C++中静态成员变量和普通成员变量、私有成员变量和公有成员变量的区别-编程知识

本文主要介绍和记录C++中静态成员变量和普通成员变量、私有成员变量和公有成员变量的区别，并给出相关示例程序，最后结合相关工程应用中编译报错给出报错原因及介绍思路

一、静态成员变量和普通成员变量

C++中，静态成员变量和普通成员变量有一些重要的区别，如下所示：

1. 存储位置：

普通成员变量：每个类的对象都有自己的一份普通成员变量的拷贝，它们存储在对象的内存中。
静态成员变量：所有属于同一个类的对象共享同一份静态成员变量的拷贝，它存储在类的类体外，并且不依赖于类的实例。

2. 作用域：

普通成员变量：只有在类的实例化后，通过对象访问。
静态成员变量：可以通过类名直接访问，不需要创建类的实例。

3. 初始化：

普通成员变量：在每个对象被创建时进行初始化，可以在类的构造函数中进行。
静态成员变量：需要在类体外进行初始化，通常在类的实现文件中进行。

4. 生命周期：

普通成员变量：随着对象的创建而创建，随着对象的销毁而销毁。
静态成员变量：从程序开始时创建，直到程序结束时销毁。

5. 访问权限：

普通成员变量：可以是公有、私有或受保护的，根据访问修饰符的设置。
静态成员变量：也可以是公有、私有或受保护的，但由于可以通过类名直接访问，一般建议将其声明为私有，并提供公有的静态成员函数用于访问或修改。

6. 使用场景：

普通成员变量：通常用于描述对象的状态或属性。
静态成员变量：通常用于描述属于整个类而非特定对象的属性，例如计数器、共享资源等。

下面是一个简单的例子，演示了静态成员变量和普通成员变量的用法：

#include <iostream>class MyClass {
public:int regularVar;        // 普通成员变量static int staticVar;  // 静态成员变量// 构造函数MyClass() {regularVar = 0;}// 静态成员函数，可以访问静态成员变量和其他静态成员函数static void staticFunction() {staticVar++;}
};// 初始化静态成员变量
int MyClass::staticVar = 0;int main() {MyClass obj1, obj2;obj1.regularVar = 10;obj2.regularVar = 20;// 访问普通成员变量，实例化后，通过对象访问std::cout << "Regular Variable of obj1: " << obj1.regularVar << std::endl;std::cout << "Regular Variable of obj2: " << obj2.regularVar << std::endl;// 访问静态成员变量，不需要实例化类的对象std::cout << "Static Variable: " << MyClass::staticVar << std::endl;// 调用静态成员函数MyClass::staticFunction();std::cout << "Static Variable after calling staticFunction: " << MyClass::staticVar << std::endl;return 0;
}

这个程序创建了一个 `MyClass` 类，其中包含了一个普通成员变量 `regularVar` 和一个静态成员变量 `staticVar`。`regularVar`是普通成员变量，每个对象都有自己的副本。`staticVar` 是静态成员变量，所有对象共享同一个副本。

在 `main` 函数中，创建了两个对象 `obj1` 和 `obj2`，分别设置了它们的 `regularVar` 值。然后，分别通过类名和对象访问了静态成员变量和普通成员变量，并调用了静态成员函数来改变`staticVar的值`。

运行结果如下：

Regular Variable of obj1: 10
Regular Variable of obj2: 20
Static Variable: 0
Static Variable after calling staticFunction: 1

二、私有成员变量和公有成员变量

在C++中，私有成员变量和公有成员变量有以下主要区别：

1. 访问权限：

- 私有成员变量：只能在类的内部访问，外部代码无法直接访问。只有类的成员函数（包括私有成员函数和公有成员函数）可以访问私有成员。
- 公有成员变量：可以被类的外部代码直接访问，没有访问限制。

2. 封装性：

- 私有成员变量：提供了更好的封装性，隐藏了类的实现细节，外部代码无法直接修改或访问私有成员。
- 公有成员变量：破坏了封装性，外部代码可以直接修改公有成员，导致代码的不安全性和可维护性降低。

3. 安全性：

