如果变量声明为static在函数的作用域中,则仅初始化一次并在函数调用之间保留其值.它的生命到底是什么？它的构造函数和析构函数何时被调用？
void foo()
{
static string plonk = "When will I die?";
}
编辑:从另一个问题我提供了一个答案,链接到很多关于单身人士的问题/答案:有关单身人士的更多信息:
所以我读过Singletons的帖子:好的设计还是拐杖？
争论仍然激烈.
我认为单身人士是一种设计模式(好的和坏的).
Singleton的问题不是模式而是用户(对不起所有人).每个人和他们的父亲都认为他们可以正确地实施一个(而且从我做过的许多采访中,大多数人都做不到).此外,因为每个人都认为他们可以实现正确的Singleton,他们滥用模式并在不合适的情况下使用它(用Singletons替换全局变量!).
所以需要回答的主要问题是:
我对这篇文章的希望是,我们可以在一个地方收集(而不是谷歌和搜索多个网站)一个权威的来源,了解何时(以及如何)正确使用单身人士.同样合适的还有一份反用法和常见的不良实施清单,解释了为什么他们无法工作以及为了实现他们的弱点.
所以让球滚动:
我会举起手来说这是我用的,但可能有问题.
我喜欢"Scott Myers"在他的书"Effective C++"中处理这个主题
使用单身人士的好情况(不是很多):
- 记录框架
- 线程回收池
/*
* C++ Singleton
* Limitation: Single Threaded Design
* See: http://www.aristeia.com/Papers/DDJ_Jul_Aug_2004_revised.pdf
* For problems associated with locking in multi threaded applications
*
* Limitation:
* If you use this Singleton (A) within a destructor of another Singleton (B)
* This Singleton (A) must be fully constructed before the constructor of (B)
* is called.
*/
class MySingleton
{ …以下实现,使用延迟初始化Singleton(Meyers'Seingleton)线程安全吗？
static Singleton& instance()
{
static Singleton s;
return s;
}
如果没有,为什么以及如何使其线程安全？
既然C++ 11有多线程,我想知道在不使用互斥锁的情况下实现延迟初始化单例的正确方法是什么(出于性能原因).我想出了这个,但是我并不擅长编写无锁代码,所以我正在寻找更好的解决方案.
// ConsoleApplication1.cpp : Defines the entry point for the console application.
//
# include <atomic>
# include <thread>
# include <string>
# include <iostream>
using namespace std;
class Singleton
{
public:
Singleton()
{
}
static bool isInitialized()
{
return (flag==2);
}
static bool initizalize(const string& name_)
{
if (flag==2)
return false;// already initialized
if (flag==1)
return false;//somebody else is initializing
if (flag==0)
{
int exp=0;
int desr=1;
//bool atomic_compare_exchange_strong(std::atomic<T>* obj, T* exp, T desr)
bool willInitialize=std::atomic_compare_exchange_strong(&flag, &exp, desr); …单身类的通常模式就像
static Foo &getInst()
{
static Foo *inst = NULL;
if(inst == NULL)
inst = new Foo(...);
return *inst;
}
但是,我的理解是这个解决方案不是线程安全的,因为1)Foo的构造函数可能被多次调用(可能或可能不重要)和2)inst在返回到不同的线程之前可能没有完全构造.
一种解决方案是围绕整个方法包装一个互斥锁,但是在我真正需要它之后很长时间我就要付出同步开销.另一种选择是
static Foo &getInst()
{
static Foo *inst = NULL;
if(inst == NULL)
{
pthread_mutex_lock(&mutex);
if(inst == NULL)
inst = new Foo(...);
pthread_mutex_unlock(&mutex);
}
return *inst;
}
这是正确的做法,还是我应该注意哪些陷阱？例如,是否存在可能发生的静态初始化顺序问题,即在第一次调用getInst时,inst总是保证为NULL？
C++保证编译单元(.cpp文件)中的变量按声明顺序初始化.对于编译单元的数量,此规则分别适用于每个(我的意思是类外的静态变量).
但是,变量的初始化顺序在不同的编译单元中是不确定的.
我在哪里可以看到关于gcc和MSVC的这个订单的一些解释(我知道依赖于这是一个非常糟糕的想法 - 它只是为了理解我们在迁移到新的GCC主要和不同操作系统时遗留代码可能遇到的问题) ？
我们遇到了静态初始化命令惨败的一些问题,我正在寻找方法来梳理大量代码以找到可能发生的事件.有关如何有效地做到这一点的任何建议？
编辑:我得到了一些关于如何解决静态初始化顺序问题的好答案,但这不是我的问题.我想知道如何查找受此问题影响的对象.在这方面,Evan的答案似乎是迄今为止最好的答案; 我不认为我们可以使用valgrind,但我们可能有可以执行类似功能的内存分析工具.只有在给定构建的初始化顺序错误的情况下才能捕获问题,并且顺序可以随每个构建而改变.也许有一个静态分析工具可以捕捉到这一点.我们的平台是在AIX上运行的IBM XLC/C++编译器.
我按照以下方式编写单例c ++:
class A {
private:
static A* m_pA;
A();
virtual ~A();
public:
static A* GetInstance();
static void FreeInstance();
void WORK1();
void WORK2();
void WORK3();
}
}
A* A::GetInstance() {
if (m_pA == NULL)
m_pA = new A();
return m_pA;
}
A::~A() {
FreeInstance() // Can I write this? are there any potential error?
}
void A::FreeInstance() {
delete m_pA;
m_pA = NULL;
}
谢谢!Evan Teran和sep61.myopenid.com的回答是正确的,非常好!我的方式是错的,我希望任何人写这样的代码都可以避免我的愚蠢错误.
我的项目中的单例A有一个智能指针向量,另一个线程也可以编辑这个向量,所以当应用程序关闭时,即使我添加了很多CMutex,它总是变得不稳定.多线程错误+单身错误浪费了我一天.
// ------------------------------------------------ -----------新单例,如果您认为以下示例中存在任何问题,欢迎您进行编辑:
class A {
private:
static A* m_pA;
explicit A();
void …首先我来自JAVA.
在java中,我们创建这样的类对象.
Example example=new Example();
Example类可以有构造函数或者不能有构造函数.
我可以像这样使用c ++中的相同内容
Example* example=new Example();
建设者是强制性的.
从本教程http://www.cplusplus.com/doc/tutorial/classes/
我知道我们可以创建这样的对象.
Example example;
哪个不需要构造函数.
我有两个问题.
1)创建类对象的方式之间有什么区别.
2)如果我正在创建Example example;如何在单例类中使用它的对象.
就像我通常喜欢这样.
Sample* Singleton::get_sample() {
if (sample == NULL) {
sample = new Sample();
}
return sample;
}
如果我错了,请指导我.