const static int foo = 42;

Я бачив це в деякому коді тут на StackOverflow, і я не міг зрозуміти, що це робить. Потім я побачив кілька заплутаних відповідей на інших форумах. Я найкраще здогадуюсь, що він використовується в C для приховування константи fooвід інших модулів. Це правильно? Якщо так, навіщо хтось використовувати його в контексті C ++, де ви можете просто зробити це private?

Він використовує як C, так і C ++.

Як ви здогадалися, staticчастина обмежує сферу його дії на цю компіляційну одиницю . Він також передбачає статичну ініціалізацію. constпросто каже компілятору нікому не дозволяти його змінювати. Ця змінна або поміщається в сегмент даних або bss залежно від архітектури і може бути в пам'яті, позначеної лише для читання.

Все це, як C поводиться з цими змінними (або як C ++ ставиться до змінних простору імен). У C ++ позначений член staticподіляється всіма примірниками даного класу. Незалежно від того, приватна чи ні, це не впливає на те, що одну змінну поділяють декілька примірників. Наявність constна ньому попередить вас, чи якийсь код намагатиметься це змінити.

Якби він був суто приватним, то кожен екземпляр класу отримав би свою версію (незважаючи на оптимізатор).

Багато людей дали основний відповідь , але ніхто не вказав, що в C ++ по constзамовчуванням , щоб staticна namespaceрівні (а деякі дали невірну інформацію). Див. Стандартний розділ 3.5.3 C ++ 98.

Спочатку деякі відомості:

Блок перекладу: вихідний файл після того, як попередній процесор (рекурсивно) включив усі його файли, що включають.

Статична зв'язок: Символ доступний лише в його одиниці перекладу.

Зовнішня посилання: Символ доступний для інших перекладацьких одиниць.

В namespace рівні

Сюди входить глобальна область імен, також глобальних змінних .

static const int sci = 0; // sci is explicitly static
const int ci = 1;         // ci is implicitly static
extern const int eci = 2; // eci is explicitly extern
extern int ei = 3;        // ei is explicitly extern
int i = 4;                // i is implicitly extern
static int si = 5;        // si is explicitly static

На рівні функцій

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

Наclass рівні

staticозначає, що значення поділяється між усіма примірниками класу і constозначає, що воно не змінюється.

Цей рядок коду насправді може з’являтися в декількох різних контекстах, і хоча він поводиться приблизно однаково, є невеликі відмінності.

Сфера застосування імен

// foo.h
static const int i = 0;

' i' буде видно в кожній одиниці перекладу, яка включає заголовк. Однак, якщо ви фактично не використовуєте адресу об'єкта (наприклад, ' &i'), я майже впевнений, що компілятор буде ставитися до ' i' просто як до безпечного типу 0. Якщо ще дві одиниці перекладу беруть " &i", то адреса буде різною для кожної одиниці перекладу.

// foo.cc
static const int i = 0;

' i' має внутрішню зв'язок, і тому її не можна посилатись із-за меж цього перекладацького підрозділу. Однак знову ж таки, якщо ви не використовуєте його адресу, це, швидше за все, буде розглядатися як безпечне для типу 0.

Варто зазначити, що наступна декларація:

const int i1 = 0;

це точно так же , як static const int i = 0. Змінна в просторі імен, оголошена з, constа не явно декларована з extern, неявно статична. Якщо ви задумаєтесь над цим, комітет C ++ мав намір дозволити оголошення constзмінних у файлах заголовків, не потребуючи завжди staticключового слова, щоб уникнути порушення ODR.

Область застосування класу

class A {
public:
  static const int i = 0;
};

У наведеному вище прикладі стандарт прямо вказує, що " i" не потрібно визначати, якщо його адреса не потрібна. Іншими словами, якщо ви використовуєте лише " i" як безпечний тип 0, компілятор не визначатиме його. Однією з різниць між версіями класу та простору імен є те, що адреса ' i' (якщо використовується у двох або більше одиницях перекладу) буде однаковою для члена класу. Де використовується адреса, ви повинні мати її визначення:

// a.h
class A {
public:
  static const int i = 0;
};

// a.cc
#include "a.h"
const int A::i;            // Definition so that we can take the address

Це невелика космічна оптимізація.

Коли ти кажеш

const int foo = 42;

Ви не визначаєте константу, а створюєте змінну, доступну лише для читання. Компілятор досить розумний, щоб використовувати 42, коли він бачить foo, але він також виділить простір в ініціалізованій області даних для нього. Це робиться тому, що, як визначено, foo має зовнішні зв'язки. Інша одиниця компіляції може сказати:

extern const int foo;

Щоб отримати доступ до його вартості. Це не є хорошою практикою, оскільки цей компілятор не має поняття, яке значення foo. Він просто знає, що це const int і повинен перезавантажувати значення з пам'яті кожного разу, коли воно використовується.

Тепер, заявивши, що це статично:

static const int foo = 42;

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

Слід також зазначити, що в C ++ кращим способом запобігти виходу імен з поточного блоку компіляції є використання анонімного простору імен:

namespace {
    const int foo = 42; // same as static definition above
}

У ньому відсутній "int". Вона повинна бути:

const static int foo = 42;

У C і C ++ він оголошує цілу константу з локальним обсягом файлу значення 42.

Чому 42? Якщо ви ще не знаєте (і важко повірити, що не знаєте), це посилання на відповідь на життя, Всесвіт та все .

В C ++,

static const int foo = 42;

