将智能指针传递给模板类成员函数时的编译错误

Question

我将面临编译错误传递1.将唯一的ptr传递给模板类成员函数2.指向模板类成员函数的唯一指针的内容

我试图在向量内推送数据。数据是模板类型。此处的唯一指针用于在每次数据到来时在堆上创建内存，然后将该数据存储到向量中。即使复制指向新位置的指针也可以在向量内推送。我已尝试过两种方法1.使用T项捕获数据; //下面提到的代码2.使用std :: unique_ptr＆item捕获引用的唯一指针;示例代码是一种长代码的代码段

#include <stdio.h>
#include<iostream>
#include<vector>
#include <mutex>
#include <condition_variable>
#include <boost/any.hpp>
using namespace std;
namespace amb
{

template <typename T>
class Queue
{
public:
        Queue(bool unique = false, bool blocking = false)
                :mUnique(unique), mBlocking(blocking)
        {
        }
        virtual ~Queue()
        {
        }
        int count()
        {
                std::lock_guard<std::mutex> lock(mutex);
                return mQueue.size();
        }
        T pop()
        {
                std::unique_lock<std::mutex> lock(mutex);
                uint16_t i =0;
                if(mBlocking)
                {
                        if(!mQueue.size())
                        {
                                cond.wait(lock);
                        }
                }
                if(!mQueue.size())
                {
                        throw std::runtime_error("nothing in queue");
                }
                auto itr = mQueue.begin();
                T item = *itr;
                mQueue.erase(itr);
                return item;
        }

        virtual void append(T  item)
        {
            std::lock_guard<std::mutex> lock(mutex);
                        mQueue.push_back(item);
        }
        void remove(T item)
        {
                std::lock_guard<std::mutex> lock(mutex);

                removeOne(&mQueue, item);
        }
        std::vector<T> get_Val()
        {
                return mQueue;
        }
    private:
        bool mBlocking;
        bool mUnique;
        std::mutex mutex;
        std::condition_variable cond;
        std::vector<T> mQueue;
};
}

class AbstractPropertyType
{
public:
 AbstractPropertyType(){}

 virtual ~AbstractPropertyType()
    {

    }

 virtual AbstractPropertyType* copy() = 0;
 boost::any anyValue()
    {
        return mValue;
    }
 protected:

    boost::any mValue;
};

template <typename T>
class BasicPropertyType: public AbstractPropertyType
{
public:
    BasicPropertyType(): AbstractPropertyType("")
    {
        mValue = T();
    }
    AbstractPropertyType* copy()
    {
        return new BasicPropertyType<T>(*this);
    }
};
amb::Queue<AbstractPropertyType*> prop;
void updateProperty(AbstractPropertyType * val)
{
    std::unique_ptr<AbstractPropertyType> temp_data =  std::unique_ptr<AbstractPropertyType>(val->copy());
    prop.append(temp_data);
}
int main() {
    //code
    uint8_t x = 10;
    uint8_t * test_val = &x;
    boost::any to_check = (uint8_t *)test_val;
    AbstractPropertyType * value = new BasicPropertyType<uint32_t>;
    updateProperty(value);
}

主要的moto是1.将模板数据的内容推入向量2.指向指针的指针

编译错误：prog.cpp：在函数'void updateProperty（AbstractPropertyType *）'中：prog.cpp：109：26：错误：没有用于调用'amb :: Queue :: append（std :: unique_ptr＆）'prop的匹配函数.append（TEMP_DATA）; ^

Answer 1

amb::Queue<AbstractPropertyType*> prop;

因此，prop.append()采用AbstractPropertyType*类型的参数，但是你发送temp_data类型的std::unique_ptr<AbstractPropertyType>。由于append函数需要一个原始指针，因此您应该将原始指针传递给它。从unique_ptr<T>到T*没有隐含的转换。

void updateProperty(AbstractPropertyType * val)
{
    std::unique_ptr<AbstractPropertyType> temp_data =  std::unique_ptr<AbstractPropertyType>(val->copy());
    prop.append(temp_data.get());
}