admin管理员组文章数量:1794759
八、特殊成员
八、特殊成员
静态成员
在C++中，静态成员是属于类的变量或函数，而不是属于类的某个特定对象的。这意味着无论创建了多少个类的对象，静态成员只有一份拷贝。静态成员在类的所有对象之间共享。
静态成员变量
- 静态成员变量在类的所有对象之间共享。
- 静态成员变量在类的外部定义和初始化，使用类名和作用域解析运算符
::。 - 静态成员变量可以在类的内部初始化，但这种初始化形式是C++11及之后版本的标准。
class MyClass {
public:
static int staticValue; // 声明静态成员变量
};
// 在类外部定义和初始化
int MyClass::staticValue = 0;
// C++17及之后版本允许在类内部初始化
class MyClass {
public:
inline static int staticValue = 0; // C++17及之后版本允许
};静态成员函数
- 静态成员函数与静态成员变量一样，也属于类本身，而不是类的对象。
- 静态成员函数没有
this指针，因此它不能直接访问类的非静态成员变量或非静态成员函数。 - 静态成员函数可以直接通过类名和作用域解析运算符
::调用，无需创建类的对象。
class MyClass {
public:
static void staticFunction() {
// 静态成员函数体
}
};
// 调用静态成员函数
MyClass::staticFunction();使用场景
静态成员常用于以下场景：
- 当需要在类的所有对象之间共享数据时。
- 当需要实现与类相关但与类的任何特定对象无关的功能时。
静态成员提供了一种方式来处理与类相关但与类的实例无关的数据和函数。
this
在C++中，this 是一个特殊的指针，它指向当前对象的实例。当你调用一个类的成员函数时，编译器会自动将当前对象的地址传递给这个成员函数，这个地址就是通过 this 指针来访问的。this 指针是隐式传递的，你不需要（也不能）在函数参数列表中显式地声明它。
使用场景
返回当前对象的引用或指针：当你需要从一个成员函数返回当前对象的引用或指针时，可以使用 this 指针。
class MyClass {
public:
MyClass* getThis() {
return this;
}
};链式调用：在某些情况下，this 指针用于支持链式调用（也称为方法链）。这通常在返回当前对象引用的成员函数中使用。
class MyClass {
public:
MyClass& add(int value) {
// 修改当前对象的状态
// ...
return *this; // 返回当前对象的引用
}
};
// 使用链式调用
MyClass obj;
obj.add(1).add(2);区分成员变量和局部变量：在成员函数内部，如果成员变量和局部变量的名字相同，可以使用 this 指针来访问成员变量。
class MyClass {
private:
int value;
public:
void setValue(int value) {
this->value = value; // 使用this指针来访问成员变量
}
};注意事项
this指针在静态成员函数中不可用，因为静态成员函数不属于任何对象实例。- 在构造函数或析构函数中，
this指针指向的是正在构造或正在析构的对象。 - 虽然
this指针在成员函数中是隐式可用的，但在某些情况下（如模板编程或需要显式转换对象类型时），你可能需要显式地使用它。
结论
this 指针是C++中一个非常重要的概念，它使得成员函数能够访问和操作调用它的对象。通过理解和正确使用 this 指针，你可以写出更灵活、更强大的C++代码。
const 成员
在C++中，const 关键字可以用在成员变量（成员属性）和成员函数上，以表示这些成员是不可变的或不会修改对象的任何成员变量（对于成员函数而言）。使用 const 可以帮助增强代码的可读性、安全性和可维护性。
const 成员变量
const 成员变量意味着一旦这个变量被初始化之后，它的值就不能再被修改。这通常用于表示那些不应该被改变的值，比如数学中的常量（π、e等）或者对象的某些固有属性（比如圆的半径，一旦对象被创建，半径就不应该改变）。
class Circle {
public:
Circle(double r) : radius(r) {} // 构造函数初始化半径
double getArea() const { // 使用const成员函数计算面积
return 3.14159 * radius * radius;
}
private:
const double radius; // 半径是const的，创建后不能被修改
};注意，由于 radius 是 const 的，它只能在构造函数的初始化列表中被初始化，而不能在构造函数的函数体中被赋值。
const 成员函数
const 成员函数是指那些不会修改任何成员变量的函数。这意味着，在 const 成员函数内部，你不能修改任何非 const 成员变量的值。但是，你可以读取它们的值。此外，const 成员函数可以被 const 对象调用，这是非 const 成员函数所不允许的。
class MyClass {
public:
void modify() { // 非const成员函数
value = 10;
}
void display() const { // const成员函数
std::cout << "Value: " << value << std::endl;
// value = 20; // 这条语句会导致编译错误，因为不能修改成员变量
}
private:
int value;
};
int main() {
const MyClass obj; // obj是const对象
obj.display(); // 正确：display是const成员函数
// obj.modify(); // 错误：modify不是const成员函数，不能被const对象调用
}mutable
在C++中，mutable关键字是一个比较特殊的修饰符，它用于声明类的成员变量即使在类的const成员函数（即那些被声明为const的成员函数，它们保证不会修改类的任何成员变量的值）中也可以被修改。这听起来可能有点反直觉，因为const成员函数的设计初衷就是保证不会改变对象的任何状态。然而，mutable关键字允许开发者在特定情况下绕过这一限制。
使用场景
mutable关键字的主要使用场景包括：
- 缓存数据：当你想在类的
const成员函数中使用缓存的数据，而这些缓存数据在函数执行过程中可能需要更新时，可以使用mutable来标记这些缓存变量。 - 状态跟踪：在类的
const成员函数执行过程中，可能需要跟踪一些状态（如访问计数、最后访问时间等），这些状态变量可以使用mutable来标记。 - 线程安全：在涉及多线程的类中，
mutable可以用于标记那些需要加锁保护的成员变量，即使这些变量在const成员函数中被访问或修改。
示例
下面是一个简单的例子，展示了mutable的使用：
#include <iostream>
#include <string>
class MyClass {
private:
mutable int accessCount; // 这是一个可变的成员变量
std::string data;
public:
MyClass(const std::string& initData) : data(initData), accessCount(0) {}
void setData(const std::string& newData) {
data = newData;
accessCount = 0; // 这里不需要mutable，因为setData不是const成员函数
}
std::string getData() const {
++accessCount; // 即使在const成员函数中，accessCount也可以被修改
std::cout << "Data accessed " << accessCount << " times.\n";
return data;
}
};
int main() {
MyClass obj("Hello, World!");
obj.getData(); // 输出：Data accessed 1 times.
obj.getData(); // 输出：Data accessed 2 times.
return 0;
}在这个例子中，accessCount是一个mutable成员变量，因此它可以在getData这个const成员函数中被修改。这允许我们跟踪getData函数被调用的次数，即使这个函数是const的。
注意事项
- 在
const成员函数内部，你不能修改任何非const成员变量的值。 const成员函数可以被const对象和非const对象调用。- 非
const成员函数只能被非const对象调用。 - 在
const成员函数内部，通过this指针（虽然你通常不会显式地使用它）访问的成员变量都会被视为const的，这意味着你不能修改它们。 - 静态成员变量和静态成员函数与
const成员无关，因为静态成员不属于类的任何特定对象实例。
友元
C++ 中的友元（Friend）是一种定义在类之外的函数或另一个类，但它有权访问类的私有（private）成员和保护（protected）成员（注意，它不能访问类的公有成员，因为公有成员默认就是对外开放的）。友元关系不是相互的，即如果类A是类B的友元，并不意味着类B自动成为类A的友元。
友元函数
友元函数是定义在类外部的一个普通函数，但它不是类的成员函数。通过在类内部声明该函数为友元，可以使得该函数能够访问类的所有私有成员和保护成员。友元函数的声明在类的访问说明符（public、protected、private）之后，并且在任何成员函数声明之前。
代码语言：javascript代码运行次数：0运行复制class MyClass {
private:
int x;
public:
MyClass(int val) : x(val) {}
friend void display(const MyClass& obj); // 声明友元函数
};
// 定义友元函数
void display(const MyClass& obj) {
std::cout << "Value of x: " << obj.x << std::endl; // 访问私有成员x
}友元类
友元类则是另一个类，它的所有成员函数都可以访问当前类的私有成员和保护成员。友元关系的建立也是通过在类内部声明另一个类为友元来实现的。
代码语言：javascript代码运行次数：0运行复制class MyClass {
private:
int x;
public:
MyClass(int val) : x(val) {}
friend class FriendClass; // 声明友元类
};
class FriendClass {
public:
void show(const MyClass& obj) {
std::cout << "Value of x: " << obj.x << std::endl; // 访问MyClass的私有成员x
}
};使用友元的注意事项
- 封装破坏：友元关系破坏了类的封装性，因为它允许非成员函数或另一个类的成员函数访问类的私有成员。因此，应当谨慎使用友元。
- 非成员函数：友元函数不是类的成员函数，它们不能通过对象来调用（尽管通常通过对象作为参数来传递信息）。
- 单向性：友元关系不是相互的。即，如果类A是类B的友元，并不意味着类B也是类A的友元。
- 数量限制：一个类可以有多个友元函数或友元类，但通常建议限制友元的数量，以保持类的封装性。
- 访问权限：友元函数或友元类可以访问其友元类的所有私有成员和保护成员，但不能访问其友元类的公有成员（因为公有成员默认就是可访问的）。
成员指针
C++ 中的成员指针（Member Pointers）允许你访问类（或结构体）中的成员变量或成员函数。成员指针分为两类：指向成员变量的指针（也称为数据成员指针）和指向成员函数的指针（也称为成员函数指针）。
指向成员变量的指针
指向成员变量的指针声明时，需要指定其所属的类以及该成员变量的类型。语法如下：
代码语言：javascript代码运行次数：0运行复制返回类型 类名::* 指针名;其中，返回类型 是成员变量的类型，类名 是该成员变量所属的类，指针名 是指向成员变量的指针变量名。
示例
代码语言：javascript代码运行次数：0运行复制#include <iostream>
using namespace std;
class MyClass {
public:
int myVar;
};
int main() {
MyClass obj;
int MyClass::*ptr = &MyClass::myVar; // 指向成员变量的指针
obj.*ptr = 10; // 通过指针访问并修改成员变量
cout << obj.myVar << endl; // 输出: 10
return 0;
}指向成员函数的指针
指向成员函数的指针的声明与指向成员变量的指针类似，但更复杂一些，因为成员函数指针还需要处理成员函数可能的隐含的 this 指针（非静态成员函数）或可能的重载版本（通过函数签名区分）。
语法如下：
代码语言：javascript代码运行次数：0运行复制返回类型 (类名::* 指针名)(参数列表);示例
代码语言：javascript代码运行次数：0运行复制#include <iostream>
using namespace std;
class MyClass {
public:
void myFunc() {
cout << "Hello, MyClass!" << endl;
}
};
int main() {
MyClass obj;
void (MyClass::*ptr)() = &MyClass::myFunc; // 指向成员函数的指针
(obj.*ptr)(); // 通过指针调用成员函数
return 0;
}注意事项
- 成员指针不能直接指向类的静态成员。静态成员属于类本身，而非类的某个实例，因此不需要通过对象来访问。
- 成员函数指针的调用：调用通过成员函数指针指向的函数时，需要使用特殊的语法
(对象.*指针名)(参数列表)或(对象指针->*指针名)(参数列表)。 - 成员函数指针和继承：如果子类重写了父类的成员函数，通过父类指针指向子类对象并使用成员函数指针时，会调用子类中的实现（多态行为）。
成员指针是 C++ 中一个较为高级的特性，用于在需要灵活处理类成员访问的场合，如泛型编程、反射（虽然 C++ 标准库不直接支持反射，但成员指针可以在一定程度上模拟反射的行为）等。
本文参与 腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。 原始发表：2024-10-28，如有侵权请联系 cloudcommunity@tencent 删除数据指针变量对象函数本文标签： 八特殊成员
版权声明：本文标题：八、特殊成员 内容由林淑君副主任自发贡献，该文观点仅代表作者本人， 转载请联系作者并注明出处：http://www.xiehuijuan.com/baike/1754595466a1704176.html， 本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌抄袭侵权/违法违规的内容，一经查实，本站将立刻删除。
发表评论