C's static member variables and functions belong to classes rather than objects and are shared among all instances. static member variables are used to save the status information of the class. For example, object counting, which must be defined outside the class, such as counting the number of objects created; static member functions can access static members, suitable for tool methods, singleton mode and other scenarios, but cannot access non-static members; when using it, you need to pay attention to issues such as initialization order, life cycle, thread safety, and access permissions; typical applications include object counting, global configuration management, tool classes, singleton mode and resource cache.

C's static member variables and functions are shared resources at the class level and do not depend on object instances. That is to say, no matter how many objects are created, the static member has only one copy and is shared by all objects. This is very practical in designing tool classes, counters, singleton modes and other scenarios.

What are static member variables?

static member variable belongs to the entire class, not an object of the class. It is shared among all objects of the class and is often used to save the status information of the class.

For example, if you want to count how many objects a certain class has created:

 class MyClass {
private:
    static int count; // Declare public:
    MyClass() { count; }
    static int getCount() { return count; }
};
int MyClass::count = 0; // Definition

In this way, every time a MyClass object is constructed, count will increase automatically. You can access directly through the class name: MyClass::getCount() .

Note: The static variable must be defined separately outside the class, otherwise an error will be reported during linking.

What is the function of static member functions?

static member functions can only access static member variables and other static functions. They do not have this pointer, so they cannot access non-static members.

Uses include:

• Provides functionality that is related to a class but does not require object context
• Access static data
• Implement factory methods, singleton and other design models

For example:

 class Logger {
private:
    static std::string logFile;
public:
    static void setLogFile(const std::string& file) { logFile = file; }
    static void log(const std::string& message) {
        std::ofstream out(logFile, std::ios::app);
        out << message << std::endl;
    }
};

In this example, both log and setLogFile are static functions that can control log behavior globally without instantiating objects.

What should I pay attention to when using static members?

There are several common pitfalls to be paid attention to when using static members:

• Initialization order problem : The initialization order of static variables in different translation units is uncertain, which may lead to undefined behavior.
• Lifecycle management : static variables are destroyed at the end of the program. If complex resource management is involved (such as file handles, network connections), you must be handled with caution.
• Thread safety : Multiple threads modify static members at the same time may cause race conditions, and it is recommended to add locks or use atomic operations to protect them.
• Access permissions : Even if declared as private, static members can still be accessed through friend or public functions.

If you define the inline const or constexpr static variable in a header file, it can be initialized directly within the class without additional definitions.

What are the applicable scenarios for static members?

Some typical usage scenarios include:

• Object counter : records the number of instances of a certain class.
• Global configuration/state management : such as game settings, log switches, etc.
• Tool function collection : general functions such as mathematical operations and string processing.
• Singleton pattern implementation : Use static function to return a unique instance.
• Resource cache : such as database connection pool, image cache, etc.

To give a simple example:

 class MathUtils {
public:
    static int square(int x) { return x * x; }
    static double pi() { return 3.1415926; }
};

This kind of tool class usually does not require instantiation, just call it directly: MathUtils::square(5);

Basically that's it. static members are not particularly difficult to understand, but details are easily overlooked in actual development, especially initialization and multithreading aspects. Rational use can improve the code structure, while excessive use may cause problems such as high coupling and difficulty in testing.

The above is the detailed content of C static member variables and functions. For more information, please follow other related articles on the PHP Chinese website!