De mixage externe et const

C++17 inline variables

Si vous pensez que vous voulez un extern const, alors il est plus probable que vous voulez vraiment utiliser C++17 inline variables.

Ce génial C++17 fonction de nous permettre de:

• utilisation pratique d'une seule adresse de mémoire pour chaque constante
• le stocker en tant que constexpr: Comment déclarer constexpr extern?
• le faire en une seule ligne à partir d'un en-tête

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

#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;
}

Compiler et exécuter:

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 en amont.

Voir aussi: Comment puis-inline variables de travail?

C++ standard inline sur les variables

La norme C++ garantit que les adresses seront les mêmes. C++17 N4659 projet de norme
10.1.6 "La ligne spécificateur":

6 Une fonction inline ou variable, avec une liaison externe doit avoir la même adresse dans toutes les unités de traduction.

cppreference https://en.cppreference.com/w/cpp/language/inline explique que si static n'est pas donné, alors il a une liaison externe.

Variable Inline mise en œuvre

Nous pouvons observer comment il est mis en œuvre avec:

nm main.o notmain.o

qui contient:

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

et man nm dit à propos de u:

"u" Le symbole est un unique symbole mondial. C'est une extension GNU à l'ensemble standard de ELF symbole de liaisons. Pour un symbole de l'éditeur de liens dynamique sera assurez-vous que dans l'ensemble du processus
il y a juste un symbole avec ce nom et type de l'utilisation.

nous voyons donc qu'il y a un ELFE de la prolongation pour cette.

Pré-C++ 17: extern const

extern const ne fonctionne pas comme dans l'exemple ci-dessous, mais les inconvénients en plus de inline sont:

• il n'est pas possible de faire de la variable constexpr avec cette technique, seulement inline permet: Comment déclarer constexpr extern?
• il est moins élégant que vous devez déclarer et définir la variable séparément dans l'en-tête et un fichier 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.php

#ifndef NOTMAIN_HPP
#define NOTMAIN_HPP

extern const int notmain_i;

const int* notmain_func();

#endif

GitHub en amont.

Pré-C++17-tête uniquement alternatives

Elles ne sont pas aussi bon que le extern solution, mais ils travaillent et de prendre uniquement un seul emplacement de mémoire:

Un constexpr fonction, parce que constexpr implique inline et inline permet (forces) de la définition de figurer sur chaque unité de traduction:

constexpr int shared_inline_constexpr() { return 42; }

et je parie que tout bon compilateur inline l'appel.

Vous pouvez également utiliser un const ou constexpr statique de la variable de type entier comme dans:

#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;
}

mais vous ne pouvez pas faire des choses comme la prise de son adresse, ou autre chose, elle devient odr-utilisé, voir aussi: https://en.cppreference.com/w/cpp/language/static "Constante de membres statiques" et La définition de constexpr données membres statiques

Toute façon de l'inclure?

TODO: est-il possible de pleinement inline de la variable, sans utiliser toute la mémoire à tout?

Ressemble beaucoup à ce que le préprocesseur n'.

Cela nécessiterait en quelque sorte:

• interdisant ou de détecter si l'adresse de la variable est pris
• ajouter cette information à l'ELFE de fichiers de l'objet, et laissez-LTO optimiser jusqu'

Connexes:

• C++11 enum avec les membres de la classe et constexpr lien-optimisation du temps d'

Testé sur Ubuntu, 18.10, GCC 8.2.0.

Vous pouvez les utiliser ensemble et vous pouvez faire toutes sortes de choses qui ignorent le mot-clé const, parce que c'est tout ce qu'il est; un mot-clé. Il indique au compilateur que vous ne serez pas en changeant une variable qui à son tour permet au compilateur de faire quelque chose d'utile optomisations et vous empêche de changer les choses que tu ne voulais pas.

Possibility.com a un article décent avec un peu plus de fond.