compilation error

[John Harrison]

Slightly surprised that the following didn't compile

#inclue <algorithm>
enum { C = 10 };
int main()
{
char a[C];
std::fill_n(a, C, '\0');
}

Error message points to implementation of std::fill_n and complains that

unary '--' : '' does not define this operator or a conversion to a type
acceptable to the predefined operator

Essentially I think its complaining that it can't modify the value of the
enum C.

Is this correct? I expected the template to be instantiated with an int
which could be modified using operator--.

Replacing enum { C = 10 }; with const int C = 10; does compile.

John

[John Harrison]

"Pete Becker" <pe********@acm .org> wrote in message
news:3F******** *******@acm.org ...

John Harrison wrote:

"Pete Becker" <pe********@acm .org> wrote in message
news:3F******** *******@acm.org ...

John Harrison wrote:
>
> That's very strange because since enums are often used for ordinal types

you

> would think that if any arithmetic operators were to be defined then

it > would be ++ and --. Just an oversight I guess.
>

Nope, deliberate. We didn't want to require compiler writers to generate increment and decrement code for things like this:

enum flags { 0x01, 0x02, 0x04, 0x08, 0x10 };

OK I can buy that but then why define unary minus?

--, ++, +=, etc. all must create values of the same type as their
operand. Unary minus, as well as the rest of the arithmetic operators,
create integral values. Read about the "usual arithmetic conversions."

OK makes sense, in a twisted kind of way.

john

[John Harrison]

"Pete Becker" <pe********@acm .org> wrote in message
news:3F******** ******@acm.org. ..

John Harrison wrote:

"Pete Becker" <pe********@acm .org> wrote in message
news:3F******** *******@acm.org ...

John Harrison wrote:
>
> "Pete Becker" <pe********@acm .org> wrote in message
> news:3F******** *******@acm.org ...
> > John Harrison wrote:
> > >
> > > That's very strange because since enums are often used for

ordinal types

> you
> > > would think that if any arithmetic operators were to be defined

then it

> > > would be ++ and --. Just an oversight I guess.
> > >
> >
> > Nope, deliberate. We didn't want to require compiler writers to

generate

> > increment and decrement code for things like this:
> >
> > enum flags { 0x01, 0x02, 0x04, 0x08, 0x10 };
> >
>
> OK I can buy that but then why define unary minus?
>

--, ++, +=, etc. all must create values of the same type as their
operand. Unary minus, as well as the rest of the arithmetic operators,
create integral values. Read about the "usual arithmetic conversions."

OK makes sense, in a twisted kind of way.

Why do you call it twisted?

Your explanation makes perfect sense, and the current situation is not an
oversight at all (as I impudentally suggested) but a result of careful
consideration by the standard committee.

Nevertheless, from my point of view, it's still the case that the two
operators that it would make most sense for the standard to define behaviour
for (operator++ and operator--) have no behaviour defined. While operators
which are pretty meaningless for enum do have behaviour defined.

john

[Rob Williscroft]

John Harrison wrote in news:bf******** ****@ID-196037.news.uni-berlin.de:

Your explanation makes perfect sense, and the current situation is not
an oversight at all (as I impudentally suggested) but a result of
careful consideration by the standard committee.

Nevertheless, from my point of view, it's still the case that the two
operators that it would make most sense for the standard to define
behaviour for (operator++ and operator--) have no behaviour defined.
While operators which are pretty meaningless for enum do have
behaviour defined.

If the behaviour was defined, like it is for int say, you couldn't
do this:

#include <iostream>
#include <ostream>

enum myEnum
{
A, B, C
};

myEnum operator+(myEnu m a, myEnum b)
{
int i = (int(a) + int(b)) % int(C + 1);
return myEnum(i);
}

myEnum &operator++(myE num &a)
{
int i = (int(a) + 1) % int(C + 1);
a = myEnum(i);
return a;
}

myEnum operator++(myEn um &a, int)
{
int i = (int(a) + 1) % int(C + 1);
myEnum b = a;
a = myEnum(i);
return b;
}
int main()
{
myEnum a, b, e;
a = B;
b = C;
e = a + b;

std::cout << int(e) << std::endl;

std::cout << int(++e) << std::endl;

std::cout << int(e++) << std::endl;

std::cout << int(e) << std::endl;

}
Rob.
--
http://www.victim-prime.dsl.pipex.com/