Exemplo mínimo executável
Esse incrível recurso do C ++ 17 nos permite:
- use convenientemente apenas um único endereço de memória para cada constante
- armazene-o como
constexpr
: Como declarar constexpr extern?
- faça isso em uma única linha a partir de um cabeçalho
main.cpp
#include <cassert>
#include "notmain.hpp"
int main() {
// Both files see the same memory address.
assert(¬main_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 ¬main_i;
}
Compile e execute:
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 upstream .
Consulte também: Como as variáveis embutidas funcionam?
Padrão C ++ em variáveis embutidas
O padrão C ++ garante que os endereços serão os mesmos. Rascunho padrão do C ++ 17 N4659
10.1.6 "O especificador em linha":
6 Uma função em linha ou variável com ligação externa deve ter o mesmo endereço em todas as unidades de tradução.
A cppreference https://en.cppreference.com/w/cpp/language/inline explica que, se static
não for fornecida, ela terá ligação externa.
Implementação de variável em linha do GCC
Podemos observar como é implementado com:
nm main.o notmain.o
que contém:
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
e man nm
diz sobre u
:
"u" O símbolo é um símbolo global exclusivo. Esta é uma extensão GNU para o conjunto padrão de ligações de símbolos ELF. Para esse símbolo, o vinculador dinâmico garantirá que, durante todo o processo, exista apenas um símbolo com esse nome e digite em uso.
então vemos que há uma extensão ELF dedicada para isso.
Pré-C ++ 17: extern const
Antes de C ++ 17 e em C, podemos obter um efeito muito semelhante a um extern const
, o que levará a um único local de memória sendo usado.
As desvantagens inline
são:
- não é possível fazer a variável
constexpr
com esta técnica, apenas inline
permite que: Como declarar constexpr extern?
- é menos elegante, pois é necessário declarar e definir a variável separadamente no cabeçalho e no arquivo cpp
main.cpp
#include <cassert>
#include "notmain.hpp"
int main() {
// Both files see the same memory address.
assert(¬main_i == notmain_func());
assert(notmain_i == 42);
}
notmain.cpp
#include "notmain.hpp"
const int notmain_i = 42;
const int* notmain_func() {
return ¬main_i;
}
notmain.hpp
#ifndef NOTMAIN_HPP
#define NOTMAIN_HPP
extern const int notmain_i;
const int* notmain_func();
#endif
GitHub upstream .
Apenas alternativas de cabeçalho pré-C ++ 17
Eles não são tão bons quanto a extern
solução, mas funcionam e ocupam apenas um único local de memória:
Uma constexpr
função, porque constexpr
implicainline
e inline
permite (força) a definição para aparecer em todas as unidades de tradução :
constexpr int shared_inline_constexpr() { return 42; }
e aposto que qualquer compilador decente atenderá a chamada.
Você também pode usar uma variável inteira estática const
ou constexpr
como em:
#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;
}
mas você não pode fazer coisas como usar o endereço, ou ele se torna usado por odr, consulte também: https://en.cppreference.com/w/cpp/language/static "Membros estáticos constantes" e Definição de dados estáticos constexpr membros
C
Em C, a situação é a mesma que C ++ pré C ++ 17, enviei um exemplo em: O que significa "estático" em C?
A única diferença é que, em C ++, const
implica static
em globais, mas não na semântica de C: C ++ de `const const` vs` const`
Alguma maneira de incorporá-lo totalmente?
TODO: existe alguma maneira de alinhar totalmente a variável, sem usar nenhuma memória?
Muito parecido com o que o pré-processador faz.
Isso exigiria de alguma forma:
- proibir ou detectar se o endereço da variável é usado
- adicione essas informações aos arquivos de objeto ELF e deixe o LTO otimizá-las
Palavras-chave:
Testado no Ubuntu 18.10, GCC 8.2.0.
const
.