[英]How to declare constexpr extern?
Is it possible to declare a variable extern constexpr
and define it in another file? 是否可以声明变量
extern constexpr
并将其定义在另一个文件中?
I tried it but the compiler gives error: 我试过了,但是编译器给出了错误:
Declaration of
constexpr
variable 'i
' is not a definitionconstexpr
变量'i
'的声明不是定义
in .h: 在.h中:
extern constexpr int i;
in .cpp: 在.cpp中:
constexpr int i = 10;
no you can't do it, here's what the standard says (section 7.1.5): 不,您不能做,这是标准所说的(第7.1.5节):
1 The constexpr specifier shall be applied only to the definition of a variable or variable template, the declaration of a function or function template, or the declaration of a static data member of a literal type (3.9).
1 constexpr说明符应仅应用于变量或变量模板的定义,函数或函数模板的声明或文字类型的静态数据成员的声明(3.9)。 If any declaration of a function, function template, or variable template has a constexpr specifier, then all its declarations shall contain the constexpr specifier.
如果函数,函数模板或变量模板的任何声明都有constexpr说明符,则其所有声明都应包含constexpr说明符。 [Note: An explicit specialization can differ from the template declaration with respect to the constexpr specifier.
[注意:就constexpr说明符而言,显式专门化可能与模板声明不同。 Function parameters cannot be declared constexpr.
函数参数不能声明为constexpr。 — end note ]
—尾注]
some examples given by the standard: 标准给出的一些例子:
constexpr void square(int &x); // OK: declaration
constexpr int bufsz = 1024; // OK: definition
constexpr struct pixel { // error: pixel is a type
int x;
int y;
constexpr pixel(int); // OK: declaration
};
extern constexpr int memsz; // error: not a definition
C++17 inline
variables C ++ 17
inline
变量
This awesome C++17 feature allow us to: 强大的C ++ 17功能使我们能够:
constexpr
constexpr
main.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.hpp notmain.hpp
#ifndef NOTMAIN_HPP
#define NOTMAIN_HPP
inline constexpr int notmain_i = 42;
const int* notmain_func();
#endif
notmain.cpp notmain.cpp
#include "notmain.hpp"
const int* notmain_func() {
return ¬main_i;
}
Compile and run: 编译并运行:
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
The C++ standard guarantees that the addresses will be the same. C ++标准保证地址相同。 C++17 N4659 standard draft 10.1.6 "The inline specifier":
C ++ 17 N4659标准草案 10.1.6“内联说明符”:
6 An inline function or variable with external linkage shall have the same address in all translation units.
6具有外部链接的内联函数或变量在所有翻译单元中应具有相同的地址。
cppreference https://en.cppreference.com/w/cpp/language/inline explains that if static
is not given, then it has external linkage. cppreference https://zh.cppreference.com/w/cpp/language/inline解释说,如果未指定
static
,则它具有外部链接。
See also: How do inline variables work? 另请参阅: 内联变量如何工作?
Tested in GCC 7.4.0, Ubuntu 18.04. 已在GCC 7.4.0,Ubuntu 18.04中测试。
No. Extern constexpr does not make any sense. 否。Externconstexpr没有任何意义。 Please read http://en.cppreference.com/w/cpp/language/constexpr
请阅读http://en.cppreference.com/w/cpp/language/constexpr
ie the bit " it must be immediately constructed or assigned a value. " 即位“必须立即构造或为其赋值”。
I agree with 'swang' above, but there is a consequence. 我同意上面的“ swang”,但是有一个结果。 Consider:
考虑:
ExternHeader.hpp ExternHeader.hpp
extern int e; // Must be extern and defined in .cpp otherwise it is a duplicate symbol.
ExternHeader.cpp ExternHeader.cpp
#include "ExternHeader.hpp"
int e = 0;
ConstexprHeader.hpp ConstexprHeader.hpp
int constexpr c = 0; // Must be defined in header since constexpr must be initialized.
Include1.hpp Include1.hpp
void print1();
Include1.cpp Include1.cpp
#include "Include1.hpp"
#include "ExternHeader.hpp"
#include "ConstexprHeader.hpp"
#include <iostream>
void print1() {
std::cout << "1: extern = " << &e << ", constexpr = " << &c << "\n";
}
Include2.hpp Include2.hpp
void print2();
Include2.cpp Include2.cpp
#include "Include2.hpp"
#include "ExternHeader.hpp"
#include "ConstexprHeader.hpp"
#include <iostream>
void print2() {
std::cout << "2: extern = " << &e << ", constexpr = " << &c << "\n";
}
main.cpp main.cpp
#include <iostream>
#include "Include1.hpp"
#include "Include2.hpp"
int main(int argc, const char * argv[]) {
print1();
print2();
return 0;
}
Which prints: 哪些打印:
1: extern = 0x1000020a8, constexpr = 0x100001ed0
2: extern = 0x1000020a8, constexpr = 0x100001ed4
IE the constexpr
is allocated twice whereas the extern
is allocated once. 即
constexpr
分配两次,而extern
分配一次。 This is counterintuitive to me, since I 'expect' constexpr
to be more optimized than extern
. 这对我来说是违反直觉的,因为我“期望”
constexpr
比extern
更优化。
Edit: const
and constexpr
have the same behaviour, with regard to allocation, therefore from that point of view the behaviour is as expected. 编辑:就分配而言,
const
和constexpr
具有相同的行为,因此,从该角度来看,行为是预期的。 Though, as I said, I was surprised when I came across the behaviour of constexpr
. 但是,正如我所说,当我遇到
constexpr
的行为时,我感到很惊讶。
Yes it somewhat is... 是的, 有点 ...
//===================================================================
// afile.h
#ifndef AFILE
#define AFILE
#include <cstddef>
#include <iostream>
enum class IDs {
id1,
id2,
id3,
END
};
// This is the extern declaration of a **constexpr**, use simply **const**
extern const int ids[std::size_t(IDs::END)];
// These functions will demonstrate its usage
template<int id> void Foo() { std::cout << "I am " << id << std::endl; }
extern void Bar();
#endif // AFILE
//===================================================================
// afile.cpp
#include "afile.h"
// Here we define the consexpr.
// It is **constexpr** in this unit and **const** in all other units
constexpr int ids[std::size_t(IDs::END)] = {
int(IDs::id1),
int(IDs::id2),
int(IDs::id3)
};
// The Bar function demonstrates that ids is really constexpr
void Bar() {
Foo<ids[0] >();
Foo<ids[1] + 123>();
Foo<ids[2] / 2 >();
}
//===================================================================
// bfile.h
#ifndef BFILE
#define BFILE
// These functions will demonstrate usage of constexpr ids in an extern unit
extern void Baz();
extern void Qux();
#endif // BFILE
//===================================================================
// bfile.cpp
#include "afile.h"
// Baz demonstrates that ids is (or works as) an extern field
void Baz() {
for (int i: ids) std::cout << i << ", ";
std::cout << std::endl;
}
// Qux demonstrates that extern ids cannot work as constexpr, though
void Qux() {
#if 0 // changing me to non-0 gives you a compile-time error...
Foo<ids[0]>();
#endif
std::cout << "Qux: 'I don't see ids as consexpr, indeed.'"
<< std::endl;
}
//===================================================================
// main.cpp
#include "afile.h"
#include "bfile.h"
int main(int , char **)
{
Bar();
Baz();
Qux();
return 0;
}
What you probably want is extern and constexpr initialization, eg: 您可能想要的是extern和constexpr初始化,例如:
// in header
extern const int g_n;
// in cpp
constexpr int g_n = 2;
This is support though in Visual Studio 2017 only through conformance mode: 尽管仅通过一致性模式在Visual Studio 2017中提供了此支持:
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.