在最近学习cartographer算法的时候，发现源码中大量的使用了std::shared_ptr与std::make_unique，对于这些东西之前不是很了解，为了更好的理解源代码，因此简单学习了一下这块内容的使用，在这里简单记个笔记。

std::shared_ptr

shared_ptr是一种智能指针（smart pointer），作用有如同指针，但会记录有多少个shared_ptrs共同指向一个对象。这便是所谓的引用计数（reference counting）。
一旦最后一个这样的指针被销毁，也就是一旦某个对象的引用计数变为0，这个对象会被自动删除。

其创建方式主要包含以下几种：
1、空shared_ptr

shared_ptr <T>  ptr;

2、使用new创建

shared_ptr<T> ptr(new T());

3、使用复制构造函数，或者重载=构造

shared_ptr<T> ptr1(new T()); 
shared_ptr<T> ptr2(ptr1);

示例：

shared_ptr<int> sp(new int(10));                //一个指向整数的shared_ptr    
assert(sp.unique());                            //现在shared_ptr是指针的唯一持有者     
shared_ptr<int> sp2 = sp;                       //第二个shared_ptr,拷贝构造函数     
assert(sp == sp2 && sp.use_count() == 2);       //两个shared_ptr相等,指向同一个对象,引用计数为2    
*sp2 = 100;                                     //使用解引用操作符修改被指对象    
assert(*sp == 100);                             //另一个shared_ptr也同时被修改     
sp.reset();                                     //停止shared_ptr的使用    
assert(!sp); 

有些东西不是完全理解，先放这儿，后面看得多了写的多了自然就理解了。

此外，与shared_ptr相反的还有unique_ptr，它的区别在于unique_ptr实现独占式拥有（exclusive ownership）或严格拥有（strict ownership）概念，保证同一时间内只有一个智能指针可以指向该对象。它对于避免资源泄露（resourece leak）——例如“以new创建对象后因为发生异常而忘记调用delete”——特别有用。

std::make_unique

std::make_unique 是 C++11 标准引入的一个模板函数，用于动态分配指定类型的内存，并返回一个指向分配内存的唯一指针 (即 std::unique_ptr)。

std::make_unique 的语法如下：

template<typename T, typename... Args>
std::unique_ptr<T> make_unique(Args&&... args);

其中，T 是指定的类型，Args 是可变长模板参数包，用于传递给指定类型的构造函数的参数。在调用 std::make_unique 时，通过 Args 包传入构造函数的参数会被转发给类型 T 的构造函数，以生成相应的对象实例。该函数返回的指针是一个 std::unique_ptr 类型，表示一个拥有指向动态内存的所有权的对象。

为了方便理解std::shared_ptr与std::make_unique，我们在这里举个例子：

例1

#include "ros/ros.h"  
#include "std_msgs/String.h"
using namespace std;
 
class A {
public:
    //std::shared_ptr<B> pointer;
    ~A() {
        std::cout << "A was destroyed" << std::endl;
    }
    void printdata()
    {
        std::cout << "print A class data" << std::endl;
    }
};

class share_test
{
    public:
    share_test();
    ros::Subscriber data_sub;
    void init();
    private:
    std::shared_ptr<A> a;
    void dataCallback(const std_msgs::String::ConstPtr &msg);
};
share_test::share_test()
{
    ros::NodeHandle n;
	ros::NodeHandle private_nh("~");
    data_sub = n.subscribe<std_msgs::String>("/data_pub",1,&share_test::dataCallback,this);
}


void share_test::init()
{
    a = std::make_unique<A>();
    //std::shared_ptr<A> a = std::make_shared<A>();
}

void share_test::dataCallback(const std_msgs::String::ConstPtr &msg)
{
    a->printdata();
}
int main(int argc, char **argv)  
{
    ros::init(argc, argv, "share_test");  
    share_test share_test;
    share_test.init();
    ros::spin();  
    return 0;
}

在上述函数中，定义了两个类函数A以及share_test，在函数初始化中我们初始化了share_test类，同时在share_test中声明了一个shared_ptr指针：

std::shared_ptr<A> a;

注意这里创建的是一个空指针，上述创建方法中第一种。然后我们在下面的init函数中使用make_unique将其创建为动态分配的智能指针：

