我在c++项目调用文件make的时候报错，其中这是AsyncHeartClient.h文件
"#ifndef OPENCVDEMO_HEARTCLIENT_H
#define OPENCVDEMO_HEARTCLIENT_H

#include <atomic>
#include <boost/date_time/posix_time/posix_time_duration.hpp>
#include <boost/asio/deadline_timer.hpp>
#include "AsyncClient.h"



template <typename receivedMsgT,typename sendMsgT>
class AsyncHeartClient
{
public:
    //心跳回调函数,在定时器中会自动发送心跳,也可以通过该函数执行一些其他自定义操作
    typedef std::function<void(const sendMsgT &sendedMsg)> TimerCallBack;
public:
    AsyncHeartClient() = delete;

    AsyncHeartClient(const std::string &addr, int port, unsigned int heart_interval, ReadCallBack readCallBack = nullptr,
                     TimerCallBack timerCallBack = nullptr);

    virtual ~AsyncHeartClient();

    /*!
     * 心跳初始化
     * @param heart_interval 心跳间隔
     * @param timerCallBack 自定义心跳函数
     */
    //void InitHeartBeat(unsigned int heart_interval=200,TimerCallBack timerCallBack= nullptr);

    /*!
     * 获取接收的数据
     * @param data
     * @return 接收的数据是否已更新.true:是;false:否
     */
    bool GetReceivedData(receivedMsgT &data);

    /*!
     * 设置发送给PLC的数据.Note:设置完毕后不会立即发送,需要等待定时器下一次执行到才会发送;会自动添加包头,包尾,心跳编号
     * @param msg
     */
    virtual void UpdateSendData(const sendMsgT &msg);

    /*!
     * 套接字是否连接.无法判断网线突然不通情况
     * @return
     */
    bool isConnected() const;

    /*!
     * 是否需要重新初始化对象.针对网线突然中断情况
     * @return true:重新初始化该对象
     */
    bool isNeedReConstruct();

private:
    /*!
     * 心跳初始化
     * @param heart_interval 心跳间隔
     * @param timerCallBack 自定义心跳函数
     */
    void InitHeartBeat(unsigned int heart_interval = 200, TimerCallBack timerCallBack = nullptr);

    //心跳数据发送.心跳间隔:m_timerInterval
    void SendHeartBeat(const boost::system::error_code &ec);

    //消息接收回调
    void ReceivedCallBack(const std::string &addr, int port, CallBackType type, const std::vector<unsigned char> &data,
                          const size_t len);

protected:
    //通信模块
    std::shared_ptr<AsyncClient> m_pSocket;

    //自定义消息处理函数
    ReadCallBack m_readCallBack;
    //自定义定时执行函数
    TimerCallBack m_timerCallBack;

    //定时间隔.心跳数据发送间隔
    boost::posix_time::milliseconds m_timerInterval;
    std::shared_ptr<boost::asio::deadline_timer> m_pTimer;
    //心跳编号
    std::atomic_ushort m_heartNo;
    std::atomic_ushort m_plcHeartNo;//收到的plc心跳编号
    std::atomic<sendMsgT> m_sendMsg;
    std::atomic<receivedMsgT> m_receivedMsg;
    std::atomic_bool m_bRecMsgUpdated;
    std::atomic_int m_unchangeNum;

};
#endif //OPENCVDEMO_HEARTCLIENT_H
"
AsyncHeartClient.hpp文件代码
"#include "AsyncHeartClient.h"
#include <boost/asio.hpp>
#include <boost/bind/bind.hpp>
#include <iostream>
#include <thread>


template<typename receivedMsgT, typename sendMsgT>
AsyncHeartClient<receivedMsgT, sendMsgT>::AsyncHeartClient(const std::string &addr, int port,
                                                           unsigned int heart_interval, ReadCallBack readCallBack,
                                                           TimerCallBack timerCallBack)
        :m_pSocket(new AsyncClient(addr, port, std::bind(&AsyncHeartClient::ReceivedCallBack, this, \
std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4, std::placeholders::_5), \
sizeof(receivedMsgT))), m_readCallBack(readCallBack), m_timerCallBack(nullptr), m_timerInterval(200), m_pTimer(nullptr),
         m_heartNo(0),m_plcHeartNo(0),
         m_sendMsg(sendMsgT()), m_receivedMsg(receivedMsgT()), m_bRecMsgUpdated(false), m_unchangeNum(0)
{
    InitHeartBeat(heart_interval, timerCallBack);
}

template<typename receivedMsgT, typename sendMsgT>
AsyncHeartClient<receivedMsgT, sendMsgT>::~AsyncHeartClient()
{
    m_pTimer->cancel();
    m_pTimer = nullptr;
    //std::this_thread::sleep_for(std::chrono::milliseconds(2*m_timerInterval.total_milliseconds()));
}

