大家好啊，这里是c++之旅第六弹，跟随我的步伐来开始这一篇的学习吧！

如果有知识性错误，欢迎各位指正！！一起加油！！

创作不易，希望大家多多支持哦！

一,静态成员：

1.静态成员是什么：

静态成员可以在类的所有对象之间共享数据，也可以提供不依赖于类的对象的操作。静态成员是在类的整个生命周期中存在的

静态成员在全局静态常量区，全局静态常量区的数据在程序一开始就有，在程序结束时才死亡；而栈区和堆区的生命周期却是暂时性的，比较短

2.静态成员定义方式：

静态成员，指的是在C++类中声明成员时，可以加上static关键字，这样声明的成员叫静态成员

3.静态成员的分类：

静态成员分为静态数据成员和静态函数成员两种

（1）静态数据成员：（示例代码）

class node
{
public:
static int id;// 静态数据成员定义
};
int node::id=10;// 不管是什么访问属性，静态数据成员都是在类外初始化

静态数据成员的特点：

①、只会被定义一次，所有对象共享这个数据

②、不管是什么访问属性都是在类中声明，类外初始化

③、如果是公有访问属性，那么可以类外直接通过 类名 :: 静态数据成员 访问

④ 、构造函数里面可以重新赋值，在其他函数中是不可以进行修改的

（2）静态函数成员：

class node
{
  public:
  static void fun()
  {
  }
  // 在类中定义
  static void fun1();
  // 类中声明
};
void node::fun1()
{
}
// 在类外定义

静态函数成员的特点：

①、访问和静态数据成员一样，并且使用是在类中声明，在类外进行定义

②、静态函数成员中不能访问类中的普通成员,可以访问静态成员

③、静态函数成员中可以使用局部变量，形参，静态成员

4.静态成员的使用场景：

（1）、共享数据：静态成员可以用于存储所有类的实例之间共享的数据。

（2）、全局数据：静态成员可以被视为类的全局变量。可以在整个程序中访问静态成员，不需要创建类的实例。

（3）、类方法：静态成员函数不依赖于类的实例，因此它们可以用于执行与特定对象无关的操作。静态成员函数通常用于执行与类相关的全局任务或操作。

5.static的五种用法：

1、修饰局部变量，使用在局部，生命周期在全局（全局是在整个项目中）

2、修饰全局变量，该变量只能使用在本文件，生命周期在全局（不修饰则是使用在全局了）

3、修饰普通函数，该函数只能使用在本文件（不修饰则是使用在全局了）

4、修饰类中成员数据，数据被所有对象共享

5、修饰类中成员函数，该成员函数只能访问类中静态成员数据、局部变量和形参

//额外知识点：

类的大小的计算：一个类如果成员是空的，那么其大小为一个字节，用来表示这是一个类，如果其中有成员，则按照成员来计算其大小，计算方式和结构体是一致的，这时它的大小就不需要加上用来表示它是类的那一个字节了.静态成员不属于类中的成员，而是在该类唯一所对应的共享空间中，那么也就会导致当一个类中只有静态成员时，该类的大小是一个字节（定义类时如果里面没有数据成员，其大小就是一个字节），同时因为这个共享性，才导致类中的静态成员无论什么访问属性都可以在类外进行初始化，友元函数也不属于类，和静态成员是一个意思（在后面会讲到友元函数） ​

二，常量成员：

1.常量成员介绍：常量成员，指的是在 C++ 类中声明对象成员时可以加上 const 关键字

2.常量成员分为常量数据成员和常量函数成员，都具有常量的特点不可以修改 ( 只读 )

（1）常量数据成员：

class node
{
const int id;
const int age=18;
// 不建议
};
//如果要初始化常量数据成员，
//一般只能通过初始化列表初始化
​
//改进：
class node
{
const int id;
int age;
node(int x):id(x),age(18)//id 的值初始化为 x ，age 初始为 18,可以给常量和普通成员进行初始化
{
}
//CMyStu::CMyStu(int i, char s) :sex(s),id(i)//常量成员初始化列表的带参初始化方式
};

常量的初始化：在类中直接赋值，但是是新写法，在老版本的编译器中可能会报错，所以想使用另一种初始化方式：借鉴静态成员的初始化方式，我们在类外进行常量成员的初始化，但是这样写会报错，因为相当于在类中声明了一次常量成员，在类外初始化时相当于进行了第二次声明，这样就会报错。所以使用成员初始化列表方式来进行初始化常量成员 ，常量成员只能在成员初始化列表中进行初始化；同时成员初始化列表可以初始化一般数据成员。

但是成员初始化列表可以进行初始化的话，那要构造函数进行初始化干什么？