a = std::make_unique<A>();

此时，原来的空指针就变成了指向类A的智能指针。这里有个问题，在《C++ 的 make_unique》这篇博客中使用：

auto a = std::make_unique<A>();

的方式建立了指向A的智能指针时，a的指针类型为unique_ptr，但是这里我初始化时将其初始化为shared_ptr似乎也是一样的？不是很理解。

在完成这一步之后，就有了一个指向class A的智能指针。然后我们就可以调用class A中的相关函数，例如这里我们在订阅data_pub的回调函数中引用了A的print函数，编译运行后新开一个终端输入：

rostopic pub -1 /data_pub std_msgs/String "data: 'SSS'"

就可以在节点这边的终端显示如下输出：

可以看到这里打印出了class A中的打印输出。通过这种指针的方式我们可以很容易的引用一些其他类函数进行需求的解算

例2

再看一个新的例子：

#include "ros/ros.h"  
#include "std_msgs/String.h"
using namespace std;

class C
{
public:
    double input_1;
    string input_2;
    C(double data1,string data2){
        std::cout << "data1 is:" << data1 << std::endl;
        std::cout << "data2 is:" << data2 << std::endl;
        input_1 = data1;
        input_2 = data2;
    }
    void printdata()
    {
        std::cout << "print C class data" << std::endl;
        std::cout << "input_1 is:" << input_1 << std::endl;
        std::cout << "input_2 is:" << input_2 << std::endl;
    }
    ~C() {
        std::cout << "C was destroyed" << std::endl;
    }
};


class share_test
{
    public:
    share_test();
    ros::Subscriber data_sub;
    void init();
    private:
    std::shared_ptr<C> c;
    std::shared_ptr<C> c2;
    void dataCallback(const std_msgs::String::ConstPtr &msg);
};
share_test::share_test()
{
    ros::NodeHandle n;
	ros::NodeHandle private_nh("~");
    data_sub = n.subscribe<std_msgs::String>("/data_pub",1,&share_test::dataCallback,this);
}


void share_test::init()
{
    c = std::make_unique<C>(1,"abc");
    c2 = std::make_unique<C>(2,"abcd");
    //std::shared_ptr<A> a = std::make_shared<A>();
}

void share_test::dataCallback(const std_msgs::String::ConstPtr &msg)
{
    c->printdata();
    c2->printdata();
}
int main(int argc, char **argv)  
{
    ros::init(argc, argv, "share_test");  
    share_test share_test;
    share_test.init();
    ros::spin();  
    return 0;
}

这里与上面的例子略有不同，这里的calss C定义了一个初始化函数，需要传递两个参数，同时在它的print函数中会打印这两个参数。而在class share_test中创建了两个指针：

    std::shared_ptr<C> c;
    std::shared_ptr<C> c2;

随后我们再次使用make_unique创建了两个指向class C的智能指针：

    c = std::make_unique<C>(1,"abc");
    c2 = std::make_unique<C>(2,"abcd");

编译运行这个程序，终端会显示如下：

可以看到这里输出了4条打印，这是因为share_test::init()函数初始化了两个智能指针，class C这个类作为模板类被使用了两次。

而后，我们再次触发一下subscriber回调函数，可以显示打印如下：

到这里执行了两次打印调用：

c->printdata();
c2->printdata();

这两个智能指针虽然是指向了同一个模板类，但是由于我们在创建的时候传参是不一样的，因此它们的打印结果也是不一样的，这个就是模板类与智能指针的好处了，通常我们只需要定一一个类函数，然后通过这样一个make_unique的方式创建一个智能指针，就可以使用它里面的一些函数，同时，由于它的指针是独享的，因此我虽然两个指针指向的是同一个类，但是由于类初始化时传递的参数不一致，最后得到的结果也是不一致的，这就极大的便利了一些重复性类函数的使用，例如在cartographer中，使用的子图的概念，就是通过类函数与指针的形式实现的。

参考：
std::shared_ptr 详解
shared_ptr(共享指针)使用总结
C++11新特性之十三：std::make_unique和std::make_shared
C++ 的 make_unique（含 C++ 代码示例）