C++知识---奇怪的知识

void get_mock_loc_from_file(const std::string& trail_path, std::vector<MockLoc>& v)
{
    std::string file_path = trail_path;
    if(file_path.empty()){
        std::cout << "empty file path" << std::endl;
        return;
    }
    std::ifstream fin;
    fin.open(file_path.c_str());
    std::string str;
    std::getline(fin, str);
    while (!fin.eof())
    {
        std::getline(fin, str);
        if(str.empty()){
            continue;
        }
        std::stringstream ss(str);
        std::string item;
        MockLoc loc;
        std::vector<std::string> strs;
        while(std::getline(ss, item, ',')){
            strs.push_back(item);
        }
        loc.x = atof(strs[1].c_str());
        loc.y = atof(strs[2].c_str());
        v.push_back(loc);
    }
    fin.close();
}

创建线程的方式

std:sync

#include

auto f = std::async(std::launch::async, [this, &links_csv]() {
            for (size_t i = 0; i < links_csv.size(); i++) {
                links tmp = links_csv.at(i);
                baidu::imap::NavStatus navi_in;
                navi_in.navigation_status = baidu::imap::NS_NAVIGATION;
                navi_in.matching_table_status = baidu::imap::MS_MATCHING_TABLE_OK;
                navi_in.remain_distance = 38500000;
                baidu::imap::NavHDLinkList nav_links;
                nav_links.linkid = tmp.v;
                baidu::imap::dev::MapEngine::instance()->set_navi_status(navi_in);
                baidu::imap::dev::MapEngine::instance()->set_navi_hd_links(nav_links);
                usleep(1000000);
            }
        });

函数原型：

thread构造

创建：

_ehp_send_thread = std::thread(&EhpOutputAdapt::send_message, this);
    pthread_setname_np(_ehp_send_thread.native_handle(), "EhpMsgAdaptSend");

退出：

if (_ehp_send_thread.joinable()) {
        _ehp_send_thread.join();
    }

pthread_cread

pthread_mutex_t _mutex_input;
    pthread_t _comp_thread;

pthread_create(&_comp_thread, NULL, _compute, (void*)this);
    pthread_setname_np(_comp_thread, "HdmapEHR");

void* _compute(void* arg) {
    class* p = static_cast<class*>(arg);
    p->compute();
    return NULL;
}

void compute() {
    std::vector<BUFFER> buffer_vec;
    _out_data_thread_running = true;
    while(_out_data_thread_running)
    {
        if (_buf_dq.size() > 0)
        {
            std::cout << "\n****************************start parse recv data***********************" << std::endl;
            buffer_vec.clear();
            pthread_mutex_lock(&_mutex_input);
            buffer_vec = _buf_dq[0];
            _buf_dq.pop_front();
            pthread_mutex_unlock(&_mutex_input);

			//do something
         }
     }

uint32_t set_current_message(std::vector<BUFFER>& buffer_vec)
{
    pthread_mutex_lock(&_mutex_input);
    _buf_dq.push_back(buffer_vec);
    pthread_mutex_unlock(&_mutex_input);
    return had_ehr::StatusCode::EHR_OK;
}

优先级队列

原理：
复杂度为logn，要知道logn得复杂度大多与二叉树相关，即优先级队列底层也是基于二叉树进行实现得
实现：

namespace wjw3
{
    template<class T>
    class less
    {
    public:
        bool operator()(const T& x, const T& y)const//const
        {
            return x < y;
        }
    };
    template<class T>
    class greater
    {
    public:
        bool operator()(const T& x, const T& y)const
        {
            return x > y;
        }
    };
    template<class T, class Container = vector<T>, class Compare = less<T>>
    class priority_queue
    {
    public:
 
        priority_queue()
        {}
        template<class InputIterator>
        priority_queue(InputIterator first, InputIterator last)
            :_con(first,last)
        {
            //保证每一个左右子树都是堆，找到最后一个孩子节点的父亲，向下调整
            for (size_t i = _con.size() - 1 - 1 / 2; i >= 0; --i)
            {
                adjust_down(i);
            }
        }
        void push(const T& x)
        {
            _con.push_back(x);
            adjust_up(_con.size()-1);
        }
        void pop()
        {
            swap(_con[0], _con[_con.size() - 1]);//交换元素
            _con.pop_back();
            adjust_down(0);
        }
        void adjust_up(size_t child)
        {
            Compare cmp;
            size_t parent = (child - 1) / 2;
            while (child>0)
            {
                if (cmp(_con[parent],_con[child]))
                {
                    swap(_cont[parent], _con[child]);
                    child = parent;
                    parent = (child-1) / 2;
                }
            }
        }
        void adjust_down(size_t parent)
        {
            Compare cmp;
            size_t child = parent * 2 + 1;
            while (child < _con.size())
            {
                if (child + 1 < _con.size() && cmp(_con[parent], _con[child]))
                {
                    child++;
                }
                if (_con[parent] < _con[child])
                {
                    swap(_con[parent], _con[child]);
                    parent = child;
                    child = parent * 2 + 1;
                    
                }
                else
                {
                    break;
                }
 
            }
 
        }
        const T& top()const
        {
            return _con[0];
        }
        bool empty()const
        {
            return _con.empty();
        }
        size_t size()const
        {
            return _con.size();
        }
    private:
        Container _con;
    };
}

NEW的简单使用
1：基础创建

int *a= new int;
delete a;

int *a= new int[10];
delete[]a;

2:定位new
在 C++ 中，new 运算符可以接受一个指向特定内存位置的指针，并在该位置上构造一个对象。这种用法被称为“定位 new”（placement new），语法如下

new (void* pointer) Type();

其中，void* pointer 是指向预分配的内存块的指针，Type 是要在该内存位置上构造的对象类型。
示例：

#include <iostream>

class MyClass {
public:
    MyClass() {
        std::cout << "Constructor called" << std::endl;
    }

    ~MyClass() {
        std::cout << "Destructor called" << std::endl;
    }

    void someMethod() {
        std::cout << "Some method called" << std::endl;
    }
};

int main() {
    // 预分配内存块
    void* memory = malloc(sizeof(MyClass));

    // 使用定位 new 在指定内存地址上构造对象
    MyClass* obj = new (memory) MyClass();

    // 调用类的方法
    obj->someMethod();

    // 手动调用析构函数
    obj->~MyClass();

    // 释放预分配的内存块
    free(memory);

    return 0;
}```
模板示例：

```cpp
template <typename T, class... Args>
T* asf_new(Args&& ...args)
{
    typedef typename std::remove_cv<T>::type T_nc;
    return new(malloc(sizeof(T_nc)))T_nc(std::forward<Args>(args)...);
}

template <typename T>
void delete(T* p)
{
    (static_cast<T*>(p))->~T();
    free(p);
}