Utilizzando enum all'interno tipi - avviso del compilatore C4482 C ++

Question

Sto usando il nome completo del enum all'interno di un metodo in uno della mia classe. Ma io sono sempre avviso del compilatore che dice "avviso C4482: estensione non standard utilizzata: enum 'Foo' utilizzato nel nome qualificato" . In C ++, abbiamo bisogno di usare le enumerazioni senza il nome qualificato? Ma IMO, che sembra brutto.

Qualche idea?

Answer 1

Sì, enumerazioni non creano un nuovo "spazio dei nomi", i valori nella enum sono direttamente disponibili in ambito circostante. Così si ottiene:

enum sample {
  SAMPLE_ONE = 1,
  SAMPLE_TWO = 2
};

int main() {
  std::cout << "one = " << SAMPLE_ONE << std::endl;
  return 0;
}

Answer 2

Per rendere più pulita, sostituire:

enum Fruit {

    ORANGE = 0,
    BANANA = 1

};

con

namespace Fruit {

    enum { //no enum name needed

        ORANGE = 0,
        BANANA = 1

    };

};

...

int f = Fruit::BANANA; //No warning

Answer 3

Mentre qc fa rispondere alla domanda, lo ha fatto non affronta come ho sempre usato le enumerazioni. Anche se sono solo nomi più o meno per i numeri, ho sempre usato loro di definire i tipi che possono avere solo determinati valori.

Se l'enum è parte della classe, poi che aiuta i consumatori a identificare chiaramente un riferimento enum:

class Apple {
  enum Variety {
    Gala,
    GoldenDelicious,
    GrannySmith,
    Fuji
  }
  ...
};

Poi i consumatori sarebbero casi di dichiarazione in grado di enum, passare come parametri, e qualificarli quando si fa riferimento uno dei tipi.

unsigned int GetCountOfApples( Apple::Variety appleVariety );
...
fujiCnt = GetCountOfApples( Apple::Fuji );

A volte si vuole un enum al di fuori di una classe o due enumerazioni nella stessa classe, e si può fare qualcosa di simile a quello che aveva Poy. Non sarà in grado di fare riferimento al tipo enum, però, quindi basta il nome.

namespace Color {
  enum ColorEnum {
    Blue,
    Red,
    Black
  };

Ora con l'enum e valori avrebbero funzionato come:

Color::ColorEnum firstColor = Color::Blue;
Color::ColorEnum secondColor = Color::Red;

if( firstColor == secondColor )
....

Ora, se vi capita di essere diverse enumerazioni con lo stesso nome in loro, essi saranno sempre qualificati con che tipo sono. Poi si potrebbe gestire ciò che gamblor sta chiedendo circa.

BananaColorEnum banCol = BananaColor::Yellow;
TomatoColorEnum tomCol = TomatoColor::Yellow;

Answer 4

Sì. enum concettualmente definisce un tipo, ed i possibili valori di quel tipo. Anche se sembra naturale, per definire enum foo { bar, baz }; e quindi consultare foo::baz è lo stesso come riferito a int::1.

Answer 5

namespace Company
{
    typedef int Value;
    enum
    {
        Microsoft= 0,
        APPLE = 1, 
    };
};

namespace Fruit
{
    typedef int Value;
    enum
    {
        ORANGE = 0,
        BANANA = 1,
        APPLE = 2, 
    };
};

...

Fruit::Value f = Fruit::BANANA; //No warning
Company::Value f = Company::APPLE; //is different value then Fruit::APPLE

Questo funziona su GCC e MS compilatore e Mac. E il vantaggio è che è possibile utilizzare operatore di namespace e superare i conflitti. Il piccolo svantaggio è che invece di frutta, si deve scrivere Frutta :: Valore. è più utile nel grande progetto quando non si sa che cosa le enumerazioni sono in altra classe.

Se è possibile utilizzare C ++ 11, invece, è molto più semplice, perché la sintassi enum :: namespace è quindi possibile.

Answer 6

Il modo più pulito che ho trovato per fare questo è definire l'enum come tale

namespace Samples
{
    enum Value
    {
        Sample1,
        Sample2,
        Sample3
    };
}
typedef Samples::Value Sample;

Poi nella funzione e definizioni di variabili è possibile utilizzare il typedef:

void Function(Sample eSample);
Sample m_eSample;

E nel file cpp è possibile utilizzare lo spazio dei nomi per assegnare le variabili:

void Function(Sample eSample)
{
    m_eSample = Samples::Sample1;
    eSample = Samples::Sample2;
}

Answer 7

Personalmente, penso che questo sia un errore del compilatore. Sto usando C ++ per un sacco di tempo. Purtroppo, nessun codice di esempio in OP. L'interpretazione di un enum da parte del popolo di Java era in realtà corretta IMO. Mine, era come questo ...

class Foo {
    enum tMyEnum { eFirstVal = 0, eSecondVal = 1};
    // ...
    tMyEnum m_myVal;
};
void Foo::MyMethod() {
    if(m_myVal == tMyEnum::eFirstVal) {
//  ...
    }
}

Ho anche provato, Foo :: :: tMyEnum eFirstVal. Senza le qualificazioni, tutto compilato.

Answer 8

Ho avuto lo stesso problema e non sto usando C ++ 11 ancora. Preferisco di gran lunga gli spazi dei nomi pienamente qualificati me stesso.

ho disabilitato questo particolare allarme. Sono sicuro che la gente non piace l'idea, ma alcuni possono essere grati ..

#pragma warning( disable : 4482 )