«Static const» против «#define» против «enum»

Какой из них лучше использовать среди приведенных ниже утверждений в C?

static const int var = 5;

или

#define var 5

или

enum { var = 5 };

Это зависит от того, для чего вам нужно значение. Вы (и все остальные до сих пор) пропустили третий вариант:

1. static const int var = 5;
2. #define var 5
3. enum { var = 5 };

Игнорируя вопросы о выборе имени, тогда:

• Если вам нужно передать указатель, вы должны использовать (1).
• Поскольку (2), по-видимому, вариант, вам не нужно указывать указатели.
• Оба (1) и (3) имеют символ в таблице символов отладчика, что облегчает отладку. Скорее всего, у (2) не будет символа, и вам будет интересно, что это такое.
• (1) нельзя использовать в качестве измерения для массивов в глобальной области видимости; оба (2) и (3) могут.
• (1) нельзя использовать в качестве измерения для статических массивов в области действия функции; оба (2) и (3) могут.
• Под C99 все это можно использовать для локальных массивов. Технически, использование (1) подразумевало бы использование VLA (массива переменной длины), хотя размерность, на которую ссылается 'var', конечно же, была бы зафиксирована в размере 5.
• (1) нельзя использовать в таких местах, как операторы switch; оба (2) и (3) могут.
• (1) нельзя использовать для инициализации статических переменных; оба (2) и (3) могут.
• (2) может изменить код, который вы не хотели изменять, потому что он используется препроцессором; у обоих (1) и (3) не будет неожиданных побочных эффектов, подобных этому.
• Вы можете определить, было ли (2) установлено в препроцессоре; ни (1), ни (3) не позволяют этого.

Таким образом, в большинстве случаев предпочитайте enum альтернативам. В противном случае, первый и последний пункты пули, вероятно, будут контролирующими факторами, и вам нужно подумать над тем, чтобы удовлетворить оба сразу.

Если бы вы спрашивали о C ++, то каждый раз использовали бы option (1) - static const.

Вообще говоря:

static const

Потому что он уважает область и является типобезопасным.

Единственное предостережение, которое я мог видеть: если вы хотите, чтобы переменная была определена в командной строке. Есть еще альтернатива:

#ifdef VAR // Very bad name, not long enough, too general, etc..
  static int const var = VAR;
#else
  static int const var = 5; // default value
#endif

Когда это возможно, вместо макросов / многоточия используйте безопасную альтернативу.

Если вам действительно НУЖНО идти с макросом (например, вы хотите __FILE__или __LINE__), то вам лучше ОЧЕНЬ назвать свой макрос ОЧЕНЬ осторожно: в соглашении об именах Boost рекомендует использовать все прописные буквы, начиная с имени проекта (здесь BOOST_ ), просматривая библиотеку, вы заметите, что за ней (обычно) следует имя конкретной области (библиотеки), а затем значимое имя.

Это обычно делает для длинных имен :)

В C конкретно? В C правильный ответ: использовать #define(или, если это необходимо, enum)

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

Таким образом, в C выбор должен определяться тем, как вы планируете использовать свою константу. Например, вы не можете использовать const intобъект в качестве caseметки (в то время как макрос будет работать). Вы не можете использовать const intобъект в качестве ширины битового поля (пока макрос будет работать). В C89 / 90 вы не можете использовать constобъект для указания размера массива (в то время как макрос будет работать). Даже в C99 вы не можете использовать constобъект для указания размера массива, когда вам нужен массив без VLA .

Если это важно для вас, это определит ваш выбор. В большинстве случаев у вас не будет выбора, кроме как использовать #defineв C. И не забывайте другую альтернативу, которая производит истинные константы в C - enum.

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

Разница между static constи #defineзаключается в том, что первый использует память, а второй не использует память для хранения. Во-вторых, вы не можете передать адрес a, #defineтогда как вы можете передать адрес a static const. На самом деле, в зависимости от того, в каких обстоятельствах мы находимся, нам нужно выбрать одно из этих двух. Оба в своих лучших проявлениях при разных обстоятельствах. Пожалуйста, не думайте, что одно лучше другого ... :-)

Если бы это было так, Деннис Ричи оставил бы лучшего в покое ... хахаха ... :-)

