Как использовать перечисления в C ++

Предположим, у нас есть что-то enumвроде следующего:

enum Days {Saturday, Sunday, Tuesday, Wednesday, Thursday, Friday};

Я хочу создать экземпляр этого enumи инициализировать его с надлежащим значением, поэтому я делаю:

Days day = Days.Saturday;

Теперь я хочу проверить мою переменную или экземпляр с существующим enumзначением, поэтому я делаю:

if (day == Days.Saturday)
{
    std::cout << "Ok its Saturday";
}

Что дает мне ошибку компиляции:

ошибка: ожидаемое первичное выражение перед '.' знак

Итак, чтобы было ясно, в чем разница между высказыванием:

if (day == Days.Saturday) // Causes compilation error

и

if (day == Saturday)

?

Что эти два на самом деле ссылаются, в том, что один в порядке, а другой вызывает ошибку компиляции?

Этот код неверен:

enum Days {Saturday, Sunday, Tuesday, Wednesday, Thursday, Friday};
Days day = Days.Saturday;
if (day == Days.Saturday)

Потому что Daysэто не сфера и не объект. Это тип. И сами типы не имеют членов. То, что вы написали, эквивалентно std::string.clear. std::stringэто тип, поэтому вы не можете использовать .его. Вы используете .на экземпляре класса.

К сожалению, перечисления являются волшебными, и аналогия на этом заканчивается. Потому что с классом вы можете сделать, std::string::clearчтобы получить указатель на функцию-член, но в C ++ 03, Days::Sundayявляется недействительным. (Что грустно). Это потому, что C ++ (в некоторой степени) обратно совместим с C, а C не имеет пространств имен, поэтому перечисления должны были находиться в глобальном пространстве имен. Таким образом, синтаксис просто:

enum Days {Saturday, Sunday, Tuesday, Wednesday, Thursday, Friday};
Days day = Saturday;
if (day == Saturday)

К счастью, Майк Сеймур отмечает, что это было решено в C ++ 11. Измените enumна enum classи получите свою собственную область; это Days::Sundayне только допустимо, но и является единственным способом доступа Sunday. Счастливые дни!

Этого будет достаточно, чтобы объявить переменную enum и сравнить ее:

enum Days {Saturday, Sunday, Tuesday, Wednesday, Thursday, Friday};
Days day = Saturday;
if (day == Saturday) {
    std::cout << "Ok its Saturday";
}

Многое из этого должно дать вам ошибки компиляции.

// note the lower case enum keyword
enum Days { Saturday, Sunday, Monday, Tuesday, Wednesday, Thursday, Friday };

Теперь Saturday, Sundayи т.д. могут быть использованы в качестве голых констант верхнего уровня, и Daysможет быть использован в качестве типа:

Days day = Saturday;   // Days.Saturday is an error

И аналогично позже, чтобы проверить:

if (day == Saturday)
    // ...

Эти enumзначения , как голые константы - они ип -scoped - с небольшой дополнительной помощи со стороны компилятора: (если вы не используете ++ 11 C классов перечислений ) , они не инкапсулированы как объекта или структуры элементов , например, и вы не можете обратиться к ним в качестве членов в Days.

Вы получите то, что ищете, с C ++ 11 , который представляет enum class:

enum class Days
{
    SUNDAY,
    MONDAY,
    // ... etc.
}

// ...

if (day == Days::SUNDAY)
    // ...

Обратите внимание, что этот C ++ немного отличается от C в двух отношениях, во-первых, C требует enumобъявления ключевого слова при объявлении переменной:

// day declaration in C:
enum Days day = Saturday;

Вы можете использовать трюк для использования областей по своему усмотрению, просто объявите enum следующим образом:

struct Days 
{
   enum type
   {
      Saturday,Sunday,Tuesday,Wednesday,Thursday,Friday
   };
};

Days::type day = Days::Saturday;
if (day == Days::Saturday)

Вместо того, чтобы использовать кучу операторов if, перечисления хорошо подходят для переключения операторов

В построителе уровней, которые я строю для своей игры, я использую несколько комбинаций enum / switch.

РЕДАКТИРОВАТЬ: Еще одна вещь, я вижу, вы хотите синтаксис похож на;

if(day == Days.Saturday)
etc

Вы можете сделать это в C ++:

if(day == Days::Saturday)
etc

Вот очень простой пример:

EnumAppState.h

#ifndef ENUMAPPSTATE_H
#define ENUMAPPSTATE_H
enum eAppState
{
    STARTUP,
    EDIT,
    ZONECREATION,
    SHUTDOWN,
    NOCHANGE
};
#endif

Somefile.cpp

#include "EnumAppState.h"
eAppState state = eAppState::STARTUP;
switch(state)
{
case STARTUP:
    //Do stuff
    break;
case EDIT:
    //Do stuff
    break;
case ZONECREATION:
    //Do stuff
    break;
case SHUTDOWN:
    //Do stuff
    break;
case NOCHANGE:
    //Do stuff
    break;
}