є кращим способом визначення та використання констант. Тобто це скоріше використовувати

#define foo 42

тому що вона не підриває систему безпеки типу.

До всіх чудових відповідей хочу додати невелику деталь:

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

1. Система CAD завантажує плагін A, який має "const int foo = 42;" в цьому.
2. Система завантажує плагін B, який має "const int foo = 23;" в цьому.
3. В результаті плагін B використовуватиме значення 42 для foo, оскільки завантажувач плагінів зрозуміє, що вже існує "foo" із зовнішнім зв'язком.

Ще гірше: крок 3 може поводитися по-різному залежно від оптимізації компілятора, механізму завантаження плагінів тощо.

У мене виникла ця проблема один раз з двома допоміжними функціями (однойменною назвою, різною поведінкою) у двох плагінах. Оголошення їх статичними вирішило проблему.

Відповідно до специфікації C99 / GNU99:

• static

  • є специфікатором класу зберігання

  • Об'єкти області файлу за замовчуванням мають зовнішню зв'язок

  • Об'єкти області файлового рівня зі статичним специфікатором мають внутрішню зв'язок

• const

  • є класифікатором типу (є частиною типу)

  • ключове слово, застосоване до безпосереднього лівого екземпляра - тобто

    • MyObj const * myVar; - некваліфікований покажчик для встановлення кваліфікованого типу об'єкта

    • MyObj * const myVar; - const кваліфікований покажчик на некваліфікований тип об'єкта

  • Найменше використання - застосовується до типу об'єкта, а не змінної

    • const MyObj * myVar; - некваліфікований покажчик для встановлення кваліфікованого типу об'єкта

ЦЕ:

static NSString * const myVar; - постійний вказівник на незмінний рядок із внутрішнім зв’язком.

Відсутність staticключового слова зробить ім’я змінної глобальним і може призвести до конфліктів імен у програмі.

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

Якщо ви ввімкнули "C ++ const statik", то це дуже ймовірно, що ви дійсно хочете використовувати це C ++ 17 вбудовані змінні .

Ця дивовижна функція 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 ++ гарантує, що адреси будуть однаковими. C ++ 17 N4659 стандартний проект 10.1.6 "Вбудований специфікатор":

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

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

Вбудована змінна версія GCC

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

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.

Pre-C ++ 17: extern const

До C ++ 17 та C, ми можемо досягти дуже подібного ефекту за допомогою a extern const , що призведе до того, що буде використано єдине місце пам'яті.

Мінуси inline:

• неможливо зробити змінну за constexprдопомогою цієї методики, inlineдозволяє лише : Як оголосити constexpr extern?
• він менш елегантний, оскільки вам доведеться оголошувати та визначати змінну окремо у файлі заголовка та cpp

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.cpp

#include "notmain.hpp"

const int notmain_i = 42;

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

notmain.hpp

#ifndef NOTMAIN_HPP
#define NOTMAIN_HPP

extern const int notmain_i;

const int* notmain_func();

#endif

GitHub вище за течією .

Замінники заголовка Pre-C ++ 17 лише

Це не так добре, як externрішення, але вони працюють і займають лише одне місце пам'яті:

constexprФункція, тому що constexprмає на увазіinline і inline дозволяє (сил) визначення з'являтися на кожному ЕП :

constexpr int shared_inline_constexpr() { return 42; }

і я маю надію, що будь-який пристойний компілятор вкладе в дзвінок.

Ви також можете використовувати constабо constexprстатичну змінну, як у:

#include <iostream>

struct MyClass {
    static constexpr int i = 42;
};

int main() {
    std::cout << MyClass::i << std::endl;
    // undefined reference to `MyClass::i'
    //std::cout << &MyClass::i << std::endl;
}

але ви не можете робити такі речі, як прийняття його адреси, інакше він стає odr-використаний, див. також: Визначення членів статичних даних constexpr

С

У C ситуація така ж, як у C ++ до C ++ 17, я завантажив приклад за адресою: Що означає "статичний" у C?

Єдина відмінність полягає в тому, що в C ++, constмається staticна увазі для глобальних, але це не в C: C ++ семантиці `статичного const` проти` const`

Будь-який спосіб його повністю накреслити?

TODO: Чи є спосіб повністю вбудувати змінну, не використовуючи взагалі ніякої пам'яті?

Наче схоже на те, що робить препроцесор.

Для цього потрібно якось:

• заборона або виявлення, чи взята адреса змінної
• додайте цю інформацію до об’єктних файлів ELF, і дозвольте LTO оптимізувати її

Пов'язані:

• C ++ 11 перерахунок з членами класу та оптимізацією часу зв’язку contexpr

Випробувано в Ubuntu 18.10, GCC 8.2.0.

Так, він приховує змінну в модулі від інших модулів. У C ++ я використовую його, коли мені не хочеться / не потрібно змінювати .h-файл, що спричинить непотрібну перебудову інших файлів. Також я ставлю статику першим:

static const int foo = 42;

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

Ця глобальна константа видима / доступна лише в модулі компіляції (.cpp-файл). BTW, що використовує статичну для цієї мети, застаріла. Краще використовувати анонімний простір імен і перерахунок:

namespace
{
  enum
  {
     foo = 42
  };
}

Зробити його приватним все одно означатиме, що він з’являється у заголовку. Я схильний використовувати «найслабший» спосіб, який працює. Дивіться цю класичну статтю Скотта Майєрса: http://www.ddj.com/cpp/184401197 (мова йде про функції, але їх можна застосувати і тут).