C++笔记之静态成员函数的使用场景

C++静态成员函数的核心特点是不与特定类实例相关，可通过类名直接调用，用于执行与类相关的操作而无需创建类对象。其主要用途是在类级别上共享功能，管理全局状态或提供工具函数。

code review!

1.共享数据：当类的所有实例需要共享某个数据时，可以使用静态数据成员

代码

class BankAccount {
private:static double interestRate; // 静态数据成员，所有账户共享利率double balance;
public:static void setInterestRate(double rate) {interestRate = rate;}// ...
};// 在类外初始化静态数据成员
double BankAccount::interestRate = 0.05;int main() {BankAccount::setInterestRate(0.07); // 所有账户的利率都被更新// ...return 0;
}

2.工具函数： 静态函数成员通常用于实现与类相关的工具函数，这些函数不需要访问实例特定的数据

代码

class MathUtils {
public:static int factorial(int n) {if (n <= 1)return 1;return n * factorial(n - 1);}
};int main() {int fact = MathUtils::factorial(5); // 调用静态函数成员// ...return 0;
}

3.计数或标识： 使用静态成员可以在所有实例之间保持计数或标识的状态

代码

class Student {
private:static int count; // 静态数据成员，用于记录学生数量int studentID;
public:Student() {count++;studentID = count;}static int getCount() {return count;}
};int Student::count = 0; // 初始化静态数据成员int main() {Student s1, s2, s3;cout << "Total students: " << Student::getCount() << endl; // 输出学生数量// ...return 0;
}

4.单例模式: 静态成员可用于实现单例模式，确保一个类只有一个实例

代码

class Singleton {
private:static Singleton* instance; // 静态指针成员，指向单一实例Singleton() { /* 构造函数私有化，防止外部实例化 */ }
public:static Singleton* getInstance() {if (!instance)instance = new Singleton();return instance;}// ...
};Singleton* Singleton::instance = nullptr; // 初始化静态指针成员为 nullptrint main() {Singleton* singleton = Singleton::getInstance(); // 获取单例实例// ...return 0;
}

5.日志记录： 在一个应用程序中使用静态成员来记录和管理日志信息

代码

class Logger {
private:static std::ofstream logFile; // 静态文件流，用于日志记录
public:static void openLogFile(const std::string& filename) {logFile.open(filename);}static void log(const std::string& message) {if (logFile.is_open())logFile << message << std::endl;}static void closeLogFile() {logFile.close();}
};std::ofstream Logger::logFile; // 初始化静态文件流int main() {Logger::openLogFile("app.log");Logger::log("Application started.");// ...Logger::closeLogFile();return 0;
}

6.全局配置： 使用静态数据成员来保存全局配置设置

代码

class AppConfig {
private:static int maxConnections; // 最大连接数
public:static void setMaxConnections(int max) {maxConnections = max;}static int getMaxConnections() {return maxConnections;}
};int AppConfig::maxConnections = 100; // 初始化最大连接数int main() {AppConfig::setMaxConnections(150);int max = AppConfig::getMaxConnections();// ...return 0;
}

7.数学常数： 在数学库中使用静态成员来提供常用的数学常数

代码

class MathConstants {
public:static const double PI;static const double E;
};const double MathConstants::PI = 3.141592653589793;
const double MathConstants::E = 2.718281828459045;int main() {double circumference = 2 * MathConstants::PI * radius;// ...return 0;
}

8.数据库连接池： 使用静态成员来管理共享的数据库连接池

代码

class DBConnectionPool {
private:static std::vector<Connection> pool; // 静态连接池
public:static void initializePool(int size) {for (int i = 0; i < size; ++i) {pool.push_back(Connection());}}static Connection getConnection() {if (!pool.empty()) {Connection conn = pool.back();pool.pop_back();return conn;}throw std::runtime_error("Connection pool empty.");}static void releaseConnection(const Connection& conn) {pool.push_back(conn);}
};std::vector<Connection> DBConnectionPool::pool; // 初始化静态连接池int main() {DBConnectionPool::initializePool(10);Connection conn = DBConnectionPool::getConnection();// ...DBConnectionPool::releaseConnection(conn);return 0;
}

9.跟踪对象数量： 使用静态数据成员来跟踪特定类的实例数量

代码

class ObjectCounter {
private:static int count; // 静态计数器，跟踪对象数量
public:ObjectCounter() {count++;}~ObjectCounter() {count--;}static int getCount() {return count;}
};int ObjectCounter::count = 0; // 初始化静态计数器int main() {ObjectCounter obj1, obj2, obj3;std::cout << "Total objects: " << ObjectCounter::getCount() << std::endl;// ...return 0;
}