Если вы все еще используете C ++ 03 и хотите использовать перечисления, вам следует использовать перечисления внутри пространства имен. Например:

namespace Daysofweek{
enum Days {Saturday, Sunday, Tuesday,Wednesday, Thursday, Friday};
}

Вы можете использовать enum вне пространства имен, например,

Daysofweek::Days day = Daysofweek::Saturday;

if (day == Daysofweek::Saturday)
{
    std::cout<<"Ok its Saturday";
}

Вы ищете строго типизированные перечисления , функция, доступная в стандарте C ++ 11 . Превращает перечисления в классы со значениями области видимости.

Используя ваш собственный пример кода, это:

  enum class Days {Saturday, Sunday, Tuesday,Wednesday, Thursday, Friday};
  Days day = Days::Saturday;

  if (day == Days::Saturday)  {
    cout << " Today is Saturday !" << endl;
  }
  //int day2 = Days::Sunday; // Error! invalid

Использование в ::качестве средств доступа к перечислениям не удастся, если нацелено на стандарт C ++ до C ++ 11. Но некоторые старые компиляторы не поддерживают его, а некоторые IDE просто переопределяют эту опцию и устанавливают старый стандарт C ++.

Если вы используете GCC, включите C + 11 с -std = c ++ 11 или -std = gnu11 .

Будь счастлив!

Это не должно работать в C ++:

Days.Saturday

Days не является областью или объектом, который содержит членов, к которым вы можете получить доступ с помощью оператора точка. Этот синтаксис является просто C # -измом и недопустим в C ++.

Microsoft уже давно поддерживает расширение C ++, которое позволяет вам получать доступ к идентификаторам, используя оператор области действия:

enum E { A, B, C };

A;
E::B; // works with Microsoft's extension

Но это нестандартно до C ++ 11. В C ++ 03 идентификаторы, объявленные в enum, существуют только в той же области видимости, что и сам тип enum.

A;
E::B; // error in C++03

C ++ 11 делает законным квалифицировать идентификаторы перечисления с именем перечисления, а также вводит классы перечисления, которые создают новую область видимости для идентификаторов вместо того, чтобы помещать их в окружающую область видимости.

A;
E::B; // legal in C++11

enum class F { A, B, C };

A; // error
F::B;

К сожалению, элементы перечисления являются «глобальными». Вы получаете доступ к ним, делая day = Saturday. Это означает, что вы не можете иметь, enum A { a, b } ;и enum B { b, a } ;они находятся в конфликте.

Хотя C ++ (исключая C ++ 11) имеет перечисления, значения в них «просочились» в глобальное пространство имен.
Если вы не хотите, чтобы они просочились (и не НУЖНО использовать тип enum), подумайте о следующем:

class EnumName {  
   public:   
      static int EnumVal1;  
      (more definitions)  
};  
EnumName::EnumVal1 = {value};  
if ([your value] == EnumName::EnumVal1)  ...

Перечисления в C ++ похожи на целые числа, маскируемые именами, которые вы даете им, когда вы объявляете свои значения перечислений (это не определение, а лишь подсказка, как это работает).

Но в вашем коде есть две ошибки:

1. Записать enumвсе строчные
2. Вам не нужно Days.до субботы.
3. Если это перечисление объявлено в классе, используйте if (day == YourClass::Saturday){}

Я думаю, что вашей основной проблемой является использование .вместо ::, которое будет использовать пространство имен.

Пытаться:

enum Days {Saturday, Sunday, Tuesday, Wednesday, Thursday, Friday};
Days day = Days::Saturday;
if(Days::Saturday == day)  // I like literals before variables :)
{
    std::cout<<"Ok its Saturday";
}

Если мы хотим строгой безопасности типов и ограниченного перечисления, использование enum classхорошо в C ++ 11.

Если нам приходилось работать в C ++ 98, мы могли бы воспользоваться советом InitializeSahib, Sanданным для включения enum в области видимости.

Если мы также хотим строгой безопасности типов, следующий код может реализовать что-то вроде enum.

#include <iostream>
class Color
{
public:
    static Color RED()
    {
        return Color(0);
    }
    static Color BLUE()
    {
        return Color(1);
    }
    bool operator==(const Color &rhs) const
    {
        return this->value == rhs.value;
    }
    bool operator!=(const Color &rhs) const
    {
        return !(*this == rhs);
    }

private:
    explicit Color(int value_) : value(value_) {}
    int value;
};

int main()
{
    Color color = Color::RED();
    if (color == Color::RED())
    {
        std::cout << "red" << std::endl;
    }
    return 0;
}

Код изменен из примера класса Месяц в книге Эффективное C ++ 3-е: Пункт 18

Прежде всего, сделайте «E» в enum, «e» в нижнем регистре.

Во-вторых, добавьте имя типа «Дни» в «Days.Saturday».

В-третьих ... купите себе хорошую книгу по С ++.