①因为初始化列表是伴随在构造函数后面的，如果有多个构造函数，那对常量成员的初始化就需要在每个构造函数后面写（如果有定义和声明，在定义后面写即可），这是因为每一个构造函数都可能被使用。

②因为成员初始化列表只能初始化类对象的数据成员，而对成员函数无法进行调用，而构造函数就可以在里面写上这个普通成员函数来进行调用，这一点是成员初始化列表所做不到的，但是成员初始化列表可以对构造函数进行调用

（2）常量函数成员：

class node
{
int id=10;
public:
void fun()const // 注意 const 是写在函数的后面不是前面
{
id=10;// 报错
}
void fun1()const;// 类内声明
};
void node::fun1()const// 类外实现
{}
// 在这个函数中，不能修改类中的数据成员

（3）常量对象：

①、在对象实例化的时候在类名前面加上 const 修饰，该对象为常量对象，满足常量的操作，定义时必须初始化。

②、该对象里面的所有数据都不能被修改。因此对象里面的普通成员函数不允许被调用（防止改变数据），只允许调用常量函数成员

3.初始化列表注意事项：

初始化列表的初始化顺序是按照他们在类中出现的顺序来初始化的，而不是在初始化列表中写的顺序来初始化的

4.使用场景：

（1）、不可修改的数据：常量成员变量用于存储在类的实例中不可更改的数据。这些常量可以是类的特定值，或者是在类的构造函数中初始化的无需修改的数据。

（2）、数据保护和封装：通过将某些成员变量声明为常量，可以防止它们被意外修改。这有助于提高类的安全性和封装性，确保只有类的特定方法才能修改数据。

（3）、优化和性能：常量成员变量可以在编译时被优化。由于这些变量的值是固定的，编译器可以在必要时直接将其替换为对应的常量值，从而改善代码的性能。

（4） 、类的接口：常量成员函数表示这些函数不会修改任何类的成员变量。这样的函数可以被其他部分（包括常量对象和常量成员函数）使用，从而增加类的灵活性和可重用性。

（5）、强制性的函数语义：声明成员函数为常量成员函数可以强制函数在不修改类的状态的情况下执行操作。以确保函数不会产生意外的副作用导致类中不可修改的常量成员被修改。

三，友元成员： 类的特性之一就是封装，而友元打破这种封装的方式，友元分为友元函数和友元对象：

1.综述：

（1）友元函数，他只是一个函数，友元函数不是类的成员，通过类对象是无法访问的，但是在这个函数中有权通过对象访问类中的所有成员。

（2）友元函数，无论声明在类中的任访问属性下都可以，不影响他的调用和访问

（3）友元类是一个单独的类，和友元函数一样，在类中声明了一个友元类，在这个友元类中同样也可以访问该类中的所有成员

2.友元函数：

class node
{
    int id=10;
    friend void fun(node& n);// 声明
}
// 定义函数，需要有类对象
void fun(node&n)
{
    cout<<n.id<<enl;
}
//调用：
node n;
fun(n);//输出 10

3.友元类：

class A
{
friend classB;// 声明
int id;
};
class B
{
public:
void fun(A & a)//当调用该函数的时候会访问到A的私有id
{
cout<<a.id<<endl;
}
}

4.友元的特点：

（1）、单方向：B是A的朋友，B可以访问A的数据，A不可以访问B的数据。

（2）、不传递：A是B的朋友，B是 C 的朋友，A和 C没有朋友关系

（3）、不继承：A是B的朋友，B是 C 的父亲，A和 C没有关系（派生类）

5.使用场景：

（1）、访问私有成员：友元成员可以访问被声明为友元的类的私有成员。这样可以在需要直接访问私有成员的情况下，避免使用公有接口，减少函数调用开销。

（2）、维护类的封装性：正常情况下，类的私有成员只能被该类的成员函数访问。但有时需要让其他类或函数能够访问私有成员，以实现特定的功能。友元成员可以提供这种特权访问，同时仍然保持了类的封装性。

（3）、实现运算符重载：在运算符重载中，有时需要访问不同类的私有成员。通过将一个类的成员函数声明为另一个类的友元成员，可以实现对私有成员的直接访问，并且能够在运算符重载内部进行操作。

（4） 、提升效率：有时，为了提高性能，需要直接访问类的私有成员，而不是通过公有接口。友元成员提供了一种有效的方式，避免了公有接口的调用开销。

6.细节注意：

写友元成员时一般类中进行声明，类外进行定义，定义时无需在前面加上类作用域

（eg：a：：），因为友元成员不属于类（而静态成员需要，这就说明友元成员是比静态成员不属于类的层次更上一层的。