本文主要介绍和记录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文件来对相关参数进行设定，不想采用类内声明，类外初始化的形式，所以放弃了第一种和第三种方案，采用了第二种方案，编译成功