В Си #defineгораздо популярнее. Вы можете использовать эти значения для объявления размеров массива, например:

#define MAXLEN 5

void foo(void) {
   int bar[MAXLEN];
}

static constНасколько мне известно, ANSI C не позволяет вам использовать s в этом контексте. В C ++ вы должны избегать макросов в этих случаях. Ты можешь написать

const int maxlen = 5;

void foo() {
   int bar[maxlen];
}

и даже опустить, staticпотому что внутренняя связь подразумевается constуже [только в C ++].

Еще одним недостатком constC является то, что вы не можете использовать значение при инициализации другого const.

static int const NUMBER_OF_FINGERS_PER_HAND = 5;
static int const NUMBER_OF_HANDS = 2;

// initializer element is not constant, this does not work.
static int const NUMBER_OF_FINGERS = NUMBER_OF_FINGERS_PER_HAND 
                                     * NUMBER_OF_HANDS;

Даже это не работает с const, так как компилятор не видит его как константу:

static uint8_t const ARRAY_SIZE = 16;
static int8_t const lookup_table[ARRAY_SIZE] = {
    1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}; // ARRAY_SIZE not a constant!

Я был бы рад использовать напечатанный constв этих случаях, иначе ...

Если вы можете сойти с рук, static constимеет много преимуществ. Он подчиняется обычным принципам области видимости, отображается в отладчике и в целом подчиняется правилам, которым подчиняются переменные.

Тем не менее, по крайней мере, в оригинальном стандарте C он не является константой. Если вы используете #define var 5, вы можете написать int foo[var];как объявление, но вы не можете сделать это (кроме как как расширение компилятора) с static const int var = 5;. Это не так в C ++, где static constверсия может использоваться везде , где может #defineверсия, и я считаю, что это также случай с C99.

Однако никогда не называйте #defineконстанту строчными буквами. Он будет отменять любое возможное использование этого имени до конца модуля перевода. Макросконстанты должны находиться в том, что фактически является их собственным пространством имен, которое традиционно состоит из заглавных букв, возможно, с префиксом.

ВСЕГДА предпочтительно использовать const вместо #define. Это потому, что const обрабатывается компилятором, а #define - препроцессором. Это похоже на то, что #define сам по себе не является частью кода (грубо говоря).

Пример:

#define PI 3.1416

Символическое имя PI никогда не будет видно компиляторам; он может быть удален препроцессором до того, как исходный код попадет в компилятор. В результате имя PI может не войти в таблицу символов. Это может сбивать с толку, если во время компиляции вы получаете ошибку, связанную с использованием константы, поскольку сообщение об ошибке может относиться к 3.1416, а не к PI. Если бы PI был определен в заголовочном файле, который вы не написали, вы бы не знали, откуда взялся этот 3.1416.

Эта проблема также может возникать в символическом отладчике, поскольку, опять же, имя, с которым вы программируете, может отсутствовать в таблице символов.

Решение:

const double PI = 3.1416; //or static const...

#define var 5принесет вам неприятности, если у вас есть такие вещи, как mystruct.var.

Например,

struct mystruct {
    int var;
};

#define var 5

int main() {
    struct mystruct foo;
    foo.var = 1;
    return 0;
}

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

Я написал программу быстрого тестирования, чтобы продемонстрировать одно отличие:

#include <stdio.h>

enum {ENUM_DEFINED=16};
enum {ENUM_DEFINED=32};

#define DEFINED_DEFINED 16
#define DEFINED_DEFINED 32

int main(int argc, char *argv[]) {

   printf("%d, %d\n", DEFINED_DEFINED, ENUM_DEFINED);

   return(0);
}

Это компилируется с этими ошибками и предупреждениями:

main.c:6:7: error: redefinition of enumerator 'ENUM_DEFINED'
enum {ENUM_DEFINED=32};
      ^
main.c:5:7: note: previous definition is here
enum {ENUM_DEFINED=16};
      ^
main.c:9:9: warning: 'DEFINED_DEFINED' macro redefined [-Wmacro-redefined]
#define DEFINED_DEFINED 32
        ^
main.c:8:9: note: previous definition is here
#define DEFINED_DEFINED 16
        ^

Обратите внимание, что enum выдает ошибку, когда define дает предупреждение.

Определение

const int const_value = 5;

