我要评论1. const 常量的初始化与赋值
基本类型 const 变量
// 必须初始化，不能先声明后赋值 const int a = 10; // 正确：定义时初始化 const double pi = 3.14159; // 正确 // const int b; // 错误：未初始化常量 // b = 20; // 错误：不能给常量赋值
const 指针和引用
int x = 10, y = 20; // const 指针（指向常量的指针） const int* ptr1 = &x; // 正确：指向的内容不可变 // *ptr1 = 30; // 错误：不能通过ptr1修改x ptr1 = &y; // 正确：指针本身可以指向其他地址 // 常量指针（指针本身是常量） int* const ptr2 = &x; // 正确：指针本身不可变 *ptr2 = 30; // 正确：可以通过ptr2修改x // ptr2 = &y; // 错误：ptr2是常量指针 // 指向常量的常量指针 const int* const ptr3 = &x; // 指针和指向的内容都不可变 // const 引用 const int& ref = x; // 正确：引用不可修改其值 // ref = 40; // 错误：不能通过ref修改x
类中的 const 成员变量
class myclass {
private:
const int id; // const 成员变量
const std::string name;
public:
// 必须在初始化列表中初始化
myclass(int idval, const std::string& nameval)
: id(idval), name(nameval) { // 初始化列表
// id = idval; // 错误！不能在构造函数体内赋值
}
// 委托构造函数也要通过初始化列表
myclass() : myclass(0, "unknown") {}
};const 成员变量的特殊情况
class advancedclass {
private:
const int size = 100; // c++11: 类内直接初始化
static const int count = 50; // 静态常量可以在类内初始化
public:
advancedclass() {} // 使用默认值
advancedclass(int s) : size(s) {} // 可以覆盖默认值
};const 赋值规则总结
- 基本类型 const 变量：必须在定义时初始化，之后不能赋值
- const 成员变量：必须在构造函数的初始化列表中初始化
- const 指针/引用：遵循指针和引用的 const 规则
- 编译时常量：可以使用
constexpr获得更好的优化
2. static 变量的使用
静态局部变量
void counterfunction() {
static int count = 0; // 只在第一次调用时初始化
count++;
std::cout << "called " << count << " times" << std::endl;
}
// 使用
counterfunction(); // called 1 times
counterfunction(); // called 2 times
counterfunction(); // called 3 times静态成员变量
class player {
private:
static int totalplayers; // 声明
std::string name;
int score;
public:
player(const std::string& n) : name(n), score(0) {
totalplayers++; // 创建对象时计数
}
~player() {
totalplayers--; // 销毁对象时减计数
}
static int gettotalplayers() {
return totalplayers;
}
};
// 静态成员变量必须在类外定义
int player::totalplayers = 0; // 定义和初始化
// 使用
player p1("alice");
player p2("bob");
std::cout << player::gettotalplayers(); // 输出: 2静态常量成员变量
class mathconstants {
public:
static const double pi; // 需要类外定义
static constexpr double e = 2.71828; // c++11: 可以在类内初始化
// 整型静态常量可以在类内初始化（历史原因）
static const int max_size = 100;
};
// 类外定义（如果使用了取地址操作，必须定义）
const double mathconstants::pi = 3.14159;
const int mathconstants::max_size; // 定义，不需要重复初始化3. static 函数的使用
静态成员函数
class utility {
private:
static int instancecount;
int instancedata; // 非静态成员
public:
utility() { instancecount++; }
// 静态成员函数
static int getinstancecount() {
return instancecount;
// return instancedata; // 错误！不能访问非静态成员
}
static double calculatedistance(double x1, double y1, double x2, double y2) {
// 工具函数，不依赖对象状态
return std::sqrt((x2-x1)*(x2-x1) + (y2-y1)*(y2-y1));
}
// 工厂方法模式
static utility* createutility() {
return new utility();
}
};
int utility::instancecount = 0;
// 使用静态函数
int main() {
std::cout << utility::getinstancecount(); // 直接通过类名调用
std::cout << utility::calculatedistance(0, 0, 3, 4); // 输出: 5
utility u1;
std::cout << u1.getinstancecount(); // 也可以通过对象调用（不推荐）
}文件作用域的静态函数（c风格）
// 在 .cpp 文件中
static void internalhelper() { // 只在当前文件可见
std::cout << "内部帮助函数" << std::endl;
}
// 替代方案：使用匿名命名空间（推荐）
namespace {
void anotherhelper() { // 同样具有内部链接
std::cout << "另一个帮助函数" << std::endl;
}
}4. 综合应用示例
单例模式（singleton）
class databaseconnection {
private:
static databaseconnection* instance; // 静态实例指针
const std::string connectionstring; // const 成员
mutable std::mutex mtx; // mutable：可在const函数中修改
// 私有构造函数
databaseconnection(const std::string& connstr)
: connectionstring(connstr) {}
public:
// 删除拷贝构造和赋值
databaseconnection(const databaseconnection&) = delete;
databaseconnection& operator=(const databaseconnection&) = delete;
// 静态函数获取单例
static databaseconnection* getinstance() {
if (instance == nullptr) {
instance = new databaseconnection("localhost:3306");
}
return instance;
}
// const 成员函数
const std::string& getconnectionstring() const {
return connectionstring;
}
// 可修改 mutable 成员的 const 函数
void query(const std::string& sql) const {
std::lock_guard<std::mutex> lock(mtx); // 修改 mutable 成员
std::cout << "executing: " << sql << std::endl;
}
static void cleanup() {
delete instance;
instance = nullptr;
}
};
// 静态成员定义
databaseconnection* databaseconnection::instance = nullptr;使用示例
int main() {
// 单例使用
databaseconnection* db = databaseconnection::getinstance();
db->query("select * from users");
// const 对象使用
const databaseconnection* constdb = databaseconnection::getinstance();
std::cout << constdb->getconnectionstring() << std::endl;
constdb->query("select * from products"); // 可以调用 const 函数
databaseconnection::cleanup();
return 0;
}5. 关键要点总结
const 规则
- 必须初始化：所有 const 变量必须在创建时初始化
- 不能赋值：初始化后不能再修改值
- 成员变量：必须在构造函数初始化列表中初始化
- mutable 例外：mutable 成员在 const 函数中可修改
static 规则
- 静态变量：类级别共享，必须在类外定义
- 静态函数：无 this 指针，只能访问静态成员
- 生命周期：整个程序运行期间存在
- 访问方式：推荐使用
classname::member方式访问
最佳实践
- 将不修改对象状态的成员函数声明为
const - 使用
static实现工具函数和单例模式 - 优先使用匿名命名空间替代文件作用域的 static 函数
- 合理使用
mutable处理 const 函数中的特殊情况
到此这篇关于c++ const 与 static变量、函数、类成员的全面解析(最新推荐)的文章就介绍到这了,更多相关c++ const 与 static 类成员内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！
发表评论