[已解决]c++构造函数，静态成员和多线程问题求助

sun_chuan

最近学习c++多线程时候碰到的问题：

1. #include <iostream>
   
2. #include<thread>
   
3. #include<mutex>
   
4. #include<Windows.h>
   
5. 
   
6. static std::once_flag once;
   
7. class Log
   
8. {
   
9. public:
   
10.     //Log() {};//（问题一）我发现这里为啥非要加一个构造函数？不加构造函数就会提示“类 "Log" 不存在默认构造函数”
    
11.     Log(const Log& log) = delete;
    
12.     Log& operator=(const Log& log) = delete;
    
13. 
    
14.     static Log& GetInstance()
    
15.     {
    
16.         Log* log = NULL;
    
17.         std::call_once(once, init, log);
    
18.         return *log;
    
19.     }
    
20. 
    
21.     static void init(Log* log)
    
22.     {
    
23.         if (log == NULL)log = new Log;
    
24. 
    
25.     }
    
26. 
    
27.     void PrintLog(std::string msg)
    
28.     {
    
29.         std::cout << __TIME__ << "  " << msg << '\n';
    
30.     }
    
31. 
    
32. private:
    
33.     //static std::once_flag once; （问题二）为啥这个放在类外面就没事了？放在类里面就会报错“无法解析的外部符号 "private: static struct std::once_flag Log::once" (?once@Log@@0Uonce_flag@std@@A)”
    
34. 
    
35. };
    
36. 
    
37. void PrintError()
    
38. {
    
39.     Log::GetInstance().PrintLog("error\n");
    
40. }
    
41. 
    
42. 
    
43. 
    
44. int main()
    
45. {
    
46.     std::thread t1(PrintError);
    
47.     std::thread t2(PrintError);
    
48.     t1.join();
    
49.     t2.join();
    
50. }

复制代码

最佳答案

月排行榜 / 总排行榜

FishC

2024-7-19 13:27:20

sun_chuan 发表于 2024-07-19 13:27
为什么    static std::once_flag once;放在类里面就 ...

哈哈，C++的细节真的是一波接一波呀！让我们揭开这个谜底吧~

### 问题解析

事实上，这是因为在C++中静态成员变量的初始化规则。静态成员变量必须在类定义外面进行初始化。这是C++语言的一个规定，因为静态成员变量在所有实例中是共享的，它们并不随每个对象的创建而重新分配存储空间，而是从属于整个类的。因此，我们要在类外对它进行定义和初始化。简单来说，你需要告诉编译器，这个静态变量是在类外部定义的。

### 解决方案

你可以这样来解决这个问题：

1. 在类内部声明静态成员变量。
2. 在类外部定义并初始化静态成员变量。

下面是改进后的例子：

1. #include <iostream>
   
2. #include <mutex>
   
3. 
   
4. class Log
   
5. {
   
6. public:
   
7.     // 默认构造函数
   
8.     Log() {}
   
9. 
   
10.     // 禁用拷贝构造函数和赋值运算符
    
11.     Log(const Log& log) = delete;
    
12.     Log& operator=(const Log& log) = delete;
    
13. 
    
14.     static Log& GetInstance()
    
15.     {
    
16.         std::call_once(once, &Log::init); // 注意这里的改变
    
17.         return *log;
    
18.     }
    
19. 
    
20.     void PrintLog(std::string msg)
    
21.     {
    
22.         std::cout << msg << std::endl;
    
23.     }
    
24. 
    
25. private:
    
26.     static void init()
    
27.     {
    
28.         log = new Log;
    
29.     }
    
30. 
    
31.     static Log* log;
    
32.     static std::once_flag once;
    
33. };
    
34. 
    
35. // 在类外部定义并初始化静态成员变量
    
36. Log* Log::log = nullptr;
    
37. std::once_flag Log::once;
    
38. 
    
39. int main()
    
40. {
    
41.     Log& logger = Log::GetInstance();
    
42.     logger.PrintLog("Hello from FishC!");
    
43.     return 0;
    
44. }

复制代码

### 为什么这样做？

- **声明 vs 定义**：在类内部，你只是在声明 `std::once_flag`，告诉编译器这个类里会有一个这样的静态成员变量。但是你并没有定义它，也没有为它分配内存空间。
- **类外定义**：在类外，你才真正定义了这个静态变量，并且为它分配了内存空间和初值。

### 小幽默时刻

C++ 的这些规则就像我们做菜时的“先声明后定义”原则。你得先告诉大家“今晚吃火锅”，然后再去买菜准备食材。而不能说“我已经准备好火锅了”，但其实家里连锅还没买。这就是为啥一定要在类外定义和初始化这些静态成员变量啦！

希望这次的解释清楚明了，如果还有什么头疼的C++问题，尽管问，我会继续用通俗易懂的方式为你解答哒！

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

跳转到最佳答案楼层

FishC

哈哈，这个问题看起来蛮有意思的，尤其是要在多线程的背景下处理构造函数和静态成员的问题。让我们一条一条地解决你的疑惑吧。

### 问题一：为什么需要一个构造函数？

首先，C++中的类如果不显式声明构造函数，编译器会默认生成一个默认的构造函数。然而，如果你在类里定义了其他构造函数（即使是拷贝构造函数、移动构造函数等），编译器就不会提供默认构造函数了。所以你的代码中：

1. //Log() {}; // 注释掉了默认构造函数
   
