[Dúvida] Utilidade dos enumeradores

[1named]

Boa noite,

Gostaria de saber como acessar o valor de uma enumerador, porque pelo que entendi até agora só dá para iniciar um tipo enumerador já setando seu valor. Vou tentar explicar melhor no código:

 

//enum use
#include <iostream>
using namespace std;

int main()
{
	//Imaginemos que seja o menu de seleção de dificuldade de um jogo:
    
    int num //Prentendo pedir um valor para o user 1-4 correspondentes aos valores das dificuldades
    		//e em seguida imprimir na tela do usuário
    
    enum dif //Dificuldade
    {
    	EASY,
        NORMAL,
        HARDCORE,
        INSANE
    };
    
    dif myDif;
    
    cout << "Select difficulty [1-4]: " << endl;
    cin >> num;
    
   //Agora, pelo lógica eu poderia acessar qualquer um dos valores do enum myDif presentes em dif (easy, normal, etc)
   //Através dos números, visto que o enum começa do 0 caso não seja setado nenhum valor para as variáveis...
   //Então, vou tentar iniciar a dita cuja:

	cout << myDif::num << endl; 
    cout << myDif.num << endl;
    cout << myDif>>num << endl;
    cout << myDif->num << endl;
    //Todas as formas acima dão algum erro.
    
    system("pause");
    return 0;
}

A minha dúvida é: Como eu acesso os valores dentro do enum myDif? Como notaram estou tentando acessar como se acessa os valores de um array.

Observação: Qual é a utilidade de uma enumeração se eu não posso acessar atrás de um index seu conteúdo, já tenho que setar de cara?

Obrigado pela atenção e tempo dispensados;

[]'s

[vangodp]

Servem para enumerar coisas de forma mais ou menos organizadas:
 

#include <iostream>
using namespace std;

enum Dif {
    EASY,   // Aqui é onde dif toma valor 0, poderia fazer EASY = 10, então NORMAL tomaria 11, HARDCORE 12 e INSANE 13, ou poderia indicar todos os valores.
    NORMAL,
    HARDCORE,
    INSANE
};


int main () {
    int dificuldade = 3;
    
    if ( dificuldade == EASY ) {
        cout << "Escolhido: EASY" << endl;
    } else if(dificuldade == NORMAL ) {
        cout << "Escolhido: NORMAL" << endl;
    }else if(dificuldade == HARDCORE ) {
        cout << "Escolhido: HARDCORE" << endl;
    }else if(dificuldade == INSANE ) {
        cout << "Escolhido: INSANE" << endl;
    }else{
        cout << "não existe essa opcao" << endl;
    }
    
    Dif d;       //Dif é o tipo d é a variavel do tipo Dif
    d = NORMAL; //<-sempre temos que indicar o valor
    cout << "a: " << d << endl;
    cout << "b: " <<  HARDCORE << endl; //Podemos usar diretamente como se de constante se tratasse
	//Não posso fazer algo como NORMAL = outro_valor    
    
    cin.ignore();
    return 0;
}

Outro exemplo:

#include <iostream>
using namespace std;

enum op { SAIR, OPCAO1, OPCAO2, OPCAO3 };
               // |
               // |
int main () {  // v
    op my_op = OPCAO1;

    int opcao = 1;
    
    if ( opcao == my_op ){
        cout << "iguais" << endl;
    }else{
        cout << "diferentes" << endl;
    }
    
    //Igual que
    if ( opcao == OPCAO1 ){
        cout << "iguais" << endl;
    }else{
        cout << "diferentes" << endl;
    }    
    
    cin.ignore();
    return 0;
}

 

Para fazer um menú como esse:

#include <iostream>
using namespace std;

enum op { SAIR, OPCAO1, OPCAO2, OPCAO3 };


int main () {
    int opcao;
    bool sair = false;
    
    while ( !sair ) {
        cout << "Escolha opcao";
        cin >> opcao;
        cin.sync();
        
        switch ( opcao ) {
            case SAIR:
                sair = true;
                cout << "saindo" << endl;
                break;
            case OPCAO1:
                cout << "opcao1" << endl;
                break;
            case OPCAO2:
                cout << "opcao2" << endl;
                break;
            case OPCAO3:
                cout << "opcao3" << endl;
                break;            
            default:
                cout << "default" << endl;
                break;
        }
    }
    
    
    cin.ignore();
    return 0;
}

valeu!?

Resumindo... myDif só pode tomar um dos valores do enunciado dif EASY, NORMAL, HARDCORE, INSANE. Ou você pode usar diretamente esses valores de dif como se fossem constantes.

mydif é uma porção de memória reservada, como int por exemplo, se você não der um valor vai conter lixo ou pode que NULL, acho que com isso já respondo sua duvida do por que se deve inicializar.

