ros学习#4 一些与ros有关的C++基础知识_ros需要c++的哪些知识-CSDN博客

4. 函数包装器std::function

三、多线程与回调函数

前言

今天补充一下c++的基础知识

ros2的基础编程

一、面向对象编程

面向对象的编程核心要点在于创建类，所有的编程围绕类进行，类可以看做是一个对象，这个对象拥有属性和方法，所谓的属性就是用来描述这个对象的，比如长度、宽度、年龄这种；所谓的方法就是一系列函数，用来表示这个对象的行为，比如一个人吃饭、写作业、一个机关的开机和关机，一个类的形成就是由这些属性和方法封装而成的。

在调用时可以实例化一个类的对象，比如我想干一件事，那么我就可以创建一个人，这个人就是一个类，在这个类的方法里写上完成这件事的函数，再调用这个方法。

为了学习我编写了如下代码，在/home/hcd/dev_ws/src/learning_pkg_c/src中创建一个新文件命名为phone_node.cpp，代码内容如下：

文件名：phone_node.cpp

#include "rclcpp/rclcpp.hpp"
#include<string>

class PhoneNode: public rclcpp::Node      //创建手机节点这么一个类，让他继承rcl::Node,方便管理节点
{
private:  //在面向对象编程中，通常的做法是将类的属性（成员变量）定义为私有（private），而将方法（成员函数）定义为公共（public）。这种做法是基于封装原则，是面向对象设计的核心概念之一。
    std::string type_;
    int gen_;
    std::string color_;

public:
    PhoneNode(const std::string &node_name,
    const std::string &type,
    const int &gen,
    const std::string &color):Node(node_name)
    {
        this->type_ = type;
        this->gen_ = gen;
        this->color_ = color;
    };

    void power(const int &command)
    {
        if(command == 1)
        {RCLCPP_INFO(this->get_logger(), "我的%s%d%s直接开机", type_.c_str(), gen_, color_.c_str());}
        else if(command == 0)
        {RCLCPP_INFO(this->get_logger(), "关机");}
        else
        {RCLCPP_INFO(this->get_logger(), "看不懂");}
    };

};

int main(int argc, char **argv)
{
    rclcpp::init(argc, argv);
    auto node = std::make_shared<PhoneNode>("phone_node", "HUAWEI", 14, "冷锋蓝");
    node->power(1);
    rclcpp::spin(node);
    //清理资源
    rclcpp::shutdown();
    return 0;
}

首先我创建了一个类PhoneNode ，这个PhoneNode就是一个对象，后面的public rclcpp::Node表示继承Node类，这就是类的一个特性：继承性。这行命令使得他可以使用node类的初始化、运行和销毁等等指令。

接下来我开始依次定义PhoneNode类的属性和方法，在面向对象编程中，通常的做法是将类的属性（成员变量）定义为私有（private），而将方法（成员函数）定义为公共（public）。这种做法是基于封装原则，是面向对象设计的核心概念之一。将属性定义为private可以防止外部访问和修改属性，从而使对象状态意外改变。

接下来我定义了手机phone的三个属性，包括型号type，代数gen和颜色color

然后我定义了方法的两个函数，phonenode函数用来传递参数，power函数用来显示手机的开关机状态。其中std::string 后面的“&”表示传递引用，避免了不必要的数据复制，可以提高代码效率，前面的const限制变量为只读，可以避免他在方法内被意外修改，提高代码安全性，后面的:Node(node_name)用来传递节点名称参数，然后在构造函数内用this指针对手机的型号代数和颜色进行赋值。然后定义power函数，当给出不同指令command时还可以打印不同信息。

在主函数里首先对节点进行初始化，然后调用std::make_shared创建一个PhoneNode对象，并传入其中的属性参数并返回该对象的智能指针赋值给node，然后调用node的power方法进行手机电源的开关操作。根据上一节的ros学习#3-CSDN博客配置CMakelists.txt文件，然后构建并更新环境变量，然后运行，使用下面三行代码：

(myros) hcd@hcd-Dell-G15-5511:~/dev_ws/src/learning_pkg_c$ colcon build
(myros) hcd@hcd-Dell-G15-5511:~/dev_ws/src/learning_pkg_c$ source install/setup.sh
(myros) hcd@hcd-Dell-G15-5511:~/dev_ws/src/learning_pkg_c$ ros2 run learning_pkg_c phone_node

运行结果如下：

二、C++新特性

1. 自动类型推导

主要就是auto关键字的使用，比如正常要用int x = 3和float y = 3.14，但是可以统一用auto来修饰变量，比如auto x = 3和auto y = 3.14，这样就可以简化代码

2. 智能指针

