Templates 如何键入定义封装模板类的智能指针

如何键入定义一个

std:：unique_ptr

，其中

T

是一个模板类

对象

我有一个模板类Object.h:

    template<typename T>
    class Object
    {
    public:
       Object()                      {}
       ~Object()                     {}

       T getValue()                  { return value_; }
       void setValue(T value)        { value_ = value; }

    private:
       T value_;
    }

模板
类对象
{
公众：
对象（）{}
~Object（）{}
T getValue（）{返回值}
void setValue（T值）{value_u=value；}
私人：
T值；
}

还有另一个名为Holder的类，它在容器中保存一个包裹在智能指针中的对象，

std:：unique\u ptr

：

    template<typename T>
    class Holder
    {
    public:
       Holder()                      {}
       ~Holder()                     {}

    private:
       std::vector<std::unique_ptr<Object<T>>> objects_;
    }

模板
阶级持有者
{
公众：
Holder（）{}
~Holder（）{}
私人：
std：：向量对象；
}

我总是使用typedef来引用封装在智能指针中的对象，因此我在类定义中添加了以下typedef：

    template<typename T>
    class Holder
    {
       typedef std::unique_ptr<Object<T>> ObjectPtr; // - (1)
      // using  ObjectPtr = std::unique_ptr<T, Object<T>> - (2) alias template - same error as above
      // typedef std::unique_ptr<Object<T>> ObjectPtr<T> - not allowed
      // ..

     private:
        std::vector<ObjectPtr<T>> objects_;

模板
阶级持有者
{
typedef std:：unique_ptr ObjectPtr；//-（1）
//使用ObjectPtr=std:：unique_ptr-（2）别名模板-与上述错误相同
//typedef std:：unique_ptr ObjectPtr-不允许
// ..
私人：
std：：向量对象；

---

但是，将成员变量

objects\uuuu

的类型更改为

ObjectPtr

会导致编译器错误

C2947：期望´>´终止模板参数列表，发现´如果我对您想要实现的目标的理解正确，解决方案是声明：

模板
阶级持有者
{
公众：
模板
使用ObjectPtr=std:：unique\u ptr；
void add_对象（ObjectPtr newObject）
{objects_u.emplace_uback（std:：move（newObject））；}
私人：
std：：向量对象；
};
int main（）
{
持有人；
holder.add_objet（make_unique（））；
}

编辑

因为我的解决方案在主模板中定义了一个内部模板，这太过繁琐了：在主模板中，ObjectPtr的每次使用都必须由T参数化。请参阅下面由其他参与者提出的基于typedef的解决方案，以获得更简单的解决方案。
您可能只需要：

template<typename T>
class Holder
{
   typedef std::unique_ptr<Object<T>> ObjectPtr; // - (1)

   void add_object( ObjectPtr newObject )
   { objects_.emplace_back(std::move(newObject)); }

 private:
    std::vector<ObjectPtr> objects_;
};

int main()
{
    Holder<int> holder;
    holder.add_object(make_unique<Object<int>>());
}

模板
阶级持有者
{
typedef std:：unique_ptr ObjectPtr；//-（1）
void add_对象（ObjectPtr newObject）
{objects_u.emplace_uback（std:：move（newObject））；}
私人：
std：：向量对象；
};
int main（）
{
持有人；
holder.add_对象（make_unique（））；
}

请注意，
Holder:：ObjectPtr
不需要自己的参数，因为它使用包含类中的
t
。
在类定义中，引用时不需要将定义的typedef参数化为typename t，只需直接替换ObjectPtr：

不起作用：

std::vector<ObjectPtr<T>> objects_;

std:：向量对象；

作品：

std::vector<ObjectPtr> objects_;

std:：向量对象；
我希望有一个唯一的指针包装一个对象，以及它们的集合：
使用ObjectPtr=std:：unique\u ptr
然后：
std:：vector
。抱歉，我不清楚这一点。这个代码示例应该是很好的，谢谢。我在模板别名之前缺少了
模板
。我想知道当它已经引用与类相同的类型时，为什么必须再次包含它。@KoolBananna:在Daniel的解决方案中，它没有引用与类相同的类型参数。（请参阅我的澄清编辑）完全同意本，我的解决方案是一个过激的，他的解决方案更简单。我要做一些编辑来说明为什么。你真的不想真正地对这个类型进行参数化吗？“并且”是C++中对类定义的重要终止。
std::vector<ObjectPtr> objects_;