Re: Is this safe?
On Jul 2, 9:45 pm, Andrew Venikov <aveni...@gmail.com> wrote:
On Jun 30, 6:55 pm, Joshua Maurice <joshuamaur...@gmail.com> wrote:
Also, it gets even worse. You have static data members of template
classes. It doesn't work the way you want it to work. You have to
define static data members in a single translation unit (read: cpp
file). You cannot declare them in the header file, and you definitely
cannot have "static" in "template<typename T> static Singleton<T>*
Singleton<T>::instance_ = 0;". However, you also simply cannot define
the static data member in a cpp file because the compiler will only
instantiate the definition on demand, when the template has been
instantiated, which probably occurs in other translation units. (When
people really need to do this, they generally have a single cpp file
whch contains a template instantiation for every argument to the
template used in the entire program.) Short version: avoid static data
members of class templates if at all possible, which is quite possible
in this case.
I'm sorry, but this is simply wrong.
Yes, you have to define static data members in a single translation
unit,
but for static data members of class templates there's an exception -
they
can (and should) be defined in a header file. Something like this:
template <typename T>
class Class
{
...
static T member_;
};
template <typename T>
T Class<T::member_ = T();
not only will it compile, but it's valid C++ code. Heck, there's code
like that
all over the standard. Take a look at 14.5.1.3 for example.
All other points are very valid in my view.
I stand corrected. The section 14.5.1.3 doesn't actually say that, but
ODR 3.2/5 makes it very clear that you are allowed multiple
definitions of static data members of class templates, subject to the
usual restrictions that it is the same series of tokens, no more than
once per translation unit, the names in each definition refer to the
same things, etc. A pity that so many people are wrong as found by
google. Thank you sir.
That probably saves his design from a total rewrite, and allows a
wrapper for the eager-initialized, initialized-on-demand singleton as
a template entirely in a header:
//all in header file
//example, should make the constructors private, etc
template <typename singleton_type>
class wrapper
{
public:
static singleton_type& get()
{ static singleton_type * t = new singleton_type;
return *t;
}
private:
static bool force_init;
};
template<typename singleton_type>
bool wrapper<singleton_type>::force_init
= (wrapper<singleton_type>::get(), true);
I think that works. Thus I was wrong; you can do the eager-initialized-
on-demand singleton wrapper entirely as a template in a header. Most
excellent.
Quoting OP
template<typename T>
static Singleton<T>* Singleton<T>::instance_ = 0;
The "static" in the definition of the static data class member at
namespace scope is still entirely bogus and should not be there.
PS:
I was poking around, and it appears that while windows does not
natively supply a pthread_once equivalent, it is possible to write
your own replacement, though I'm not sure how efficient it would be
compared to something with access to the scheduler.
Dr Dobb's
May 01, 2007
Developing Lightweight, Statically Initializable C++ Mutexes
Threadsafe initialization of Singletons
http://www.ddj.com/cpp/199203083;jsessionid=SNAFSHB3022TCQSNDLRSKHSCJUNN2JVN?pgno=1
looks promising as one option. Also Boost has a pthread_once
equivalent which (almost certainly) works on windows (though I would
be somewhat concerned and confirm that on the common path it executes
at most a read barrier and a branch).
It thus appears that the correct and sane options for doing singletons
in C++ are the eager-initialized-on-demand singleton (in this post,
above), and the pthread_once singleton implemention (in one of my
posts awaiting moderation approval, reproduced here, though it could
probably use some cleanup and verification of correctness) using a
compatibility layer like Boost, or pthread_once on posix systems and
Vladimir Kliatchko's approach for pthread_once equivalent on windows
(Dr Dobb's link above).
//singleton_wrapper.hpp
#include <pthread.h>
#include <cassert>
namespace singleton_wrapper_private_impl
{ template <typename singleton_type>
singleton_type * & get_pointer()
{ static singleton_type * singleton;
return singleton;
}
}
template <typename singleton_type>
void initialize_singleton()
{ singleton_type * & pointer =
singleton_wrapper_private_impl::get_pointer<singleton_type>();
pointer = new singleton_type;
}
template <typename singleton_type>
singleton_type & singleton_wrapper()
{ //PTHREAD_ONCE_INIT presumably is a const expr,
//and thus C++03 guarantees this happens before runtime.
static pthread_once_t init_flag = PTHREAD_ONCE_INIT;
int x =
pthread_once(
&init_flag,
&initialize_singleton<singleton_type>
);
assert(0 == x);
return *
singleton_wrapper_private_impl::get_pointer<singleton_type>();
}
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]