Re: 'global' data
On May 19, 8:30 am, Jeff Schwab <j...@schwabcenter.com> wrote:
forums...@hotmail.com wrote:
Anyway, if you want to code the discardable thing explicitly you can u=
se the
template const tric:
Could you elaborate on the template ocnst trick? Did a google search=
,
thumbed through Josuttis, C++ template text but I'm coming up short.
Static members of class templates may be defined in headers, and appear
in multiple translation units.
I suspect there's two parts of this that's throwing me for a loop
(template has a tendency to do that to me though :) )
template< typename Dummy >
double const Math_<Dummy>::pi = 3.14;
Here dummy is not deducible. T/F?
That's still just part of the template definition. Dummy is a
typename-id, not actually a typename.
typedef Math_<void> Math;
void? I suspect is all part of the trick?
The actual type doesn't matter. The point is that when the template is
instantiated, Math::pi will refer to Math_<your_type_here>::pi.
Taken astep further ..
template< typename Dummy >
struct Math_
{
static double const pi;
static int const test ;
// and so on.. ownder how far i could go with this.. unnamed
enums?
As far as you want. You can even do it with non-const, non-integral,
non-primitive, non-trivial types.
Template member definitions are instantiated only if they are accessed,
so you only pay for whichever variables or functions actually get used.
For example:
#include <iostream>
namespace app {
bool was_here1, was_here2;
struct kilroy { kilroy( bool& was_here ) { was_here = true; =
} };
namespace internal {
template<typename Dummy>
struct math { static kilroy k1, k2; };
template<typename Dummy> kilroy math<Dummy>::k1( was_h=
ere1 );
template<typename Dummy> kilroy math<Dummy>::k2( was_h=
ere2 );
}
typedef internal::math<void> math;
void main() {
std::cout
<< &math::k1 << '\n' // Instantiate k1, but=
not k2.
<< was_here1 << '\n' // 1
<< was_here2 << '\n'; // 0
}
}
int main() { app::main(); }
[OT] I'm reviewing coding standards that caution against declaring
global objects in the outer scope of a program or namespace. The
standard also states that global constants shall be declared as
'static const' within the public scope of a class. Global variable
data objects shall be avoided, but when used, they shall be
encapsulated in a class and accessed through a method call (Ex:
Singleton design pattern).
Not sure if I agree with this. Not all 'global' is bad and as such
requires 'encapsulation in a class and accessed through a singleton'