多线程；顺序容器；智能指针

#include <iostream>
#include <thread>
#include <stdlib.h> //sleep
 
using namespace std;
 
void t1()  //普通的函数，用来执行线程
{
    for (int i = 0; i < 10; ++i)
    {
        cout << "t1111\n";
        sleep(1);
    }
}
void t2()
{
    for (int i = 0; i < 20; ++i)
    {
        cout << "t22222\n";
        sleep(1);
    }
}
int main()
{
    thread th1(t1);  //实例化一个线程对象th1，使用函数t1构造，然后该线程就开始执行了（t1()）
    thread th2(t2);
 
    th1.join(); // 必须将线程join或者detach 等待子线程结束主进程才可以退出
    th2.join(); 
 
    cout << "here is main\n\n";
 
    return 0;
}

int main(int argc, char** argv)
{
    ros::init(argc, argv, "lio_sam");
 
    mapOptimization MO;
 
    ROS_INFO("\033[1;32m----> Map Optimization Started.\033[0m");
    
    std::thread loopthread(&mapOptimization::loopClosureThread, &MO);
    std::thread visualizeMapThread(&mapOptimization::visualizeGlobalMapThread, &MO);
 
    ros::spin();
 
    loopthread.join();
    visualizeMapThread.join();
 
    return 0;
}

#include<iostream>
#include<thread>
#include<mutex>
 
using namespace std;
 
mutex m;
int cnt = 10;
 
void thread1() {
    while (cnt > 5){
        m.lock();
        if (cnt > 0) {
            --cnt;
            cout << cnt << endl;
        }
        m.unlock();
    }
}
 
void thread2() {
    while (cnt > 0) {
        m.lock();
        if (cnt > 0) {
            cnt -= 10;
            cout << cnt << endl;
        }
        m.unlock();
    }
}
 
int main(int argc, char* argv[]) {
    thread th1(thread1);   //实例化一个线程对象th1，该线程开始执行
    thread th2(thread2);
    th1.join();
    th2.join();
    cout << "main..." << endl;
    return 0;
}

void laserCloudCornerLastHandler(const sensor_msgs::PointCloud2ConstPtr &laserCloudCornerLast2)
{
  mBuf.lock();
  cornerLastBuf.push(laserCloudCornerLast2);
  mBuf.unlock();
}

std::thread thread2([&]()){
    for(int i=0;i<10000;i++)
    {
        mtx.lock();
        ++num;
        mtx.unlock();
    }
});

//订阅imu里程计，由imuPreintegration积分计算得到的每时刻imu位姿
    void odometryHandler(const nav_msgs::Odometry::ConstPtr& odometryMsg)
    {
        std::lock_guard<std::mutex> lock2(odoLock);
        odomQueue.push_back(*odometryMsg);
    }

size()返回容器中元素数目；
swap()交换两个容器的内容；
begin()返回一个指向容器中第一个元素的迭代器；
end()返回一个表示超过容器尾的迭代器（指向容器最后一个元素后面的那个元素位置）；
push_back()将元素添加到矢量（vector）末尾；
erase()删除矢量中给定区间的元素；
insert()插入指定区间的元素到指定位置；

#include <iostream>
#include <deque>
#include <algorithm>
using namespace std;
 
void printDeque(const deque<int> &d)
{
    for(deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
    {
        cout<<*it<<" ";   
    }
    cout<<endl;
}
 
/* 回调函数 */
bool compare(int v1, int v2)
{
    return v1 > v2; /* 此时的排序是从大到小 */
                    /* 如果从小到大应该改为"v1 < v2" */
}
 
void test()
{
    deque<int> d;
    d.push_back(3);
    d.push_back(4);
    d.push_back(1);
    d.push_back(7);
    d.push_back(2);
 
    sort(d.begin(), d.end(), compare);
    printDeque(d);
}

list<string> names;
vector<const char*> oldstyle = { "I","love","you" };
//names = oldstyle;错误！不同的类型不能执行"="操作
names.assign(oldstyle.cbegin(), oldstyle.cend());
list<string>::iterator it;
for (auto it = names.begin(); names.begin() != names.end(); it++)
        cout << *it << " ";

segMsg.startRingIndex.assign(N_SCAN, 0);
segMsg.endRingIndex.assign(N_SCAN, 0);

shared_ptr<string> p1 //shared_ptr 指向string类型
shared_ptr<list<int>> p2 //shared_ptr 指向int类型的list

//指向一个值为24的int的shared_ptr
shared_ptr<int> p3 =make_shared<int>(42)
//指向一个值为"99999"的string的shared_ptr
shared_ptr<int> p4 =make_shared<string>(5,'9')
//指向一个值为0的int的shared_ptr
shared_ptr<int> p3 =make_shared<int>()

//指向一个值为24的int的shared_ptr
auto p6 =make_shared<int>(42)

auto p=make_shared<int>(42) //p指向的对象只有p一个引用者
auto q(p) //p和q指向相同对象，此对象有两个引用者

p1.use_count();

#include <iostream>
#include  <memory> // 需要包含这个头文件
 
int main()
{
  // 使用 make_shared 创建空对象
  std::shared_ptr<int> p1 = std::make_shared<int>();
  *p1 = 78;
  std::cout << "p1 = " << *p1 << std::endl; // 输出78
 
  // 打印引用个数：1
  std::cout << "p1 Reference count = " << p1.use_count() << std::endl;
 
  // 第2个 shared_ptr 对象指向同一个指针
  std::shared_ptr<int> p2(p1);
 
  // 下面两个输出都是：2
  std::cout << "p2 Reference count = " << p2.use_count() << std::endl;
  std::cout << "p1 Reference count = " << p1.use_count() << std::endl;
 
  // 比较智能指针，p1 等于 p2
  if (p1 == p2) {
    std::cout << "p1 and p2 are pointing to same pointer\n";
  }
 
  std::cout<<"Reset p1 "<<std::endl;
 
  // 无参数调用reset，无关联指针，引用个数为0
  p1.reset();
  std::cout << "p1 Reference Count = " << p1.use_count() << std::endl;
  
  // 带参数调用reset，引用个数为1
  p1.reset(new int(11));
  std::cout << "p1  Reference Count = " << p1.use_count() << std::endl;
 
  // 把对象重置为NULL，引用计数为0
  p1 = nullptr;
  std::cout << "p1  Reference Count = " << p1.use_count() << std::endl;
  if (!p1) {
    std::cout << "p1 is NULL" << std::endl; // 输出
  }
  return 0;
}