2. Log(const Log& log) = delete;
   
3. Log& operator=(const Log& log) = delete;

复制代码

由于你手动删除了拷贝构造函数，因此编译器不会再为你生成默认构造函数。这时你就必须自己声明一个默认的构造函数（尽管它啥都不干）。

1. Log() {};  // 这个构造函数还是要有的呀！

复制代码

### 问题二：静态变量和多线程

你的 `Log` 类是个经典的单例模式实现方法，用来确保多线程情况下只有一个 `Log` 实例。根据你的代码：

1. static Log& GetInstance()
   
2. {
   
3.     Log* log = NULL;
   
4.     std::call_once(once, init, log);
   
5.     return *log;
   
6. }
   
7. 
   
8. static void init(Log* log)
   
9. {
   
10.     if (log == NULL) log = new Log;
    
11. }

复制代码

这里的问题在于：`log` 是局部变量，导致即使在 `init` 函数里 `log` 变成了指向 `new Log` 的指针，也不会回传给 `GetInstance` 里面的 `log`。

但其实这个问题可以通过以下改进来解决：

1. static Log& GetInstance()
   
2. {
   
3.     static Log* log = NULL;  // 将log变成静态的
   
4.     std::call_once(once, init, log);
   
5.     return *log;
   
6. }
   
7. 
   
8. static void init(Log*& log)
   
9. {
   
10.     if (log == NULL) log = new Log;
    
11. }

复制代码

这样一来，`log` 变成了 `GetInstance` 函数内的静态变量，并且在 `init` 函数参数里使用引用来保证修改后的值能传递回来。

### 小幽默时刻

哎呀，C++真的很像养宠物——静态成员就像我们的猫，它们喜欢独处，所有人共享一份。而多线程就像试图同时给猫喂饭的一大群人，得小心别被抓，确保大家协调好了才行！所以，使用 `std::call_once` 就像给这群人派了个小队长，确保他们不会手忙脚乱，猫也不会炸毛啦~

希望这个解释对你有帮助！如果还有什么其他疑问，请随时提问，我会继续为你解答哒！

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

sun_chuan

FishC 发表于 2024-7-19 13:21
哈哈，这个问题看起来蛮有意思的，尤其是要在多线程的背景下处理构造函数和静态成员的问题。让我们一条一条 ...

为什么    static std::once_flag once;放在类里面就报错"private: static struct std::once_flag Log::once" (?once@Log@@0Uonce_flag@std@@A)，必须放在类外面？

FishC

sun_chuan 发表于 2024-07-19 13:27
为什么    static std::once_flag once;放在类里面就 ...

哈哈，C++的细节真的是一波接一波呀！让我们揭开这个谜底吧~

### 问题解析

事实上，这是因为在C++中静态成员变量的初始化规则。静态成员变量必须在类定义外面进行初始化。这是C++语言的一个规定，因为静态成员变量在所有实例中是共享的，它们并不随每个对象的创建而重新分配存储空间，而是从属于整个类的。因此，我们要在类外对它进行定义和初始化。简单来说，你需要告诉编译器，这个静态变量是在类外部定义的。

### 解决方案

你可以这样来解决这个问题：

1. 在类内部声明静态成员变量。
2. 在类外部定义并初始化静态成员变量。

下面是改进后的例子：

1. #include <iostream>
   
2. #include <mutex>
   
3. 
   
4. class Log
   
5. {
   
6. public:
   
7.     // 默认构造函数
   
8.     Log() {}
   
9. 
   
10.     // 禁用拷贝构造函数和赋值运算符
    
11.     Log(const Log& log) = delete;
    
12.     Log& operator=(const Log& log) = delete;
    
13. 
    
14.     static Log& GetInstance()
    
15.     {
    
16.         std::call_once(once, &Log::init); // 注意这里的改变
    
17.         return *log;
    
18.     }
    
19. 
    
20.     void PrintLog(std::string msg)
    
21.     {
    
22.         std::cout << msg << std::endl;
    
23.     }
    
24. 
    
25. private:
    
26.     static void init()
    
27.     {
    
28.         log = new Log;
    
29.     }
    
30. 
    
31.     static Log* log;
    
32.     static std::once_flag once;
    
33. };
    
34. 
    
35. // 在类外部定义并初始化静态成员变量
    
36. Log* Log::log = nullptr;
    
37. std::once_flag Log::once;
    
38. 
    
39. int main()
    
40. {
    
41.     Log& logger = Log::GetInstance();
    
42.     logger.PrintLog("Hello from FishC!");
    
43.     return 0;
    
44. }

复制代码

### 为什么这样做？

- **声明 vs 定义**：在类内部，你只是在声明 `std::once_flag`，告诉编译器这个类里会有一个这样的静态成员变量。但是你并没有定义它，也没有为它分配内存空间。
- **类外定义**：在类外，你才真正定义了这个静态变量，并且为它分配了内存空间和初值。

### 小幽默时刻

C++ 的这些规则就像我们做菜时的“先声明后定义”原则。你得先告诉大家“今晚吃火锅”，然后再去买菜准备食材。而不能说“我已经准备好火锅了”，但其实家里连锅还没买。这就是为啥一定要在类外定义和初始化这些静态成员变量啦！

希望这次的解释清楚明了，如果还有什么头疼的C++问题，尽管问，我会继续用通俗易懂的方式为你解答哒！

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。