- 私有成员变量：提高了代码的安全性，防止外部代码意外地修改类的内部状态。
- 公有成员变量：可能降低代码的安全性，因为外部代码可以直接修改类的公有成员。

4. 灵活性：

- 私有成员变量：允许类实现者更灵活地控制类的内部状态和行为，可以在类的内部进行适当的处理。
- 公有成员变量：提供了更直接的访问方式，但可能导致类的实现难以修改。

5. 继承和派生：

- 私有成员变量：在派生类中不可直接访问基类的私有成员。
- 公有成员变量：在派生类中可以直接访问基类的公有成员，但这同样可能导致破坏封装性。

下面是一个简单的例子，演示了私有成员变量和公有成员变量的用法：

#include <iostream>class Example {
private:int privateVar;  // 私有成员变量public:int publicVar;   // 公有成员变量// 构造函数Example() {privateVar = 0;publicVar = 0;}// 成员函数访问私有成员void setPrivateVar(int value) {privateVar = value;}int getPrivateVar() const {return privateVar;}
};int main() {Example obj;// 外部无法直接访问私有成员// obj.privateVar;  // 编译错误// 外部可以直接访问公有成员obj.publicVar = 42;// 调用成员函数访问私有成员obj.setPrivateVar(10);int privateValue = obj.getPrivateVar();// 输出结果std::cout << "Public Variable: " << obj.publicVar << std::endl;std::cout << "Private Variable: " << privateValue << std::endl;return 0;
}

在上述示例中，`privateVar` 是私有成员变量，只能通过成员函数进行访问，而`publicVar` 是公有成员变量，可以直接在外部访问。

运行结果如下：

Public Variable: 42
Private Variable: 10

三、相关编译报错原因及解决方法

1、编译报错内容如下：

/home/gly/catkin_ws/src/navigation-noetic-devel/rrt_star_global_planner-main/src/traj_optimizer.cpp:1066:9: error: invalid use of member ‘Trajectory_optimization::BsplineOptimizer::Opt_Storage’ in static member function
1066 | Opt_Storage.save_vector_T(opt_base_path,FN_2,time_consuming);
| ^~~~~~~~~~~
In file included from /home/gly/catkin_ws/src/navigation-noetic-devel/rrt_star_global_planner-main/src/traj_optimizer.cpp:1:
/home/gly/catkin_ws/src/navigation-noetic-devel/rrt_star_global_planner-main/include/rrt_star_global_planner/traj_optimizer.h:66:37: note: declared here
66 | Data_Storage::FileDataStorage Opt_Storage; //创建FileDataStorage类的实例，取名为Mpc_Storage

2、报错原因分析：

我们以第一个报错为例进行介绍，报错原因是在类中创建了普通成员Opt_Storage，然后尝试在类的静态成员函数 `costFunctionCallback` 中直接调用类的该普通成员Opt_Storage，导致报错

因为，静态函数无法直接访问非静态成员！！！

3、解决方案：

有三种解决思路，第一种是将 `costFunctionCallback` 设计成非静态成员函数，这样它就可以访问实例的成员变量。此时，在该函数中直接使用以下语句就不会产生报错了

Opt_Storage.save_vector_T(opt_base_path,FN_2,time_consuming);

如果我们需要保留 `costFunctionCallback函数为静态成员函数，则可以采用第二种方案，使用实例化的类的对象来调用该成员，此时，上述语句需要改写成以下的形式`

//由于costFunctionCallback是静态成员函数，而静态函数无法直接访问非静态成员
//需要借助类的实例来访问
Trajectory_optimization::BsplineOptimizer temporary_object;temporary_object.Opt_Storage.save_vector_T(temporary_object.opt_base_path,temporary_object.FN_2,time_consuming);

如果我们需要保留 `costFunctionCallback函数为静态成员函数，除了上面的第二种方案，还有第三种解决方案，即将想要在costFunctionCallback函数中直接调用的相关成员，由普通成员更改为静态成员，并在类中声明，在类外对其进行初始化。`

`最终，因为我需要保留costFunctionCallback函数为静态成员函数，且为了方便的通过修改类所在的h文件来对相关参数进行设定，不想采用类内声明，类外初始化的形式，所以放弃了第一种和第三种方案，采用了第二种方案，编译成功`