C++ - enum против const против #define

Рассмотрим этот код,

#define WIDTH 300

enum econst
{
   eWidth=300
};

const int Width=300;

struct sample{};

int main() 
{
        sample s;
        int x = eWidth * s; //error 1
        int y = WIDTH * s;  //error 2
        int z = Width * s;  //error 3
        return 0;
}

Очевидно, что каждое умножение приводит к ошибке компиляции, но посмотрите, как GCC генерирует сообщения для каждой ошибки умножения:

prog.cpp:19: ошибка: нет совпадения для 'operator*' в 'eWidth * s'
prog.cpp:20: ошибка: нет совпадения для 'operator*' в '300 * s'
prog. cpp: 21: ошибка: не соответствует «оператор *» в «Ширина * s»

В сообщении об ошибке вы не видите макрос WIDTH, который у вас есть #defined, верно? Это связано с тем, что к моменту, когда GCC пытается скомпилировать строку, соответствующую второй ошибке, он не видит WIDTH, всего видит только 300, так как до того, как GCC скомпилирует строку, препроцессор уже заменил WIDTH с 300. С другой стороны, ничего подобного не происходит с enum eWidth и const Width.

Посмотрите на ошибку здесь: http://www.ideone.com/naZ3P

Также прочтите Item 2 : Prefer consts, enums, and inlines to #defines из Effective C++ Скотта Мейерса.

enum — это постоянная времени компиляции с отладочной информацией без выделения памяти.

const выделяется хранилищем, в зависимости от того, оптимизировано ли оно компилятором с постоянным распространением.

#define не имеет места для хранения.

#define значения заменяются препроцессором на значение, в котором они объявлены, поэтому в отладчике он видит только значение, а не имя #defined, например если у вас #define NUMBER_OF_CATS 10, в отладчике вы увидите только 10 (поскольку препроцессор заменил каждый экземпляр NUMBER_OF_CATS в вашем коде на 10.

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

Компилятор сохраняет информацию о перечислении в двоичном файле, когда программа компилируется с определенными параметрами.

Когда переменная имеет тип перечисления, отладчик может показать имя перечисления. Лучше всего это показать на примере:

enum E {
    ONE_E = 1,
};

int main(void)
{
    enum E e = 1;

    return 0;
}

Если вы скомпилируете это с помощью gcc -g, вы можете попробовать следующее в gdb:

Reading symbols from test...done.
(gdb) b main
Breakpoint 1 at 0x804839a: file test.c, line 8.
(gdb) run
Starting program: test 

Breakpoint 1, main () at test.c:7
7               enum E e = 1;
(gdb) next
9               return 0;
(gdb) print e
$1 = ONE_E
(gdb) 

Если бы вы использовали определение, у вас не было бы подходящего типа для предоставления e, и вам пришлось бы использовать целое число. В этом случае компилятор напечатает 1 вместо ONE_E.

Флаг -g просит gdb добавить отладочную информацию в двоичный файл. Вы даже можете увидеть, что он есть, выполнив:

xxd test | grep ONE_E

Однако я не думаю, что это будет работать во всех архитектурах.

По крайней мере, для Visual Studio 2008, который сейчас у меня под рукой, это предложение верно. Если у вас есть

#define X 3
enum MyEnum
{
    MyX = 3
};

int main(int argc, char* argv[])
{
    int i = X;
    int j = (int)MyX;
    return 0;
}

и вы устанавливаете точку останова в main, вы можете навести указатель мыши на «MyX» и увидеть, что он оценивается как 3. Вы не увидите ничего полезного, если наведете курсор на X.

Но это не свойство языка, а скорее поведение IDE. Следующие версии могут делать это по-другому, как и другие IDE. Так что просто проверьте его для своей IDE, чтобы увидеть, применимо ли это предложение в вашем случае.

Я отвечаю слишком поздно, но чувствую, что могу что-то добавить — enum, const и #define.

перечисление –

1. Не требует присвоения значений (если вы просто хотите иметь последовательные значения 0, 1, 2..), тогда как в случае #define вам нужно вручную управлять значениями, которые иногда могут вызвать человеческую ошибку
2. Он работает так же, как переменная, чтобы во время онлайн-отладки значение enum можно было наблюдать в окне просмотра.

3. У вас может быть переменная типа перечисления, которой вы можете назначить перечисление

   номера перечисления typedef { DFAULT, CASE_TRUE, CASE_OTHER, };

   int main(void) {число чисел = CASE_TRUE; }

константа –

1. It is constant stored in read only area of memory but can be accessed using address which is not possible in case of #define
   1. You have type check in your hand if you use const rather than #define

2. определения являются директивой предварительной обработки, но const - это время компиляции, например

   const char *name = "викас";

Вы можете получить доступ к имени и использовать его базовый адрес для чтения, например, vikas[3] для чтения «a» и т. д.

#define — это тупые директивы препроцессора, которые выполняют замену текста.

Проверьте следующую статью, хорошее резюме http://www.queryhome.com/26340/define-vs-enum-vs-constant