10.全局事件处理： 使用静态函数成员来处理全局事件，如系统信号

代码

class EventHandler {
public:static void handleShutdownSignal() {// 处理关闭信号的逻辑}static void handleInterruptSignal() {// 处理中断信号的逻辑}
};int main() {// 注册信号处理函数std::signal(SIGINT, EventHandler::handleInterruptSignal);std::signal(SIGTERM, EventHandler::handleShutdownSignal);// ...return 0;
}

11.全局资源管理： 使用静态成员来管理全局资源，如文件句柄

代码

class ResourceManager {
private:static std::vector<FileHandle> openFiles; // 静态文件句柄列表
public:static FileHandle openFile(const std::string& filename) {FileHandle handle = openFileInternally(filename);openFiles.push_back(handle);return handle;}// ...
};std::vector<FileHandle> ResourceManager::openFiles; // 初始化文件句柄列表int main() {FileHandle file = ResourceManager::openFile("data.txt");// ...return 0;
}

12.全局配置管理： 使用静态成员来加载和管理全局配置信息

代码

class AppConfig {
private:static AppConfig instance; // 单例实例std::map<std::string, std::string> configData;AppConfig() {// 从配置文件加载配置数据}
public:static AppConfig& getInstance() {return instance;}std::string getConfigValue(const std::string& key) {return configData[key];}
};AppConfig AppConfig::instance; // 初始化单例实例int main() {std::string value = AppConfig::getInstance().getConfigValue("max_connections");// ...return 0;
}

13.回调-事件处理：在事件驱动的程序中，可以使用静态回调函数来响应特定事件

代码

class EventHandler {
public:static void onButtonClicked() {// 处理按钮点击事件的逻辑}static void onTextChanged(const std::string& newText) {// 处理文本变化事件的逻辑}
};int main() {Button button;button.setClickCallback(EventHandler::onButtonClicked);TextBox textBox;textBox.setTextChangeCallback(EventHandler::onTextChanged);// ...return 0;
}

14.回调-异步回调：在异步编程中，可以使用静态回调函数来处理异步任务完成的通知

运行

代码

#include <iostream>
#include <functional>
#include <thread>class AsyncTask {
public:typedef std::function<void(int result)> CompletionCallback;static int performActualTask(int input) {// 模拟耗时操作std::this_thread::sleep_for(std::chrono::seconds(2));return input * 2; // 模拟异步任务结果}static void performAsyncTask(int input, CompletionCallback callback) {std::thread([input, callback]() {int result = performActualTask(input);callback(result);}).detach();}
};int main() {int input = 42;AsyncTask::performAsyncTask(input, [](int result) {std::cout << "Async task completed with result: " << result << std::endl;});// 主线程继续执行其他操作std::cout << "Main thread continues..." << std::endl;// 等待一段时间，以确保异步任务完成std::this_thread::sleep_for(std::chrono::seconds(3));return 0;
}

15.回调-插件化架构： 在插件化架构中，可以使用静态回调函数来扩展和定制主程序的功能

运行

代码

#include <iostream>
#include <functional>
#include <vector>class Plugin {
public:typedef std::function<void()> ActionCallback;static void registerCustomAction(ActionCallback callback) {// 将回调函数注册为自定义动作customActions.push_back(callback);}static void executeCustomActions() {for (const ActionCallback& callback : customActions) {callback();}}private:static std::vector<ActionCallback> customActions;
};std::vector<Plugin::ActionCallback> Plugin::customActions;int main() {Plugin::registerCustomAction([]() {std::cout << "Custom action 1 executed." << std::endl;});Plugin::registerCustomAction([]() {std::cout << "Custom action 2 executed." << std::endl;});Plugin::executeCustomActions();// ...return 0;
}

16.回调-回调集中管理： 使用静态回调函数集中管理程序中的不同事件和处理逻辑

运行

代码

#include <iostream>
#include <functional>
#include <map>class CallbackManager {
public:typedef std::function<void()> Callback;static void registerCallback(const std::string& eventName, Callback callback) {eventCallbacks[eventName] = callback;}static void triggerEvent(const std::string& eventName) {auto it = eventCallbacks.find(eventName);if (it != eventCallbacks.end()) {(it->second)();}}private:static std::map<std::string, Callback> eventCallbacks;
};std::map<std::string, CallbackManager::Callback> CallbackManager::eventCallbacks;int main() {CallbackManager::registerCallback("start", []() {std::cout << "Start event triggered." << std::endl;});CallbackManager::registerCallback("stop", []() {std::cout << "Stop event triggered." << std::endl;});CallbackManager::triggerEvent("start");CallbackManager::triggerEvent("stop");// ...return 0;
}