在 C++ 中初始化私有静态数据成员的最佳方法是什么？我在我的头文件中尝试了这个，但它给了我奇怪的链接器错误：
class foo
{
private:
static int i;
};
int foo::i = 0;
我猜这是因为我无法从类外初始化私有成员。那么最好的方法是什么？
Jason Baker
问问题
585029 次
18 回答
618
类声明应该在头文件中（如果不共享，则在源文件中）。
文件：foo.h
class foo
{
private:
static int i;
};
但是初始化应该在源文件中。
文件：foo.cpp
int foo::i = 0;
如果初始化在头文件中，则包含头文件的每个文件都将具有静态成员的定义。因此，在链接阶段，您将收到链接器错误，因为初始化变量的代码将在多个源文件中定义。的初始化static int i必须在任何函数之外完成。
注意： Matt Curtis：指出如果静态成员变量是 const int 类型（例如int, bool, char），C++ 允许对上述内容进行简化。然后，您可以直接在头文件的类声明中声明和初始化成员变量：
class foo
{
private:
static int const i = 42;
};
于 2008-10-09T03:36:11.197 回答
104
对于变量：
富.h：
class foo
{
private:
static int i;
};
foo.cpp：
int foo::i = 0;
foo::i这是因为您的程序中只能有一个实例。它相当于extern int i在头文件和int i源文件中。
对于常量，您可以将值直接放在类声明中：
class foo
{
private:
static int i;
const static int a = 42;
};
于 2008-10-09T03:41:40.607 回答
72
从 C++17 开始，静态成员可以使用inline关键字在标头中定义。
http://en.cppreference.com/w/cpp/language/static
“静态数据成员可以内联声明。内联静态数据成员可以在类定义中定义，并且可以指定默认成员初始化程序。它不需要类外定义：”
struct X
{
inline static int n = 1;
};
于 2017-07-12T15:34:05.327 回答
33
对于这个问题的未来观众，我想指出你应该避免monkey0506 的建议。
头文件用于声明。
.cpp头文件为每个直接或间接使用它们的文件编译一次#includes，并且任何函数之外的代码在程序初始化时运行，之前main().
通过将：foo::i = VALUE;放入标题中，foo:i将为每个文件分配值VALUE（无论是什么）.cpp，并且这些分配将在运行之前以不确定的顺序（由链接器确定）发生main()。
如果我们#define VALUE在我们的一个文件中成为不同的数字.cpp怎么办？它将编译得很好，在我们运行程序之前，我们无法知道哪个获胜。
永远不要将执行的代码放入标头中，原因与您从不放入#include文件相同.cpp。
包含警卫（我同意您应该始终使用）保护您免受不同的影响：在编译单个文件时，同一个标头被间接#included 多次.cpp
于 2012-12-27T15:37:38.523 回答
23
使用 Microsoft 编译器 [1]，int也可以在头文件中定义不类似的静态变量，但在类声明之外，使用 Microsoft 特定的__declspec(selectany).
class A
{
static B b;
}
__declspec(selectany) A::b;
请注意，我并不是说这很好，我只是说可以做到。
[1] 这些天来，支持的编译器比 MSC 多__declspec(selectany)——至少 gcc 和 clang。也许更多。
于 2008-10-09T05:45:26.177 回答
18
int foo::i = 0;
是初始化变量的正确语法，但它必须放在源文件 (.cpp) 中而不是头文件中。
因为它是一个静态变量，编译器只需要创建它的一个副本。您必须在代码中的某个位置有一行“int foo:i”来告诉编译器将它放在哪里，否则会出现链接错误。如果它在标题中，您将在每个包含标题的文件中获得一个副本，因此从链接器获取多重定义的符号错误。
于 2008-10-09T03:42:18.873 回答
14
如果你想初始化一些复合类型（fe 字符串），你可以这样做：
class SomeClass {
static std::list<string> _list;
public:
static const std::list<string>& getList() {
struct Initializer {
Initializer() {
// Here you may want to put mutex
_list.push_back("FIRST");
_list.push_back("SECOND");
....
}
}
static Initializer ListInitializationGuard;
return _list;
}
};
由于ListInitializationGuard是方法内部的静态变量，SomeClass::getList()它只会被构造一次，这意味着构造函数被调用一次。这将initialize _list根据您需要的值而变化。任何后续调用都getList将简单地返回已经初始化的_list对象。
当然，您必须_list始终通过调用getList()方法来访问对象。
于 2014-11-23T11:43:15.870 回答
13
适用于多个对象的 C++11 静态构造函数模式
在以下位置提出了一个成语：https ://stackoverflow.com/a/27088552/895245 ，但这里有一个更简洁的版本，不需要为每个成员创建新方法。
主文件
#include <cassert>
#include <vector>
// Normally on the .hpp file.
class MyClass {
public:
static std::vector<int> v, v2;
static struct StaticConstructor {
StaticConstructor() {
v.push_back(1);
v.push_back(2);
v2.push_back(3);
v2.push_back(4);
}
} _staticConstructor;
};
// Normally on the .cpp file.
std::vector<int> MyClass::v;
std::vector<int> MyClass::v2;
// Must come after every static member.
MyClass::StaticConstructor MyClass::_staticConstructor;
int main() {
assert(MyClass::v[0] == 1);
assert(MyClass::v[1] == 2);
assert(MyClass::v2[0] == 3);
assert(MyClass::v2[1] == 4);
}
编译并运行：
g++ -ggdb3 -O0 -std=c++11 -Wall -Wextra -pedantic -o main.out main.cpp
./main.out
另请参阅：C++ 中的静态构造函数？我需要初始化私有静态对象
在 Ubuntu 19.04 上测试。
C++17 内联变量
提到：https ://stackoverflow.com/a/45062055/895245但这里有一个多文件可运行示例，使其更加清晰：内联变量如何工作？
这个很棒的 C++17 特性使我们能够：
- 方便地为每个常量只使用一个内存地址
- 将其存储为
constexpr：如何声明 constexpr extern？ - 从一个标题在一行中执行
主文件
#include <cassert>
#include "notmain.hpp"
int main() {
// Both files see the same memory address.
assert(¬main_i == notmain_func());
assert(notmain_i == 42);
}
不是main.hpp
#ifndef NOTMAIN_HPP
#define NOTMAIN_HPP
inline constexpr int notmain_i = 42;
const int* notmain_func();
#endif
非main.cpp
#include "notmain.hpp"
const int* notmain_func() {
return ¬main_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
于 2018-01-19T08:55:37.887 回答
9
我没有足够的代表在这里将其添加为评论，但是 IMO 无论如何用#include 防护来编写标题是一种很好的风格，正如Paranaix 几小时前所指出的那样，这可以防止多定义错误。除非您已经在使用单独的 CPP 文件，否则没有必要仅使用一个来初始化静态非整数成员。
#ifndef FOO_H
#define FOO_H
#include "bar.h"
class foo
{
private:
static bar i;
};
bar foo::i = VALUE;
#endif
我认为不需要为此使用单独的 CPP 文件。当然，你可以，但没有技术上的理由你必须这样做。
于 2012-01-07T19:42:54.520 回答
6
如果您使用标头保护，您还可以在头文件中包含分配。我已将这种技术用于我创建的 C++ 库。实现相同结果的另一种方法是使用静态方法。例如...
class Foo
{
public:
int GetMyStatic() const
{
return *MyStatic();
}
private:
static int* MyStatic()
{
static int mStatic = 0;
return &mStatic;
}
}
上面的代码具有不需要 CPP/源文件的“奖励”。同样，我用于 C++ 库的方法。
于 2013-04-11T21:50:25.020 回答
4
我遵循卡尔的想法。我喜欢它，现在我也使用它。我改变了一点符号并添加了一些功能
#include <stdio.h>
class Foo
{
public:
int GetMyStaticValue () const { return MyStatic(); }
int & GetMyStaticVar () { return MyStatic(); }
static bool isMyStatic (int & num) { return & num == & MyStatic(); }
private:
static int & MyStatic ()
{
static int mStatic = 7;
return mStatic;
}
};
int main (int, char **)
{
Foo obj;
printf ("mystatic value %d\n", obj.GetMyStaticValue());
obj.GetMyStaticVar () = 3;
printf ("mystatic value %d\n", obj.GetMyStaticValue());
int valMyS = obj.GetMyStaticVar ();
int & iPtr1 = obj.GetMyStaticVar ();
int & iPtr2 = valMyS;
printf ("is my static %d %d\n", Foo::isMyStatic(iPtr1), Foo::isMyStatic(iPtr2));
}
这输出
mystatic value 7
mystatic value 3
is my static 1 0
于 2013-12-31T14:45:25.823 回答
4
您遇到的链接器问题可能是由以下原因引起的：
- 在头文件中提供类和静态成员定义，
- 在两个或多个源文件中包含此标头。
对于那些从 C++ 开始的人来说，这是一个常见的问题。静态类成员必须在单个翻译单元中初始化，即在单个源文件中。
不幸的是，静态类成员必须在类主体之外进行初始化。这使编写仅标头代码变得复杂，因此，我使用了完全不同的方法。您可以通过静态或非静态类函数提供静态对象，例如：
class Foo
{
// int& getObjectInstance() const {
static int& getObjectInstance() {
static int object;
return object;
}
void func() {
int &object = getValueInstance();
object += 5;
}
};
于 2017-09-10T10:20:32.253 回答
3
也在 privateStatic.cpp 文件中工作：
#include <iostream>
using namespace std;
class A
{
private:
static int v;
};
int A::v = 10; // possible initializing
int main()
{
A a;
//cout << A::v << endl; // no access because of private scope
return 0;
}
// g++ privateStatic.cpp -o privateStatic && ./privateStatic
于 2014-01-26T11:21:05.630 回答
3
set_default()方法呢？
class foo
{
public:
static void set_default(int);
private:
static int i;
};
void foo::set_default(int x) {
i = x;
}
我们只需要使用该set_default(int x)方法，我们的static变量就会被初始化。
这不会与其他评论意见相左，实际上它遵循在全局范围内初始化变量的相同原则，但是通过使用这种方法，我们使其明确（并且易于理解）而不是定义的变量挂在那里。
于 2014-05-23T14:28:51.417 回答
2
以下是一个简单示例中的所有可能性和错误...
#ifndef Foo_h
#define Foo_h
class Foo
{
static const int a = 42; // OK
static const int b {7}; // OK
//static int x = 42; // ISO C++ forbids in-class initialization of non-const static member 'Foo::x'
//static int y {7}; // ISO C++ forbids in-class initialization of non-const static member 'Foo::x'
static int x;
static int y;
int m = 42;
int n {7};
};
// Foo::x = 42; // error: 'int Foo::x' is private
int Foo::x = 42; // OK in Foo.h if included in only one *.cpp -> *.o file!
int Foo::y {7}; // OK
// int Foo::y {7}; // error: redefinition of 'int Foo::y'
// ONLY if the compiler can see both declarations at the same time it,
// OTHERWISE you get a linker error
#endif // Foo_h
但最好把它放在 Foo.cpp 中。这样您就可以单独编译每个文件并稍后链接它们，否则 Foo:x 将出现在多个目标文件中并导致链接器错误。...
// Foo::x = 42; // error: 'int Foo::x' is private, bad if Foo::X is public!
int Foo::x = 42; // OK in Foo.h if included in only one *.cpp -> *.o file!
int Foo::y {7}; // OK
于 2021-09-22T07:34:35.950 回答
1
当我第一次遇到这个时，我只是想提一些对我来说有点奇怪的事情。
我需要在模板类中初始化一个私有静态数据成员。
在 .h 或 .hpp 中，初始化模板类的静态数据成员看起来像这样：
template<typename T>
Type ClassName<T>::dataMemberName = initialValue;
于 2016-10-01T01:11:21.250 回答
0
这是否符合您的目的？
//header file
struct MyStruct {
public:
const std::unordered_map<std::string, uint32_t> str_to_int{
{ "a", 1 },
{ "b", 2 },
...
{ "z", 26 }
};
const std::unordered_map<int , std::string> int_to_str{
{ 1, "a" },
{ 2, "b" },
...
{ 26, "z" }
};
std::string some_string = "justanotherstring";
uint32_t some_int = 42;
static MyStruct & Singleton() {
static MyStruct instance;
return instance;
}
private:
MyStruct() {};
};
//Usage in cpp file
int main(){
std::cout<<MyStruct::Singleton().some_string<<std::endl;
std::cout<<MyStruct::Singleton().some_int<<std::endl;
return 0;
}
于 2016-09-02T11:50:33.643 回答