Re: template const trick versus myers singleton - global data revisited
* ma740988:
I was perusing a thread a while back where the OP was trying to
determine how to express global data without polluting every
translation unit (TU) with global data a TU may not care about. There
was discussion about the use of a 'template constant trick' (I suspect
there's another name for this because I've come up short during a
seach of my texts and google) or a myers singleton. So now
consider:
# include <limits>
# include <iostream>
///form a
template < typename dummy >
struct consts // constants
{
//static int const MAX_INT = std::numeric_limits < int >::max
() ; //Visual studio 9 complains... check standard, i think this is
legal
static int const MAX_INT = INT_MAX ;
static double const PI ;
Try to avoid using all uppercase names, except for macros which should have such
names. This helps reduce the chance of undesired text replacement.
};
typedef consts<void> constants;
double const constants::PI = 3.14159;
In a single file program this will work, but if you do it in a header file,
which is the main point of the templated const trick, then you risk multiple
definitions, that is, running afoul of the One Definition Rule.
Instead do
template< typename Dummy >
double const consts<Dummy>::PI = 3.14159;
There is a special exemption for this, or put another way, the ODR allows this,
in order to make it possible to define templates in header files.
///form b
class c_constants {
public :
double const PI ;
static int const MAX_INT = INT_MAX ;
c_constants()
: PI ( 3.14159 )
{}
static c_constants& instance() {
static c_constants inst ;
return inst ;
}
};
int main()
{
std::cout << constants::PI << '\n';
std::cout << c_constants::instance().PI << '\n';
std::cin.get();
}
It seems to me that the prime difference between the two foms (a) and
(b) is that with (a) I'm unable to express PI without the static
keyword. True/False?
Not sure what you mean about "static keyword" but the templated const allows you
to define constants in a header file and for each such constant have only one
occurrence of the value in the final program, without relying on optimizations.
One other thing: There was discussion about static initialization
fiasco so consider:
class foo {
static int const MAGIC = 0xBEEF ;
public :
static foo& instance () { static foo inst; return inst; }
void do_work()
{ int const whatever = c_constants::instance().MAX_INT -
MAGIC; }
} ;
Here a foo object could potentially be created/initialized before
c_constant object which is used in the do_work method. Would the
static initialization fiasco matter here?
Not for this concrete example, because the static initialization fiasco is about
dynamic initialization, initialization that involves execution of user code, and
your constants are of built-in type:
First, static initialization is performed, which consists of, in order,
zero-initialization, and then
initialization with constant expressions (compile time constants),
then
dynamic initialization.
And the problem is that C++ does not strictly define the order that different
compilation units' dynamic initialization is performed in.
So with e.g. std::string constants the templated const trick in general runs the
risk of a static initialization order fiasco, since it just defines an ordinary
namespace scope constant, which might be accessed (from some other compilation
unit's dynamic initialization) before its constructor runs.
One way to avoid that is to wrap the constant in a function:
inline std::string const& piChars()
{
std::string const theValue = "3.141592654";
return theValue;
}
instead of
std::string const piChars = "3.141592654";
Cheers & hth.,
- Alf
--
Due to hosting requirements I need visits to <url: http://alfps.izfree.com/>.
No ads, and there is some C++ stuff! :-) Just going there is good. Linking
to it is even better! Thanks in advance!