C++ 两个类通过智能指针进行访问操作代码
作者：BoBo玩ROS
在C++中，有多种方法可以实现将一个函数传递给另一个类，并在该类中调用该函数。您可以选择将函数作为回调函数或通过类的成员函数来实现。
1.将函数作为回调函数传递：
- 定义一个函数指针类型，该函数指针类型与要传递的函数具有相同的签名。
- 在接收函数的类中，定义一个成员变量，用于存储传递的函数指针。
- 在接收函数的类中，定义一个函数，该函数使用存储的函数指针来调用传递的函数。
- 在传递函数的类中，将函数指针传递给接收函数的类的成员变量。
- 在接收函数的类中，通过调用成员函数来调用传递的函数。
下面是一个示例代码：
// 定义函数指针类型
typedef void (*CallbackFunction)(int);
class Nav {
public:
// 将函数指针作为参数传递给Follow类的函数
void setCallback(CallbackFunction callback) {
m_callback = callback;
}
// 调用回调函数
void executeCallback() {
if (m_callback) {
m_callback(42);
}
}
private:
CallbackFunction m_callback;
};
class Follow {
public:
// 接收函数，用于调用传递的函数
void execute(int value) {
// 在这里可以访问Nav的成员变量
// ...
std::cout << "Received value: " << value << std::endl;
}
};
int main() {
Nav nav;
Follow follow;
// 将Follow类的execute函数作为回调函数传递给Nav类
nav.setCallback(&Follow::execute);
// 在Nav类中调用回调函数
nav.executeCallback();
return 0;
}2.将Nav类的指针传递给Follow类：
- 在Follow类中定义一个成员变量来存储Nav类的指针。
- 在Follow类中定义一个函数，通过存储的指针来调用Nav类的函数。
- 在创建Follow类的实例时，将Nav类的指针传递给Follow类的构造函数。
- 在Follow类中通过存储的指针来调用Nav类的函数。
下面是一个示例代码：
class Nav {
public:
void execute(int value) {
// 在这里可以访问Nav的成员变量
// ...
std::cout << "Received value: " << value << std::endl;
}
};
class Follow {
public:
Follow(Nav* nav) : m_nav(nav) {}
// 使用存储的Nav指针来调用Nav类的函数
void executeCallback() {
if (m_nav) {
m_nav->execute(42);
}
}
private:
Nav* m_nav;
};
int main() {
Nav nav;
Follow follow(&nav);
// 在Follow类中调用Nav类的函数
follow.executeCallback();
return 0;
}对于这两种方法，利弊如下：
- 将函数作为回调函数传递：
- 优点：在调用函数时更加灵活，可以在不同的类之间共享和传递函数，可以传递不同的函数给同一个类的不同成员变量。
- 缺点：需要定义函数指针类型，可能会增加代码的复杂性。
- 将Nav类的指针传递给Follow类：
- 优点：更容易访问Nav类的成员变量和函数，不需要定义函数指针类型。
- 缺点：在传递指针时需要注意指针的生命周期，可能需要手动管理内存。
选择哪种方法取决于您的具体需求和设计考虑。如果您需要在不同的类之间共享和传递函数，并允许动态更改函数，那么将函数作为回调函数传递可能更适合。如果您只需要在一个类中调用另一个类的函数，并且需要访问该类的成员变量，那么将类的指针传递给另一个类可能更合适。要给 path_follow 类传递名为 waypointCallback 的函数，可以按照以下步骤进行：
1.首先，在 path_follow 类的头文件中声明函数 waypointCallback ，并指定其参数和返回类型。例如：
class path_follow {
public:
void waypointCallback(const bool arrived_flag);
};2.在 path_follow 类的实现文件中定义函数 waypointCallback ，并实现其逻辑。例如：
void path_follow::waypointCallback(const bool arrived_flag) {
// 在这里实现waypointCallback的逻辑
if (arrived_flag) {
// 如果到达了路径点，执行某些操作
// ...
} else {
// 如果未到达路径点，执行其他操作
// ...
}
}3.在需要使用 path_follow 类的地方，创建一个 path_follow 对象，并将 waypointCallback 函数作为回调函数传递给 path_follow 类的成员变量。例如：
// 定义回调函数类型
typedef void (path_follow::*CallbackFunction)(const bool);
class Nav {
public:
// 将回调函数作为参数传递给path_follow类的函数
void setCallback(CallbackFunction callback) {
m_callback = callback;
}
// 调用回调函数
void executeCallback(const bool flag) {
if (m_callback) {
(this->*m_callback)(flag);
}
}
private:
CallbackFunction m_callback;
};
int main() {
Nav nav;
path_follow pathFollow;
// 将waypointCallback函数作为回调函数传递给Nav类
nav.setCallback(&path_follow::waypointCallback);
// 在Nav类中调用回调函数
nav.executeCallback(true);
return 0;
}在上述代码中，我们定义了一个 CallbackFunction 类型，用于表示回调函数的类型。然后，在 Nav 类中，我们将 CallbackFunction 作为参数传递给 setCallback 函数，并将 waypointCallback 函数的地址传递给 setCallback 函数。最后，在 executeCallback 函数中，我们通过调用成员函数指针来调用传递的回调函数。下面是一个示例代码，演示了如何在 Nav 类中定义 path_follow 类，并在 Nav 类中定义回调函数，并将其传递给 path_follow 类，然后在 path_follow 类中调用 Nav 类的回调函数。
class Nav {
public:
void waypointCallback(const bool arrived_flag) {
if (arrived_flag) {
// 如果到达了路径点，执行某些操作
// ...
} else {
// 如果未到达路径点，执行其他操作
// ...
}
}
void executeCallback() {
// 在这里调用回调函数
bool flag = true; // 假设传递给回调函数的参数
waypointCallback(flag);
}
};
class path_follow {
public:
path_follow(Nav* nav) : m_nav(nav) {}
void executeNavCallback() {
// 在这里调用Nav类的回调函数
bool flag = false; // 假设传递给回调函数的参数
m_nav->waypointCallback(flag);
}
private:
Nav* m_nav;
};
int main() {
Nav nav;
path_follow pathFollow(&nav);
// 在path_follow类中调用Nav类的回调函数
pathFollow.executeNavCallback();
return 0;
}在上述代码中，我们首先在 Nav 类中定义了 waypointCallback 回调函数，并在 executeCallback 函数中调用该回调函数。然后，在 path_follow 类中，我们将 Nav 类的指针作为参数传递给 path_follow 类的构造函数，并在 executeNavCallback 函数中调用 Nav 类的回调函数。
如果您不想将 Nav 类的指针作为参数传递给 path_follow 类，而是将 Nav 类的函数传递给 path_follow 类，可以使用函数指针或者 std::function 来实现。下面是一个示例代码，演示了如何使用函数指针来传递 Nav 类的函数给 path_follow 类：
#include <iostream>
class Nav {
public:
void waypointCallback(const bool arrived_flag) {
if (arrived_flag) {
std::cout << "Waypoint reached!" << std::endl;
} else {
std::cout << "Waypoint not reached!" << std::endl;
}
}
};
class path_follow {
public:
// 定义函数指针类型
typedef void (Nav::*CallbackFunction)(const bool);
path_follow(Nav* nav, CallbackFunction callback) : m_nav(nav), m_callback(callback) {}
void executeNavCallback() {
// 在这里调用Nav类的回调函数
bool flag = true; // 假设传递给回调函数的参数
(m_nav->*m_callback)(flag);
}
private:
Nav* m_nav;
CallbackFunction m_callback;
};
int main() {
Nav nav;
// 定义函数指针
path_follow::CallbackFunction callback = &Nav::waypointCallback;
path_follow pathFollow(&nav, callback);
// 在path_follow类中调用Nav类的回调函数
pathFollow.executeNavCallback();
return 0;
}在上述代码中，我们首先在 Nav 类中定义了 waypointCallback 回调函数。然后，在 path_follow 类中，我们使用 CallbackFunction 函数指针类型来表示 Nav 类的回调函数类型，并将其作为参数传递给 path_follow 类的构造函数。在 executeNavCallback 函数中，我们通过函数指针调用 Nav 类的回调函数。
要将 this 转换为 std::shared_ptr<PathFollow> 类型，您可以使用 std::shared_from_this() 函数。但是，要使用 std::shared_from_this() ，您的类必须继承自 std::enable_shared_from_this 。
以下是一个示例代码，展示了如何在 PathFollow 类中使用 std::shared_from_this() ：
#include <memory>
class PathFollow : public std::enable_shared_from_this<PathFollow> {
public:
void someMethod() {
// 将 this 转换为 std::shared_ptr<PathFollow>
std::shared_ptr<PathFollow> sharedThis = shared_from_this();
// 使用 sharedThis 进行操作
// ...
}
};
int main() {
std::shared_ptr<PathFollow> pathFollow = std::make_shared<PathFollow>();
pathFollow->someMethod();
return 0;
}在上述代码中， PathFollow 类继承自 std::enable_shared_from_this<PathFollow> ，这使得 PathFollow 类能够使用 shared_from_this() 函数。
在 someMethod() 方法中，我们调用了 shared_from_this() ，将 this 转换为 std::shared_ptr<PathFollow> 类型，并将其赋值给 sharedThis 变量，然后可以使用 sharedThis 进行操作。
请注意，使用 std::shared_from_this() 的前提是，您必须在创建 PathFollow 对象时使用 std::shared_ptr<PathFollow> ，而不是使用裸指针。
希望这可以帮助到您！如果您有任何其他问题，请随时提问。
到此这篇关于C++ 两个类通过智能指针进行访问操作的文章就介绍到这了,更多相关C++ 智能指针内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！