In C++, the static<\/tt> keyword has a lot of meanings. Let’s go over all of them:<\/p>\n
Meaning 1: Private Linkage<\/b><\/p>\n
This one comes from C, and it lets you mark a variable as “file private”.<\/p>\n
Example:<\/p>\n
\r\nstatic int i = 42;\r\nvoid doSomething()\r\n{\r\n cout << i;\r\n}\r\n<\/pre>\nIn this example, static<\/b> tells the compiler to not make the variable i<\/b> available from other source files. If another file tries to use i<\/b>, perhaps using the extern<\/tt> keyword, it would generate a linker error (unresolved external symbol). The same concept applies to functions whose access you want to limit to the current file.<\/p>\n
Uses:<\/b><\/p>\n
This is very handy for creating “file private” variables and functions. I recommend using static for any file-only functions. This way, you can name them whatever you like without risking a naming collision in the global namespace.<\/p>\n
Gotchas:<\/b><\/p>\n
Unfortunately, you can’t declare a class as static. Also, the language makes no guarantee about the order in which static variables are initialized. In my experience, static variables in the same file are initialized in a “sane” order, so you can do things like this:<\/p>\n
\r\nstatic int i = 42;\r\nstatic int j = i + 1;\r\n<\/pre>\nMeaning 2: Function Call Spanning<\/b><\/p>\n
This one also comes from C, and it lets you give a function-local variable a long lifespan. Here’s an example:<\/p>\n
Example:<\/p>\n
\r\nvoid foo()\r\n{\r\n static int callCount = 0;\r\n callCount++;\r\n cout << \"foo has been called \" << callCount << \" times\" << endl;\r\n}\r\n<\/pre>\nUses:<\/b><\/p>\n
it’s a great way to keep track of how many times a function has been called, so it works well for generating unique ID numbers (watch out for thread-safety!). It’s also useful to keep track of whether a function is being called for the first time ever, like this:<\/p>\n
\r\nvoid foo()\r\n{\r\n static bool firstTime = true;\r\n if(firstTime)\r\n {\r\n \/\/ Do something special here\r\n firstTime = false;\r\n }\r\n}\r\n<\/pre>\nGotchas:<\/b><\/p>\n
Static function-local variables are initialized the first time<\/b> the function is called, not before. Using these kinds of variables can often make your code not thread safe and not re-entrant, so take care before using them. You can put static variables within scope blocks (like inside an if<\/b> or for<\/b> statement). I’m not totally sure what the implications are, and frankly I’ve never felt the need to limit the scope of a variable so aggressively.<\/p>\n
Meaning 3: Per-Class Data<\/b><\/p>\n
When you declare a class member as static, it now belongs to the class at large, and not a particular instance.<\/p>\n
Example:<\/p>\n
\r\n\/\/ In the .h file:\r\nclass MyClass\r\n{\r\n public:\r\n static int FavoriteNumber;\r\n static void foo();\r\n};\r\n\r\n\/\/ In the .cpp file (to initialize the static variable):\r\n\r\nint MyClass::FavoriteNumber = 42;\r\n\r\nvoid MyClass::foo()\r\n{\r\n \/\/ can't access member variables here!\r\n}\r\n<\/pre>\nUses:<\/b><\/p>\n
It’s very common to store class-level constants this way. You can declare class functions as static as well, so they would be callable from anyone who has access to your class, even if they don’t have an instance. This is handy for helper functions. I generally like to make class functions static if they don’t need to operate on any instance data, typically for private helper functions.<\/p>\n
Gotchas:<\/b><\/p>\n