static-members

Requirements I want a constexpr value (i.e. a compile-time constant) computed from a constexpr function. And I want both of these scoped to the namespace of a class, i.e. a static method and a static member of the class. First attempt I first wrote this the (to me) obvious way: class C1 { constexpr static int foo(int x) { return x + 1; } constexpr static int bar = foo(sizeof(int)); }; g++-4.5.3 -std=gnu++0x says to that: error: ‘static int C1::foo(int)’ cannot appear in a constant-expression error: a function call cannot appear in a constant-expression g++-4.6.3 -std=gnu++0x complains: error:

What is the best way to have a static member in a non-templated library class, without placing the burden of defining the member on the class user? Say I want to provide this class: class i_want_a_static_member { static expensive_resource static_resource_; public: void foo() { static_resource_.bar(); } }; Then the user of the class must not forget to define the static member somewhere (as already answered many times ): // this must be done somewhere in a translation unit expensive_resource i_want_a_static_member::static_resource_; I do have an answer below, but it has some disadvantages. Are

Consider this example code: template<class D> char register_(){ return D::get_dummy(); // static function } template<class D> struct Foo{ static char const dummy; }; template<class D> char const Foo<D>::dummy = register_<D>(); struct Bar : Foo<Bar> { static char const get_dummy() { return 42; } }; ( Also on Ideone .) I'd expect dummy to get initialized as soon as there is a concrete instantiation of Foo , which I have with Bar . This question (and the standard quote at the end) explained pretty clear, why that's not happening. [...] in particular, the initialization (and any associated side

What is the difference between a static member function and an extern "C" linkage function ? For instance, when using "makecontext" in C++, I need to pass a pointer to function. Google recommends using extern "C" linkage for it, because "makecontext" is C. But I found out that using static works as well. Am I just lucky or... class X { public: static void proxy(int i) {} } makecontext(..., (void (*)(void)) X::proxy, ...); vs extern "C" void proxy(int i) {} makecontext(..., (void (*)(void)) proxy, ...); EDIT: Can you show a compiler or architecture where the static member version does not work

It recently occured to me that the following (sample) enumeration... enum Color { Red, Green, Yellow, Blue } ... could be replaced with a seemingly more type-safe class: class Color { private Color() { } public static readonly Color Red = new Color(); public static readonly Color Green = new Color(); public static readonly Color Yellow = new Color(); public static readonly Color Blue = new Color(); } With "type-safe", I mean that the following statement would work if Color was an enum, but not if Color were the above class: var nonsenseColor = (Color)17; // works if Color is an enum Two

I'm trying to convert the following Objective-C code to Swift. In my Objective-C code, there's a static variable and its accessed from a class method. @implementation SomeClass static NSMutableArray *_items; + (void)someMethod { [_items removeAll]; } @end Since you can't access types declared like this private var items = [AnyObject]() from class functions in Swift, I created a stored property for it like this. class var items: [AnyObject] { return [AnyObject]() } And I'm trying to call a method on it from a class function like so. class func someFunction() { items.removeAll(keepCapacity:

Recently tried the following program and it compiles, runs fine and produces expected output instead of any runtime error. #include <iostream> class demo { public: static void fun() { std::cout<<"fun() is called\n"; } static int a; }; int demo::a=9; int main() { demo* d=nullptr; d->fun(); std::cout<<d->a; return 0; } If an uninitialized pointer is used to access class and/or struct members behaviour is undefined, but why it is allowed to access static members using null pointers also. Is there any harm in my program? TL;DR : Your example is well-defined. Merely dereferencing a null pointer is