Question

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

我正在尝试将数据推送到vector中。数据是模板类型。此处的唯一指针用于在每次数据到来时在堆上创建内存，然后将该数据存储到向量中。即使指向新位置的指针的复制也可以推入向量内部。我都尝试过 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());
}

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

1 个答案: