Визначення глобальної константи в C ++

Я хочу визначити константу в C ++, яка буде видимою у кількох вихідних файлах. Я можу уявити наступні способи визначити це у файлі заголовка:

1. #define GLOBAL_CONST_VAR 0xFF
2. int GLOBAL_CONST_VAR = 0xFF;
3. Деяка функція, що повертає значення (наприклад int get_GLOBAL_CONST_VAR())
4. enum { GLOBAL_CONST_VAR = 0xFF; }
5. const int GLOBAL_CONST_VAR = 0xFF;
6. extern const int GLOBAL_CONST_VAR; і в одному вихідному файлі const int GLOBAL_CONST_VAR = 0xFF;

Варіант (1) - це точно не той варіант, який ви хотіли б використовувати

Варіант (2) - визначення екземпляра змінної в кожному об'єктному файлі за допомогою заголовного файлу

Варіант (3) - ІМО в більшості випадків перестає вбивати

Варіант (4) - у багатьох випадках, можливо, поганий, оскільки enum не має конкретного типу (C ++ 0X додасть можливість визначити тип)

Тому в більшості випадків мені потрібно вибирати між (5) та (6). Мої запитання:

1. Що ви віддаєте перевагу (5) чи (6)?
2. Чому (5) - нормально, а (2) - ні?

(5) говорить саме те, що ви хочете сказати. Плюс це дозволяє компілятору оптимізувати його більшу частину часу. (6) з іншого боку, не дозволяє компілятору ніколи оптимізувати його, оскільки компілятор не знає, зміниш ти його з часом чи ні.

Безумовно, скористайтеся варіантом 5 - це безпечний тип і дозволяє компілятору оптимізувати (не приймайте адресу цієї змінної :) Також якщо він знаходиться в заголовку - вставте його у простір імен, щоб уникнути забруднення глобальної області дії:

// header.hpp
namespace constants
{
    const int GLOBAL_CONST_VAR = 0xFF;
    // ... other related constants

} // namespace constants

// source.cpp - use it
#include <header.hpp>
int value = constants::GLOBAL_CONST_VAR;

(5) є "кращим", ніж (6), оскільки він визначається GLOBAL_CONST_VARяк інтегральний постійний вираз (ICE) у всіх одиницях перекладу. Наприклад, ви зможете використовувати його як розмір масиву та як мітку регістру у всіх одиницях перекладу. У випадку (6) GLOBAL_CONST_VARбуде ICE лише в тій одиниці перекладу, де вона визначена, і лише після пункту визначення. В інших одиницях перекладу це не буде працювати як ICE.

Однак майте на увазі, що (5) забезпечує GLOBAL_CONST_VARвнутрішній зв'язок, що означає, що "ідентичність адреси" GLOBAL_CONST_VARбуде відрізнятися в кожній одиниці перекладу,&GLOBAL_CONST_VAR дасть вам різне значення покажчика в кожній одиниці перекладу. У більшості випадків використання це не має значення, але якщо вам потрібен константний об'єкт, який має послідовну глобальну "ідентичність адреси", то вам доведеться піти з (6), жертвуючи ДВГ-константою константи в процес.

Крім того, коли ДВС константи не є проблемою (не інтегральним типом), а розмір типу збільшується (не скалярний тип), тоді (6) зазвичай стає кращим підходом, ніж (5).

(2) не в порядку, оскільки GLOBAL_CONST_VARin (2) за замовчуванням має зовнішній зв'язок. Якщо ви помістите його у файл заголовка, ви, як правило, отримаєте кілька визначень GLOBAL_CONST_VAR, що є помилкою. constОб'єкти в C ++ мають внутрішню зв'язок за замовчуванням, саме тому (5) працює (і саме тому, як я вже говорив вище, ви отримуєте окремий, незалежний GLOBAL_CONST_VARу кожному блоці перекладу).

Починаючи з C ++ 17, у вас є можливість декларування

inline extern const int GLOBAL_CONST_VAR = 0xFF;

у файлі заголовка. Це дає вам ICE у всіх одиницях перекладу (як і метод (5)), одночасно підтримуючи глобальну ідентичність адреси GLOBAL_CONST_VAR- у всіх одиницях перекладу він матиме однакову адресу.

Якщо ви використовуєте C ++ 11 або пізнішу версію, спробуйте використати константи часу компіляції:

constexpr int GLOBAL_CONST_VAR{ 0xff };

Якщо це буде константа, тоді ви повинні позначити її як константу - ось чому 2, на мій погляд, погано.

Компілятор може використовувати const-характер значення, щоб розширити деякі математичні показники, та й інші операції, що використовують це значення.

Вибір між 5 і 6 - ммм; 5 мені просто легше.

У 6) значення непотрібно відокремлюється від його декларації.

Як правило, у мене буде один або кілька із цих заголовків, які визначають лише константи і т.д. всередині них, а потім жодних інших «розумних» речей - приємних легких заголовків, які легко можна включити де завгодно.

Щоб відповісти на ваше друге запитання:

(2) є незаконним, оскільки порушує правило Єдиного визначення. Він визначає GLOBAL_CONST_VARу кожному файлі, куди він включений, тобто більше одного разу. (5) є законним, оскільки на нього не поширюється правило Єдиного визначення. Кожне GLOBAL_CONST_VAR- це окреме визначення, локальне для того файлу, куди воно включено. Звичайно, усі ці визначення мають однакову назву та значення, але їх адреси можуть відрізнятися.

C ++ 17 inlineзмінних

Ця чудова функція C ++ 17 дозволяє нам:

• зручно використовувати лише одну адресу пам'яті для кожної константи
• зберігати як constexpr: Як оголосити constexpr extern?
• зробити це в один рядок з одного заголовка

main.cpp

#include <cassert>

#include "notmain.hpp"

int main() {
    // Both files see the same memory address.
    assert(&notmain_i == notmain_func());
    assert(notmain_i == 42);
}

notmain.hpp

#ifndef NOTMAIN_HPP
#define NOTMAIN_HPP

inline constexpr int notmain_i = 42;

const int* notmain_func();

#endif

notmain.cpp

#include "notmain.hpp"

const int* notmain_func() {
    return &notmain_i;
}

Скомпілюйте та запустіть:

g++ -c -o notmain.o -std=c++17 -Wall -Wextra -pedantic notmain.cpp
g++ -c -o main.o -std=c++17 -Wall -Wextra -pedantic main.cpp
g++ -o main -std=c++17 -Wall -Wextra -pedantic main.o notmain.o
./main

GitHub вгору за течією .

Дивіться також: Як працюють вбудовані змінні?

Стандарт C ++ для вбудованих змінних

Стандарт С ++ гарантує, що адреси будуть однаковими. C ++ 17 N4659 стандартний проект 10.1.6 "Вбудований специфікатор":

6 Вбудована функція або змінна із зовнішнім зв'язком повинна мати однакову адресу у всіх одиницях перекладу.

cppreference https://en.cppreference.com/w/cpp/language/inline пояснює, що якщо staticне вказано, то воно має зовнішній зв'язок.

Вбудована змінна змінної

Ми можемо спостерігати, як це реалізується за допомогою:

nm main.o notmain.o

який містить:

main.o:
                 U _GLOBAL_OFFSET_TABLE_
                 U _Z12notmain_funcv
0000000000000028 r _ZZ4mainE19__PRETTY_FUNCTION__
                 U __assert_fail
0000000000000000 T main
0000000000000000 u notmain_i

notmain.o:
0000000000000000 T _Z12notmain_funcv
0000000000000000 u notmain_i

і man nmкаже про u:

"u" Символ - це унікальний глобальний символ. Це розширення GNU до стандартного набору прив'язок символів ELF. Для такого символу динамічний компонувальник забезпечить, щоб у всьому процесі використовувався лише один символ із цією назвою та типом.

тому ми бачимо, що для цього існує спеціальне розширення ELF.

Перевірено на GCC 7.4.0, Ubuntu 18.04.

const int GLOBAL_CONST_VAR = 0xFF;

тому що це константа!

Це залежить від ваших вимог. (5) є найкращим для найбільш звичайного використання, але часто призводить до постійного зайняття місця в кожному об'єктному файлі. (6) може обійти це в ситуаціях, коли це важливо.

(4) також є гідним вибором, якщо вашим пріоритетом є гарантування того, що місце для зберігання ніколи не виділяється, але, звичайно, воно працює лише для інтегральних констант.

#define GLOBAL_CONST_VAR 0xFF // this is C code not C++
int GLOBAL_CONST_VAR = 0xFF; // it is not constant and maybe not compilled
Some function returing the value (e.g. int get_LOBAL_CONST_VAR()) // maybe but exists better desision
enum { LOBAL_CONST_VAR = 0xFF; } // not needed, endeed, for only one constant (enum elms is a simple int, but with secial enumeration)
const int GLOBAL_CONST_VAR = 0xFF; // it is the best
extern const int GLOBAL_CONST_VAR; //some compiller doesn't understand this