c++基础

template<class T>
using vc = std::vector<T>;
//这个声明语法使用 template<class T> 指定了一个模板参数 T，它表示一种未知的类型。
//通过声明模板参数，你可以在后续的代码中使用 T 来表示这个未知的类型，并在需要的地方进行具体化

1. 模板函数
template<class T>
void myTemplateFunction(T param) {
    // 在这里可以使用 T 来表示参数的类型
}

2.模板类
template<class T>
class MyTemplateClass {
public:
    T myVar;  // 在这里可以使用 T 来表示成员变量的类型
};

3. 模板别名
template<class T>
using MyTemplateAlias = std::vector<T>;  // 在这里可以使用 T 来表示容器中元素的类型
//可以使用 vc<int> 类型声明来代替 std::vector<int>

template<class T>
    using sp = std::shared_ptr<T>;//std::shared_ptr<T> 定义为一个新的类型别名 sp
//这里的模板类型 T 表示这个新的 sp 类型可以用于管理任意类型的对象。例如，当需要创建一个 //shared_ptr 来管理一个 string 对象时，可以使用 sp<string> 类型声明来简化代码
sp<string> ptr1 = std::make_shared<string>("hello");
sp<string> ptr2 = std::make_shared<string>("world");
//这样就可以使用 ptr1 和 ptr2 来指向 string 类型的对象，而不必每次都写出 std::shared_ptr<string>

data.reserve(end - start + 1); //reserve函数可以预留容器元素个数

//获取输入数据中起始位置的地理坐标点  at()是 容器的成员函数，返回容器中指定索引的元素
auto start_point = input->at(start)->trajectory_->geo_point_;

//emplace_back() 是容器的成员函数，在容器的末尾就地构造一个新元素，不需要手动创建该元素的对象
//LocTrajectory() 是一个类或结构体的默认构造函数，用于创建一个名为 LocTrajectory 的对象
//可以将一个新的 LocTrajectory 对象添加到 data 容器的末尾。
//这样做的好处是避免了显式创建临时对象，并且可以节省一些复制或移动操作的开销。
data.emplace_back(LocTrajectory());

//data.back() 是容器的成员函数，用于返回容器中最后一个元素的引用
auto& info = data.back();

---

LocalOptimizationProcess* LocalOptimizationProcess::GetInstance()
{
    static LocalOptimizationProcess instance;
    return &instance;
}

这段代码是 C++ 中的单例模式的实现，用于在整个程序中创建一个唯一的 LocalOptimizationProcess 对象。

单例模式是一种经典的设计模式，在许多编程语言中都有使用，它保证某个类只有一个实例化对象，并且提供了全局访问该对象的机制。

这个具体的实现方式，通过静态局部变量来创建唯一的对象 instance，其内存空间在程序开始运行时就被分配，并在程序结束时自动回收。在调用 GetInstance() 函数时，该函数会返回这个唯一的对象的地址。

如果需要在程序中使用这个类的功能，可以通过调用 GetInstance() 函数获取该类的对象，而不必担心多次实例化或多个对象实例竞争同样的资源可能引发的问题

---

std::vector<int> vec;
int num = 10;
vec.push_back(num);

上述代码中，num 是一个整数变量，通过 push_back 将其添加到 vec 容器中。push_back 会复制 num 的值，并在容器中构造一个新的整数对象

std::vector<int> vec;
int num = 10;
vec.emplace_back(num);

上述代码中，num 是一个整数变量，通过 emplace_back 将其添加到 vec 容器中。emplace_back 直接在容器中构造一个新的整数对象，并接受 num 作为构造函数的参数

总结一下区别：

• push_back 将会复制给定的对象，并在容器中构造一个新的对象。
• emplace_back 在容器中直接构造一个新的对象，避免了复制的开销。

需要注意的是，emplace_back 在构造对象时需要传递相应的构造函数参数，而 push_back 只需要对象类型可复制构造即可。

---

C++带条件编译的模板类：                                                                                                        

template<class T,typename = std::enable_if_t<std::is_same<T, int32_t>::value
                            || std::is_floating_point<T>::value>>
struct DataExportPoint {

    DataExportPoint() : x_(0.0), y_(0.0), z_(0.0) {}

    DataExportPoint(T x, T y, T z)
    {
        x_ = x;
        y_ = y;
        z_ = z;
    }

    template <typename Writer>
    void Serialize(Writer& writer) const {
        if (std::is_floating_point<T>::value)
        {
            writer.StartArray();
            writer.Double(x_);
            writer.Double(y_);
            writer.Double(z_);
            writer.EndArray();

            return;
        }

        writer.StartArray();
        writer.Uint(x_);
        writer.Uint(y_);
        writer.Uint(z_);
        writer.EndArray();
    }

    T x_;
    T y_;
    T z_;
};

这是一个具有条件编译的类模板定义。该类模板是一个数据导出点的结构，可以将其序列化为不同的格式，具体取决于模板参数 T 的类型；

---

define结合typedef使用

#define DECLARE_SHARED_PTR(__TYPE__) typedef std::shared_ptr<__TYPE__> SharedPtr

这个宏定义了一个名为 DECLARE_SHARED_PTR 的宏，它接受一个类型参数 __TYPE__，然后使用 typedef 创建了这个类型的 std::shared_ptr 的别名 SharedPtr

使用该宏

DECLARE_SHARED_PTR(MyClass); // 声明一个名为 SharedPtr 的指向 MyClass 类型对象的智能指针

// 使用 SharedPtr 创建智能指针并初始化
SharedPtr myPtr(new MyClass());