template<typename receivedMsgT, typename sendMsgT>
bool AsyncHeartClient<receivedMsgT, sendMsgT>::isConnected() const
{
    return m_pSocket->isConnected();
}

template<typename receivedMsgT, typename sendMsgT>
bool AsyncHeartClient<receivedMsgT, sendMsgT>::isNeedReConstruct()
{
    bool bTimeOut = false;
    if (m_unchangeNum * m_timerInterval.total_milliseconds() > 5000)
    {
        m_unchangeNum = 0;
        bTimeOut = true;
    }

    return (this->isConnected() && bTimeOut);
}

template<typename receivedMsgT, typename sendMsgT>
void AsyncHeartClient<receivedMsgT, sendMsgT>::InitHeartBeat(unsigned int heart_interval, TimerCallBack timerCallBack)
{
    assert(heart_interval > 0);


    m_timerInterval = boost::posix_time::milliseconds(heart_interval);
    m_pTimer = std::make_shared<boost::asio::deadline_timer>(*(m_pSocket->pIOservice()), m_timerInterval);

    m_timerCallBack = timerCallBack;


    // Set an expiry time relative to now.
    m_pTimer->expires_from_now(m_timerInterval);
    // Posts the timer event
    m_pTimer->async_wait(boost::bind(&AsyncHeartClient::SendHeartBeat, this, boost::asio::placeholders::error));
}

template<typename receivedMsgT, typename sendMsgT>
void AsyncHeartClient<receivedMsgT, sendMsgT>::SendHeartBeat(const boost::system::error_code &ec)
{
    auto start_timer = [&]()
    {
        // Set an expiry time relative to now.
        m_pTimer->expires_from_now(m_timerInterval);
        // Posts the timer event
        m_pTimer->async_wait(boost::bind(&AsyncHeartClient::SendHeartBeat, this, boost::asio::placeholders::error));
    };

    if (ec)
    {
        if (m_pTimer)
            start_timer();
        return;
    }


    //1°
    ++m_unchangeNum;

    //2°发送心跳
    auto msg = m_sendMsg.load(std::memory_order_relaxed);
    msg.head = sendMsgT().head;
    msg.heartNo = m_heartNo++;
    msg.plcHeartNo = m_plcHeartNo;
    msg.tail = sendMsgT().tail;

    std::vector<unsigned char> sendBuffer(sizeof(msg), 0);
    std::memcpy(&sendBuffer[0], &msg, sizeof(msg));
    m_pSocket->AsyncSend(sendBuffer);


    //3°执行自定义函数
    if (m_timerCallBack) m_timerCallBack(msg);


    //4°启动定时器
    start_timer();
}

template<typename receivedMsgT, typename sendMsgT>
bool AsyncHeartClient<receivedMsgT, sendMsgT>::GetReceivedData(receivedMsgT &data)
{
    std::memset(&data, 0, sizeof(receivedMsgT));

    bool bUpdated = m_bRecMsgUpdated;

    data = m_receivedMsg.load(std::memory_order_relaxed);

    m_bRecMsgUpdated = false;

    return bUpdated;
}

template<typename receivedMsgT, typename sendMsgT>
void AsyncHeartClient<receivedMsgT, sendMsgT>::UpdateSendData(const sendMsgT &msg)
{
    m_sendMsg.store(msg, std::memory_order_relaxed);
}

template<typename receivedMsgT, typename sendMsgT>
void AsyncHeartClient<receivedMsgT, sendMsgT>::ReceivedCallBack(const std::string &addr, int port, CallBackType type,
                                                                const std::vector<unsigned char> &data,
                                                                const size_t len)
{
    if (m_readCallBack)m_readCallBack(addr, port, type, data, len);

    switch (type)
    {
        case RECVED_MSG:
        {
            m_unchangeNum = 0;

            if (len != sizeof(receivedMsgT))
                return;

            receivedMsgT _rMsg;
            std::memcpy(&_rMsg, &data[0], sizeof(receivedMsgT));
            if (receivedMsgT().head != _rMsg.head || receivedMsgT().tail != _rMsg.tail)
                return;

            m_receivedMsg.store(_rMsg, std::memory_order_relaxed);
            m_plcHeartNo = _rMsg.heartNo;
            m_bRecMsgUpdated = true;

//            std::cout<<"Hex code:";
//            for (int i = 0; i < len; ++i)
//            {
//                printf("%02X ",data[i]);
//            }
//            std::cout<<std::endl;

            break;
        }
        default:
            break;
    }
}
" 你先不用急着回答，还有两个文件