greska pri buildanju, ENUM i petlja koja vrti vrijednosti definisane enum

[ refa @ 12.01.2007. 10:53 ] @

enum direction{UP, RIGHT, DOWN, LEFT, CENTER};
direction i;
for (i=UP; i<=LEFT; int(i)++){
....
}

zasto to ne mogu da kompajliram
naime ono sto zelim je da izvrtim za svaki od mogucih smijerova kroz petlju
ali dobijem error

error C2105: '++' needs l-value

kako to da rijesim

[ X Files @ 12.01.2007. 11:01 ] @

Ako traži "l-value", onda probaj /netestirano/:

umesto:
int(i)++

stavi:
i=i+1

[ NastyBoy @ 12.01.2007. 12:58 ] @

Ne mozhesh "direction" da korisitish kao tip i onda da trazhish "++".

Dovoljno je da deklarishesh i kao "int i"

[ SuPeR_MaSteR @ 12.01.2007. 16:17 ] @

Citat:

NastyBoy: Ne mozhesh "direction" da korisitish kao tip

U starom dobrom C-u ne mozes, ali C++ to podrzava i bez upotrebe typedef.
Potrebno je preklopiti operator++ i radice kako treba. Evo resenja:

Code:

#include <iostream>
using namespace std;
enum direction {UP,RIGHT,DOWN,LEFT,CENTER};
direction operator++(direction& arg); // prefix
direction operator++(direction& arg,int); // postfix
ostream& operator<<(ostream& os,direction& arg);
int main()
{
    for (direction i = UP; i <= LEFT; i++)
       cout << i << endl;
    return 0;
}
direction operator++(direction &arg) // prefix
{
    int temp = arg;    temp++;
    arg = static_cast<direction>(temp);
    return arg;
}
direction operator++(direction& arg,int) // postfix
{
    direction before = arg;
    int temp = arg;    temp++;
    arg = static_cast<direction>(temp);
    return before;
}
ostream& operator<<(ostream& os,direction& arg)
{
    switch (arg)
    {
        case UP:
            os << "UP";
            break;
        case RIGHT:
            os << "RIGHT";
            break;
        case DOWN:
            os << "DOWN";
            break;
        case LEFT:
            os << "LEFT";
            break;
        case CENTER:
            os << "CENTER";
         break;
    }
    return os;
}

[ tosa @ 12.01.2007. 18:27 ] @

Citat:

SuPeR_MaSteR: U starom dobrom C-u ne mozes, ali C++ to podrzava i bez upotrebe typedef.
Potrebno je preklopiti operator++ i radice kako treba.

Ovime si napisao istu stvar na daleko nečitljiviji i manje smislen način.
I dalje imaš konverziju iz integer-a u enum i obrnuto...

[ SuPeR_MaSteR @ 12.01.2007. 19:15 ] @

Zasto necitljiviji? A na kraju svega, moze se kod smestiti u header file pa bi bilo _citljivije_
Imam konverziju, ali i implementaciju koja je sakrivena od glavnog programa tako da se operator++ koristi kao i sa osnovnim tipovima.

Code:
for (int i = UP; i <= LEFT; i++)

^ Ovako se moze uraditi ali refa je trazio da bude:

Code:
direction i;

[ NastyBoy @ 12.01.2007. 19:27 ] @

Koja je poenta ove rasprave?

U C++u postoji implicitna konverzija enum->int dok obrnuto ne vazhi. Preklapanje operatora u enum tipu? Chemu? enum ionako ne podrzhava agregaciju, i u sushtini jeste int. Sve shto ja vidim u predlozhenim reshenjima je komplikacija zarad komplikacije.

[ X Files @ 13.01.2007. 16:24 ] @

Citat:

Koja je poenta ove rasprave?

Poenta ove rasprave je da nema poente, to si u pravu.

Ideja ovog izraza:

Code:

direction i; // direction => enum
for (i=...

... je pretpostavljam postici iteraciju (enumeraciju) svih vrednosti u okviru enum liste,
dakle nešto što je foreach u drugim jezicima, ili postići nešno što liči na Pascal kod,
koji je laganije manipulisao custom tipovima.

Neka me neko ispravi ako grešim, ali enum u C/C++ jezicima nema ugradjen elegantan način za
iteraciju kroz enum (koji može imati 'šupljine').

Prema tome treba promeniti dizajn.

[ tosa @ 14.01.2007. 10:26 ] @

Neka isprave mene ako grešim, ali po standardu svaki enum ima vrednost prethodnog + 1, tj. nema "šupljina".
Prva vrednost enum-a je nula i svaki sledeći je uvećan za jedan, osim ako nije drugačije naznačeno.

Code:

enum Primer
{
    ovo,                // vrednost je 0
    je,                 // vrednost je 1
    primer,             // vrednost je 2
    vrednosti = 23,
    enumeracija         // vrednost je 24
}

Tako da nema potrebe da menja dizajn, uz činjenicu koju je Bojan pomenuo da je konverzija enum u int implicitna.

[ X Files @ 14.01.2007. 10:49 ] @

Ja sam mislio na ovo:

Code:

enum direction{ PRVI, DRUGI=6, TRECI, CETVRTI, PETI };
direction i;
for ( i=PRVI; i<=PETI; i+=1 ) // <--- ovde sam stavio i+=1 umesto i++, da bi moglo da se kompajlira (zbog onog L value)
{
ShowMessage( i );
}
// Rezultat:
// 0 1 2 3 4 5 6 7 8 9

// Ono sto (valjda) korisnik hoce je da uzme REDOM vrednosti PET elemenata, ma koje vrednosti bile:
// 0 6 7 8 9

EDIT:
Drugim rečima, mislim da je hteo da postigne nešto ovako:
http://www.elitesecurity.org/t238173-0#1428586

P.S.

Ima ovde jedan zanimljiv kod za C#:
http://blogs.msdn.com/mitsu/ar...6/10/08/Enumerating-Enums.aspx

_{[Ovu poruku je menjao X Files dana 14.01.2007. u 12:03 GMT+1]}

[ tosa @ 14.01.2007. 13:50 ] @

Kod koji si napisao nije validan u C++-u (i neće se kompajlirati), možda tvoj kompajler to
dopušta ali to samo znači da je loš. Pored toga, refa nije koristio custom vrednosti enum-a,
tako da je ova kompletna priča bespotrebna.