智能指针可以管理动态分配的内存，避免内存泄漏和空指针问题，std::make_shared就是创建一个std::shared_ptr智能共享指针，如果在程序中将一个资源使用智能共享指针进行管理，那么无论进行多少次传递，这个资源都不会发生复制，避免资源的占用，提高运行效率，所有程序使用完之后还会自动回收，不会造成内存泄漏。

3. lambda表达式

lambda表达式有自己的一套语法

[capture list](parameters) -> return_type {function body}

capture list表示捕获列表，可以用于捕获外部变量；parameters表示参数列表；return_type表示返回值类型；function body表示函数体

根据鱼香ros大佬的教程的代码：

#include <iostream>
#include <algorithm>

int main()
{
    auto add = [](int a, int b) -> int{return a+b; };
    int sum = add(3, 5);
    auto print_sum = [sum]() -> void{std::cout << "3+5 = " << sum << std::endl;};
    print_sum();
    return 0;

}

不难看出lambda表达式其实就是一种函数的定义方法，挺方便的，但我目前还没看出来有什么大用……

4. 函数包装器std::function

举个例子

#include <iostream>
#include <functional>

// 一个简单的函数
void sayHello(const std::string& name) {
    std::cout << "Hello, " << name << "!" << std::endl;
}

// 主函数
int main() {
    // 创建一个 std::function 对象，包装一个自由函数
    std::function<void(const std::string&)> func = sayHello;
    // 调用包装的函数
    func("World"); // 输出: Hello, World!

    // 创建一个 lambda 表达式并包装到 std::function 中
    std::function<void()> lambdaFunc = []() {
        std::cout << "Hello, Lambda!" << std::endl;
    };
    // 调用包装的 lambda 表达式
    lambdaFunc(); // 输出: Hello, Lambda!

    // 包装一个带绑定的成员函数
    class Greeter {
    public:
        void say(const std::string& name) {
            std::cout << "Hello, " << name << " from Greeter!" << std::endl;
        }
    };

    Greeter greeter;
    std::function<void(const std::string&)> boundFunc = std::bind(&Greeter::say, &greeter, std::placeholders::_1);
    // 调用包装的成员函数
    boundFunc("Moonshot"); // 输出: Hello, Moonshot from Greeter!

    return 0;
}

在这个例子中：

func 是一个 std::function 对象，它包装了一个自由函数 sayHello。我们可以直接通过 func 调用 sayHello 函数。
lambdaFunc 是一个 std::function 对象，它包装了一个 lambda 表达式。这个 lambda 表达式是一个匿名函数，它打印一条消息。
boundFunc 是一个 std::function 对象，它包装了一个成员函数 say 的绑定表达式。我们使用 std::bind 来绑定 Greeter 类的 say 成员函数和对象 greeter，以及一个占位符 std::placeholders::_1 来预留一个位置传递 say 函数的参数

这使得我们可以把不同函数储存在函数封装器中，并提供统一的调度方式。说实话我目前也没有体会到这种方法的方便之处……

三、多线程与回调函数

举个例子：

#include <iostream>
#include <thread>
#include <functional>

// 一个模拟耗时计算的函数
int compute(int x, int y) {
    std::this_thread::sleep_for(std::chrono::seconds(2)); // 模拟耗时操作
    return x + y;
}

// 回调函数类型
std::function<void(int)> callback;

// 线程完成时调用的回调函数
void onComputeComplete(int result) {
    std::cout << "Compute completed with result: " << result << std::endl;
    if (callback) {
        callback(result); // 调用注册的回调函数
    }
}

int main() {
    int a = 5;
    int b = 3;

    // 设置回调函数，这个函数将在计算完成后被调用
    callback = [](int result) {
        std::cout << "Received result in main thread: " << result << std::endl;
    };

    // 启动线程执行计算
    std::thread computeThread([&a, &b]() {
        int result = compute(a, b);
        onComputeComplete(result); // 计算完成后调用回调函数
    });

    // 主线程继续执行其他任务
    std::cout << "Main thread is doing other tasks..." << std::endl;

    // 等待线程完成
    computeThread.join();

    return 0;
}

我们定义了一个 compute 函数，它模拟了一个耗时的计算操作。
我们定义了一个 onComputeComplete 函数，它作为线程完成时的回调函数，并且可以调用一个注册的回调函数（在这个例子中是 callback）。
在 main 函数中，我们设置了一个回调函数，这个函数将在计算完成后被调用，并打印结果。
我们创建了一个 std::thread 对象 computeThread 来异步执行计算操作。
在 computeThread 线程中，我们调用了 compute 函数，并在计算完成后调用了 onComputeComplete 函数。
onComputeComplete 函数打印了一条消息，并调用了注册的回调函数（如果存在）。
主线程通过调用 computeThread.join() 等待计算线程完成。