[1named]

@vangodp Obrigado pela resposta! Então para finalizar, só um esclarecimento: Então não tem como eu mostrar o valor da minha constante enumerada usando somente o cout, como se faz com um array? E.g.: cout << array[3] << endl;?

Já que preciso iniciá-la com um dos valores do enumerado que a inicia né?

Novamente agradeço pela atenção, foi muito esclarecedora,

[]'s

Editado Julho 20, 2016 por 1named

[vangodp]

você pode jogar esses valores em um array.

array[0]= EASY;
array[1]= NORMAL;
array[2]= HARDCORE;

ou

array[0]= 0;
array[1]= 1;
array[2]= 2;

É a mesma coisa.

[1named]

6 horas atrás, vangodp disse:

você pode jogar esses valores em um array.

array[0]= EASY;
array[1]= NORMAL;
array[2]= HARDCORE;

ou

array[0]= 0;
array[1]= 1;
array[2]= 2;

É a mesma coisa.

Mas eu não posso fazer o mesmo com um enumerador certo?

enum dif
{
	EASY = 1,
    NORMAL,
    HARD
};

dif myDif = 1; //isso vai retornar um erro, já:
dif myDif = EASY; //não vai retornar erro algum

Falando que não se pode iniciar uma entidade do tipo int. Ou seja: Ele aparentemente não reconhece o EASY como sendo o número 1 do enumerador e acha que estou tentando setar um novo valor para um tipo constante. Está entendendo o que está me confundindo? Se é um enumerador iniciando outro, porque raios ele não reconhece o número 1 como sendo o primeiro valor do indexer?

Obrigado, abraços.

Editado Julho 21, 2016 por 1named
Acréscimo

[vangodp]

Se tentar fazer dif myDif = 1; para que precisamos de enumerados? Um int cumpriria perfeitamente esse papel não acha? Um enumerado você só pode por o valor que declarar entre as chaves, se não fosse assim podíamos por qualquer valor igual que um inteiro. Um enum se supõe que deve ser seteado em tempo de compilação, e da forma que você diz seria possível fazer em tempo de execução. Busque também sobre enum class.

[1named]

11 minutos atrás, vangodp disse:

Se tentar fazer dif myDif = 1; para que precisamos de enumerados? Um int cumpriria perfeitamente esse papel não acha? Um enumerado você só pode por o valor que declarar entre as chaves, se não fosse assim podíamos por qualquer valor igual que um inteiro. Um enum se supõe que deve ser seteado em tempo de compilação, e da forma que você diz seria possível fazer em tempo de execução. Busque também sobre enum class.

O 1 seria o mesmo que EASY (1 == EASY), eu pensava que era assim. Então, como eu acesso o valor de um valor do enumerado? Tipo, como eu acesso esse 1 do EASY? Obrigado pela atenção, []'s

[vangodp]

pois bool b = (1==EASY);, se for correto b vai conter 1(true).
Porem sua duvida vem relacionado ao objeto do tipo dif, pois esse tipo de variável especial só pode conter os valores que estão dentro das chaves  EASY, NORMAL, HARD.. para isso você precisa usar os identificadores EASY, NORMAL e HARD que foram declarados se não seria possível por qualquer valor, e para isso já está os inteiros.

a única vantagem que vejo nesses enum é para coisas como:
 

    enum Cores{ AZUL, BRANCO, VERDE, AMARELO };
    int n = 1;
    switch (n) {
        case AZUL:    cout << "AZUL"    << endl;
            break;
        case BRANCO:  cout << "BRANCO"  << endl;
            break;
        case VERDE:   cout << "VERDE"   << endl;
            break;
        case AMARELO: cout << "AMARELO" << endl;
            break;
        default:
            break;
    }

 

É bem mais fácil que lembrar de numeros 0. 1, 2...:

    int n = 1;
    switch (n) {
        case 0:    cout << "AZUL"    << endl;
            break;
        case 1:  cout << "BRANCO"  << endl;
            break;
        case 2:   cout << "VERDE"   << endl;
            break;
        case 3: cout << "AMARELO" << endl;
            break;
        default:
            break;
    }

 

E para coisas como essa:
 

    enum Cores{ AZUL, BRANCO, VERDE, AMARELO };
    Cores branco = BRANCO;
    int cor = 1;

    if ( cor == branco){
        cout << "BRANCO"  << endl;
    }

Certamente é mais cômodo em alguns casos recordar de nomes que de valores.

[1named]

Muito obrigado @vangodp! Pela atenção e pelo tempo! Nesse último post você falou o que eu exatamente queria saber: A utilidade dos enumeradores. Administrador sinta-se a vontade para fechar o tópico, boa noite. 

[]'s