не всегда определяет постоянное значение. Некоторые компиляторы (например, tcc 0.9.26 ) просто выделяют память, идентифицированную с именем "const_value". Используя идентификатор "const_value", вы не можете изменить эту память. Но вы все равно можете изменить память, используя другой идентификатор:

const int const_value = 5;
int *mutable_value = (int*) &const_value;
*mutable_value = 3;
printf("%i", const_value); // The output may be 5 or 3, depending on the compiler.

Это означает определение

#define CONST_VALUE 5

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

Хотя вопрос был о целых числах, стоит отметить, что #define и перечисления бесполезны, если вам нужна постоянная структура или строка. Они оба обычно передаются функциям как указатели. (Со строками это требуется; со структурами это намного более эффективно.)

Что касается целых чисел, если вы находитесь во встроенной среде с очень ограниченным объемом памяти, вам может потребоваться беспокоиться о том, где хранится константа и как компилируется доступ к ней. Компилятор может добавить две константы во время выполнения, но добавить две #defines во время компиляции. Константа #define может быть преобразована в одну или несколько MOV [немедленных] инструкций, что означает, что константа эффективно сохраняется в памяти программы. Константа const будет храниться в разделе .const в памяти данных. В системах с Гарвардской архитектурой могут быть различия в производительности и использовании памяти, хотя они, вероятно, будут небольшими. Они могут иметь значение для оптимизации внутренних циклов.

Не думаю, что есть ответ на вопрос «что всегда лучше», но, как сказал Матье

static const

Тип безопасен. Моя самая большая неприятность с тем #define, что при отладке в Visual Studio вы не можете наблюдать за переменной. Это дает ошибку, что символ не может быть найден.

Между прочим, альтернативой #define, которая обеспечивает правильную область видимости, но ведет себя как «настоящая» константа, является «enum». Например:

enum {number_ten = 10;}

Во многих случаях полезно определять перечисляемые типы и создавать переменные этих типов; если это сделано, отладчики могут отображать переменные в соответствии с именем перечисления.

Однако следует сделать одно важное предостережение: в C ++ перечисляемые типы имеют ограниченную совместимость с целыми числами. Например, по умолчанию нельзя выполнять арифметику с ними. Я считаю это странным поведением по умолчанию для перечислений; хотя было бы неплохо иметь тип "строгого перечисления", учитывая желание иметь C ++, в целом совместимый с C, я бы подумал, что поведение по умолчанию для типа "enum" должно быть взаимозаменяемым с целыми числами.

Простая разница:

Во время предварительной обработки константа заменяется ее значением. Таким образом, вы не можете применить оператор разыменования к определению, но вы можете применить оператор разыменования к переменной.

Как и следовало ожидать, определить быстрее, чем статическое const.

Например, имея:

#define mymax 100

ты не можешь сделать printf("address of constant is %p",&mymax); .

Но имея

const int mymax_var=100

ты можешь сделать printf("address of constant is %p",&mymax_var); .

Чтобы быть более понятным, определение заменяется его значением на этапе предварительной обработки, поэтому у нас нет переменной, хранящейся в программе. У нас есть только код из текстового сегмента программы, где использовалось определение.

Однако для статического const у нас есть переменная, которая где-то размещена. Для gcc статические константы размещаются в текстовом сегменте программы.

Выше я хотел рассказать об операторе ссылки, поэтому замените разыменование ссылкой.

Мы рассмотрели полученный ассемблерный код на MBF16X ... Оба варианта приводят к одному и тому же коду для арифметических операций (например, ADD Immediate).

Так const intчто предпочтительнее для проверки типов, пока #defineэто старый стиль. Может быть, это зависит от компилятора. Так что проверьте ваш созданный код ассемблера

Я не уверен, прав ли я, но, по моему мнению, вызов #defineзначения d намного быстрее, чем вызов любой другой обычно объявленной переменной (или константного значения). Это потому, что когда программа работает и ей нужно использовать некоторую обычно объявленную переменную, ей нужно перейти в точное место в памяти, чтобы получить эту переменную.

Напротив, когда используется #defineзначение d, программе не нужно переходить к какой-либо выделенной памяти, она просто принимает значение. Если #define myValue 7и программа вызывает myValue, она ведет себя точно так же, как и при простом вызове 7.