目录
一、静态成员
1.1静态成员介绍
全局对象，如同程序世界中的公共广场，提供了数据共享的便捷途径，然而其无处不在的可见性却带来了安全隐患。因此，在编写程序时，我们应谨慎使用全局对象，转而寻求更为安全的方法。实现类对象间的数据共享，静态成员是我们的得力助手。静态成员分为静态数据成员和静态成员函数，它们如同桥梁，连接着类的每一个对象，确保数据的一致性和共享性。
友元函数，虽是普通的C++函数，却拥有特殊权限，能够触及类的保护或私有领域。这一特性极大地方便了编程，提升了效率，但同时也挑战了类的封装原则。
在类中，若将某一数据声明为static，它便成为了静态数据。这意味着，无论创建多少个该类的对象，静态数据始终只有一份拷贝，这份拷贝如同共享的记忆，被所有对象共同拥有。静态数据属于类，而非单个对象，它的值对所有对象都是一致的。对静态数据成员的更新，便是对所有对象中该静态数据成员值的更新。静态数据成员的声明中包含关键字static，它们在类体内被声明，在类体外被定义，以确保存储空间的分配和初始化。
1.2 静态数据成员
在C++中，静态数据成员是类的成员，它与类的所有对象共享同一份数据。这意味着，无论创建了多少个类的对象，静态数据成员只有一份拷贝。静态数据成员不属于类的任何一个特定对象，而是属于整个类。
静态数据成员的特点包括：
-
共享性：静态数据成员被类的所有对象共享，任何对象对静态数据成员的修改都会影响到其他对象。
-
独立性：静态数据成员独立于类的任何对象而存在。即使没有创建类的任何对象，静态数据成员也可以被访问。
-
生命周期：静态数据成员的生命周期与程序的生命周期相同。它在程序开始时被创建，在程序结束时被销毁。
-
存储位置：静态数据成员存储在静态存储区，而不是对象的内存空间中。
-
访问方式：可以通过类名直接访问静态数据成员，也可以通过类的对象访问。访问时需要使用作用域解析运算符
::。 -
初始化：静态数据成员必须在类外部进行初始化，通常在类的实现文件中。初始化时不需要重复使用
static关键字，但需要指定类的作用域。
例如，定义一个包含静态数据成员的类：
class MyClass {
public:
static int staticData; // 声明静态数据成员
};
// 在类外部初始化静态数据成员
int MyClass::staticData = 10;访问静态数据成员的方式：
// 通过类名访问
int x = MyClass::staticData;
// 通过对象访问
MyClass obj;
int y = obj.staticData;静态数据成员常用于记录类的所有对象共享的信息，如对象计数、共享资源的状态等。由于它们不属于任何特定对象，因此可以用来实现类级别的功能，而不依赖于类的具体对象。
1.3 静态数据成员应用场景
静态数据成员在C++编程中扮演着多重角色，其应用场景包括但不限于：
A. 对象计数：静态数据成员可用于记录和管理动态变化的对象数量，例如，在学生管理系统中，它可以用来追踪当前注册的学生人数。
B. 状态标志：它能够作为一个标志，指示某个特定事件或动作是否已经发生，为程序提供了一种简洁的状态管理机制。
C. 链表管理：静态数据成员可以作为指针，指向链表的第一个或最后一个成员，从而在类的所有对象之间共享链表的结构，确保链表操作的一致性和高效性。
这些应用展示了静态数据成员在实现数据共享和状态管理方面的强大功能，它们是构建复杂软件系统的关键组件。
1.4 静态成员函数
在C++程序中，对静态成员函数的访问可以通过以下优雅的方式进行：
使用类名直接调用：
<类名>::<静态成员函数名>(<参数表>);
ClassA::Fun(123, 456);
通过对象调用：
<对象名>.<静态成员函数名>(<参数表>);
objA.Fun(123, 456);
静态成员函数，如同类的守护者，它们属于整个类，而非类中的个别对象。它们的声明和定义与静态数据成员相似，既可以在类体内，也可以在类体外实现，与普通成员函数无异。
在静态成员函数的实现中，它们可以直接访问静态成员，如同访问自己的一部分。而对于非静态成员，它们则需要通过对象来触及，确保了类成员的封装性和安全性。
代码示例：
#include <iostream>
class MyClass {
public:
static int staticVar; // 静态数据成员
// 静态成员函数
static void staticFunction(int value) {
staticVar = value; // 可以直接访问静态数据成员
// 以下代码是错误的，因为不能直接访问非静态成员
// nonStaticVar = value; // 错误：nonStaticVar未在此处定义
}
// 非静态成员函数
void nonStaticFunction(int value) {
staticVar = value; // 非静态成员函数可以访问静态数据成员
nonStaticVar = value; // 非静态成员函数可以访问非静态数据成员
}
private:
int nonStaticVar; // 非静态数据成员
};
// 初始化静态数据成员
int MyClass::staticVar = 0;
int main() {
// 使用类名调用静态成员函数
MyClass::staticFunction(10);
// 创建对象并调用非静态成员函数
MyClass obj;
obj.nonStaticFunction(20);
// 使用对象调用静态成员函数
obj.staticFunction(30);
return 0;
}二、友元
2.1 友元机制
类，作为C++中的封装大师，将私有数据深藏于其成员函数的保护之下。若要在程序中窥探这些私有成员，唯有通过对象，借助类的成员函数之手。然而，频繁的成员函数调用，如同在程序的血管中注入了一剂缓慢的毒药，逐渐侵蚀着运行的效率。
为了破解这一难题，C++巧妙地引入了友元机制。友元，如同封装之墙上的秘密通道，允许特定的访客无需成员函数的引荐，便能直抵类的私有数据之所在。这一机制，虽能显著提升程序的运行效率，却也在封装的坚固壁垒上凿开了一道裂缝。因此，友元的使用必须慎之又慎，如同在精密的机械中嵌入一颗特制的螺丝，既要确保其功能，又要防止其破坏整体的和谐。
友元可以是单个函数，被赋予“友元函数”的尊称；亦可以是一个完整的类，被称为“友元类”。它们在类的世界中，拥有着特殊的地位，能够触及那些通常被隐藏的秘密。然而，这种特权的使用，必须如同在薄冰上行走，小心翼翼，以免破坏了类设计的初衷和封装的原则。
2.2 友元函数
在C++中，友元函数是一种特殊的函数，它被授予了访问类的私有和保护成员的权限。友元函数不是类的成员函数，但它可以像成员函数一样访问类的私有成员。下面是一个友元函数的例子：
#include <iostream>
class MyClass {
public:
static int staticVar; // 静态数据成员
// 静态成员函数
static void staticFunction(int value) {
staticVar = value; // 可以直接访问静态数据成员
// 以下代码是错误的，因为不能直接访问非静态成员
// nonStaticVar = value; // 错误：nonStaticVar未在此处定义
}
// 非静态成员函数
void nonStaticFunction(int value) {
staticVar = value; // 非静态成员函数可以访问静态数据成员
nonStaticVar = value; // 非静态成员函数可以访问非静态数据成员
}
private:
int nonStaticVar; // 非静态数据成员
};
// 初始化静态数据成员
int MyClass::staticVar = 0;
int main() {
// 使用类名调用静态成员函数
MyClass::staticFunction(10);
// 创建对象并调用非静态成员函数
MyClass obj;
obj.nonStaticFunction(20);
// 使用对象调用静态成员函数
obj.staticFunction(30);
return 0;
} 在这个例子中，friendFunction 是一个友元函数，它在 MyClass 类中被声明为友元。这意味着 friendFunction 可以直接访问 MyClass 的私有成员 privateData。在 main 函数中，我们创建了一个 MyClass 对象 obj，并通过调用 friendFunction 来访问其私有数据。
需要注意的是，友元函数不是类的成员函数，因此它不能使用成员访问运算符（. 或 ->）来调用。相反，它必须像普通函数一样被调用。此外，友元函数的声明通常放在类的私有部分，但这并不影响它的全局可见性。
2.3 友元类
在C++中，当一个类被声明为另一个类的友元时，该友元类中的所有成员函数都被授予了访问被友元类私有和保护成员的权限。下面是一个示例程序，展示了如何声明一个类为另一个类的友元：
#include <iostream>
// 声明类B
class B;
// 类A的定义
class A {
public:
// 成员函数，用于访问类B的私有成员
void displayB(const B& obj);
};
// 类B的定义
class B {
private:
int privateData;
public:
// 构造函数
B(int data) : privateData(data) {}
// 声明类A为友元类
friend class A;
};
// 类A的成员函数实现
void A::displayB(const B& obj) {
// 可以直接访问类B的私有成员
std::cout << "Private data of B: " << obj.privateData << std::endl;
}
int main() {
// 创建类B的对象
B objB(42);
// 创建类A的对象
A objA;
// 使用类A的成员函数访问类B的私有成员
objA.displayB(objB);
return 0;
} 在这个程序中，类A被声明为类B的友元。因此，类A中的所有成员函数都可以访问类B的私有成员。在 main 函数中，我们创建了类B的对象 objB 和类A的对象 objA，然后使用 objA 的成员函数 displayB 来访问 objB 的私有数据 privateData。
需要注意的是，友元关系不是相互的，也就是说，如果类A是类B的友元，这并不意味着类B也是类A的友元。此外，友元关系也不是继承的，子类不会自动成为父类的友元。
三、总结
在编程的舞台上，静态数据成员以其优雅的姿态，超越了全局变量的局限。全局变量，如同无形的锁链，束缚了面向对象程序设计的自由之翼，违背了数据封装的初衷。而静态数据成员，如同晨曦中的露珠，必须在main()程序的序幕拉开之前，便已分配好空间，静静地等待着初始化的时刻。它们独立于类的任何特定对象，如同孤独的旅者，却拥有着共享的记忆。
友元，这一机制，曾是为了提升程序的运行效率，简化编程的复杂性而诞生。然而，随着硬件性能的飞跃，友元的光芒似乎不再那么耀眼。它如同一把双刃剑，虽然能够便捷地触及类的私密领域，却也在不经意间割裂了封装的完整性。因此，在使用友元时，我们必须如履薄冰，权衡其带来的便利与潜在的风险。
在编程的艺术中，每一种工具都有其独特的价值和局限。静态数据成员和友元，如同乐章中的不同音符，只有恰到好处地运用，才能谱写出高效而优雅的代码之歌。
扫一扫
1240
到【灌水乐园】发言
