In the header I declared
#ifndef SOUND_CORE #define SOUND_CORE static SoundEngine soundEngine; ... but the constructor for SoundEngine gets called multiple times, how is it possible, when it's declared as global static
I call it as
#include "SoundCore.h" and use it directly
soundEngine.foo() thank you
I would use extern instead of static. That's what extern is for.
In the header:
extern SoundEngine soundEngine; In an accompanying source file:
SoundEngine soundEngine; This will create one translation unit with the instance, and including the header will allow you to use it everywhere in your code.
// A.cpp #include <iostream> // other includes here ... extern int hours; // this is declared globally in B.cpp int foo() { hours = 1; } // B.cpp #include <iostream> // other includes here ... int hours; // here we declare the object WITHOUT extern extern void foo(); // extern is optional on this line int main() { foo(); } A copy of static variables declared in header files gets created for each translation unit where you include the header.
Never declare your static variables inside header files.
You could use a singleton object.
extern objects have issues (both from a design point of view, and from the way they work in C++). My preferred approach is to instantiate the object inside a function (main() or something similarly high in the call chain), and pass a reference (or possibly a smart pointer, depending on how complicated the objects' lifetimes are) to everything that needs it.
As others mentioned in the answers, static variable in header file gets included in every file where the the header is included. If you want to still keep it static and avoid multiple instantiations then wrap it in a struct.
//SoundCore.h struct Wrap { static SoundEngine soundEngine; }; Now define this variable in one of the .cpp files.
//SoundCore.cpp SoundEngine Wrap::soundEngine; And use it simply as,
Wrap::soundEngine.foo(); 
extern at namespace scope?
extern is the best idea for such single variables. Since @rubenvb already suggested the same; I gave this another way (saying if you still want to keep it static).static keyword, which has a different meaning in this context. This is precisely equivalent to making it extern (i.e. it changes the linkage from internal to external), but with an extra layer of confusion caused by introducing a meaningless class.If you include this header file in multiple files, your class will be instantiated for every inclusion. I think you better take a look at Singleton pattern, to get only 1 instance, i.e., just one constructor call.
As many other reserved words, static is a modifier that has different meanings according with the context.
In this case, you are creating an object of the class SoundEngine which is private in this module. This means that it is not visible from other modules.
However, you put this line in the header, so it is a private object in various modules. I guess that's the reason of the constructor being called multiple times.
