Hello everyone, I am Xiaokang.
Today, let’s talk about the seemingly simple yet “full of tricks” keyword in C++ — static.
When it comes to static, many of you might think: “Isn’t it just a static variable? What’s so special about it?”
Well, if you really think that way, you better pay close attention to this article today. The static keyword is quite a “jack of all trades” in C++, with so many uses that it might make you question your understanding!
Don’t worry, I will explain the various “tricks” of static in the most straightforward way possible. I guarantee that after reading this, you will never be confused by static again!
⚡ Friendly Reminder: Follow me to stay updated! There will be more hardcore technical articles shared later, guiding you through Linux C/C++ programming! 😆
First Trick: Local Static Variables — The “Permanent Resident” in Functions
Let’s start with the most common case. Have you ever thought about how ordinary local variables “die” after each function call, but sometimes we want them to “live” a bit longer and remember their last value?
This is where static comes into play!
#include <iostream>
using namespace std;
void countCalls() {
static int count = 0; // This guy is a "permanent resident"
count++;
cout << "Function has been called " << count << " times" << endl;
}
int main() {
countCalls(); // Output: Function has been called 1 times
countCalls(); // Output: Function has been called 2 times
countCalls(); // Output: Function has been called 3 times
return 0;
}
See? This count variable is like a “permanent resident”, staying in memory and not leaving! Every time the function is called, it remembers its value.
Here’s the key point: A static local variable is initialized only the first time the function is entered, and then it “stays put”.
Second Trick: Global Static Variables — The “Lone Wolf” in Files
If a regular global variable is a “social butterfly” that can be accessed from any file, then a static global variable is a “lone wolf” that only hangs out in its own file.
// file1.cpp
#include <iostream>
using namespace std;
static int secretNumber = 42; // This is my little secret, no other file can touch it!
void showSecret() {
cout << "My secret number is: " << secretNumber << endl;
}
// If you try to access secretNumber in file2.cpp, the compiler will tell you: No way!
This trick is especially suitable for writing some “internally used” global variables when you don’t want other files to “drop by”.
Third Trick: Static Member Variables — The “Public Property” of Classes
This one is even more interesting! Ordinary member variables have one copy for each object, but static member variables are shared by the entire class, like “public property” for all objects.
#include <iostream>
using namespace std;
class Student {
public:
string name;
static int totalCount; // Public counter for all students
Student(string n) : name(n) {
totalCount++; // Increment counter for each student created
}
static void showTotal() {
cout << "Currently, there are " << totalCount << " students" << endl;
}
};
// Important: Static member variables need to be initialized outside the class!
int Student::totalCount = 0;
int main() {
Student s1("Xiaoming");
Student s2("Xiaohong");
Student::showTotal(); // Output: Currently, there are 2 students
Student s3("Xiaogang");
Student::showTotal(); // Output: Currently, there are 3 students
return 0;
}
See? No matter how many Student objects are created, totalCount only has one copy, and everyone shares it.
Fourth Trick: Static Member Functions — The “Independent Worker” That Doesn’t Need an Object
Static member functions are even cooler; they can be called without an object, just like the showTotal() function in the example above.
class MathHelper {
public:
static int add(int a, int b) {
return a + b;
}
static double pi() {
return 3.14159;
}
};
int main() {
// Directly call using the class name, no need to create an object
cout << "5 + 3 = " << MathHelper::add(5, 3) << endl; // Output: 8
cout << "π = " << MathHelper::pi() << endl; // Output: 3.14159
return 0;
}
Note: Static member functions cannot access non-static members because they have no idea which object’s members to access!
Fifth Trick: Static Local Objects — The “Lazy” Singleton
This trick is more advanced and suitable for implementing the singleton pattern. An object is created only when it is first needed, and then that same object is used thereafter.
#include <iostream>
using namespace std;
class Singleton {
private:
Singleton() { cout << "Singleton object created!" << endl; }
public:
static Singleton& getInstance() {
static Singleton instance; // Lazy creation
return instance;
}
void doSomething() {
cout << "I am doing something..." << endl;
}
};
int main() {
cout << "Program starts running" << endl;
Singleton& s1 = Singleton::getInstance(); // Object is created now
s1.doSomething();
Singleton& s2 = Singleton::getInstance(); // No new object will be created
s2.doSomething();
return 0;
}
// Output:
// Program starts running
// Singleton object created!
// I am doing something...
// I am doing something...
Sixth Trick: Static Constant Members — The “Iron Rules” of Classes
This trick is super useful in actual development! Sometimes we need to define constants for a class, such as maximum values, version numbers, etc., and this is where static const comes in handy.
#include <iostream>
using namespace std;
class GamePlayer {
private:
string name;
int level;
public:
// These are the "iron rules" of the game, all players must follow
static const int MAX_LEVEL = 100; // Maximum level
static const int MIN_LEVEL = 1; // Minimum level
static constexpr double UPGRADE_RATE = 1.5; // Upgrade rate
GamePlayer(string n) : name(n), level(1) {
cout << name << " joined the game, current level: " << level << endl;
}
void upgrade() {
if (level < MAX_LEVEL) {
level += 2; // Increase level by 2 each time, simple and direct
if (level > MAX_LEVEL) level = MAX_LEVEL;
cout << name << " leveled up! Current level: " << level << endl;
} else {
cout << name << " is already at max level!" << endl;
}
}
static void showGameRules() {
cout << "=== Game Rules ===" << endl;
cout << "Level range: " << MIN_LEVEL << " - " << MAX_LEVEL << endl;
cout << "Upgrade rate: " << UPGRADE_RATE << endl;
}
};
int main() {
// View game rules without creating an object
GamePlayer::showGameRules();
GamePlayer player1("Xiaoming");
// Directly access constants using the class name
cout << "The maximum level in the game is: " << GamePlayer::MAX_LEVEL << endl;
// Try leveling up a few times
player1.upgrade(); // 1 * 1.5 = 1
player1.upgrade(); // 1 * 1.5 = 1
return 0;
}
Output:
=== Game Rules ===
Level range: 1 - 100
Upgrade rate: 1.5
Xiaoming joined the game, current level: 1
The maximum level in the game is: 100
Xiaoming leveled up! Current level: 3
Xiaoming leveled up! Current level: 5
The benefits of this usage are:
- Static constants belong to the entire class and do not occupy memory for each object
- Can be accessed directly using the class name, very convenient
- Values are determined at compile time, making it very efficient
- All objects share the same set of “rules”
To summarize, the various “roles” of static:
- Local Static Variables – The permanent resident in functions, remembers the last value
- Global Static Variables – The lone wolf in files, only visible in its own file
- Static Member Variables – The public property of classes, shared by all objects
- Static Member Functions – Independent workers, callable without an object
- Static Local Objects – The lazy singleton, created only when needed
- Static Constant Members – The iron rules of classes, shared constants determined at compile time
After seeing all this, don’t you find static quite interesting? It acts like a “jack of all trades” in C++, playing different roles in different places, but the core idea is always about controlling lifecycle and visibility.
Next time you see static, don’t just think of “static variables”; think about what role it is playing. This way, your code will be clearer!
Remember: The most important thing for programmers is not to memorize all the syntax, but to understand the “character” of each tool and use the right tool in the right situation. Static is such a “characterful” tool!
So, did you gain anything from today’s journey into static?
To be honest, when I first started learning C++, I was also confused by static. But after some exploration, I discovered its “tricks”. Now, when I write programs, static is like my good buddy!
If you also want to master Linux C/C++ backend development like me, feel free to follow my public account “Learn Programming with Xiaokang“. I will regularly share practical insights, guaranteed to be experiences learned from my own mistakes.
Alright, that’s all for today. See you next time! Don’t forget to give a little heart!~
Click the public account card below to follow.
By the way, there’s also a technical exchange group where like-minded friends discuss technology and share experiences. The atmosphere is great! If you have questions, feel free to ask; it’s definitely more efficient than learning alone.
Previous Good Articles:60 Practical Linux C/C++ Projects, Challenge for 300,000 Annual Salary+What Can You Do with C++? A Complete Guide to Popular Employment Directions!Don’t Get Trapped Again! C++ Overloading vs Overriding, This Article Will Make You Understand the Difference InstantlyC++ Can Be Elegant Like Python? Let pair, tuple, and tie Help!Ubuntu 20.04 Virtual Machine Development Environment Setup Tutorial: Source Change + Tool Installation + C/C++ Configuration All in OneIncredible! These 17 C Pointer Tricks Have Made Countless Programmers Collect Them Overnight!