c++ - 为什么模板化的类在初始化列表中而不是方法主体中识别另一个类的构造函数？

作为加速C ++ Ch.14-6练习的一部分，我开发了Ptr和Cntr两类。


Ptr类是一个句柄类，它包含一个指针成员，并允许用户控制是否复制该指针引用的基础对象。
Cntr类是包含size_t类型的成员的类，该成员是指向给定对象的指针计数。


当Ptr尝试调用某些（不是全部）Cntr构造函数和Cntr析构函数时，我收到错误消息：


  错误：对“（Cntr）（std :: size_t *）”的调用不匹配
  
  错误：对“（Cntr）（）”的调用不匹配


我已经通过将构造函数移到Ptr的初始化列表中解决了一些问题。但是，在其他情况下，我需要在初始化列表之外调用〜Cntr（）析构函数。关于它为什么起作用的指导，它可以在初始化列表中起作用，但不在外部起作用，这也将有所帮助。

此代码示例并不小，但在我在stackoverflow.com上看到的其他代码的范围内。我完整的ptr.h头文件列出如下：

#ifndef GUARD_Ptr
#define GUARD_Ptr

//Ptr.h header file
#include "vec.h"

using std::size_t;

template <class T> T* clone (const T* tp);
template<> Vec<char>* clone(const Vec<char>* vp);
template <class T> class Ptr;

class Cntr {
public:
    size_t* refptr; // member made public while debugging

    Cntr() : refptr(new size_t(1)) { }
    Cntr(const Cntr& cntptr) : refptr(cntptr.refptr) { ++*refptr; }
    Cntr(size_t* t) : refptr(t) { }

    ~Cntr()
    {
        delete refptr;
    }

    size_t value() {
        return *refptr;
    }

    size_t add() {
        ++*refptr;
        return *refptr;
    }

    size_t subtract() {
        --*refptr;
        return *refptr;
    }

};


template <class T>
class Ptr {
public:
    // new member to copy the object conditionally when needed
    void make_unique()
    {
       if (cntptr.value() != 1) {
            cntptr.subtract();
            cntptr(new size_t(1));
            p = p? clone(p) : 0; // call the global version of close
       }
    }

    // the rest of the class looks like Ref_handle except for its name
    Ptr() : p(0), cntptr()  { }
    Ptr(T* t): p(t), cntptr() { }
    Ptr(const Ptr<T>& h): p(h.p), cntptr(h.cntptr) { }

    Ptr<T>& operator=(const Ptr<T>& rhs)
    {
        cntptr.add();
        // free the lhs, destroying pointers if appropriate
        if (cntptr.subtract() == 0) {
            ~cntptr();
            delete p;
        }
        // copy in values from the rhs
        cntptr(rhs.cntptr);
        p = rhs.p;
        return *this;
    }

    ~Ptr()
    {
        if (cntptr.subtract() == 0) {
            ~cntptr();
            delete p;
        }
    }

    operator bool() const { return p; }
    T& operator*() const {
        if (p)
            return *p;
        throw std::runtime_error("unbound Ptr");
    }

    T* operator->() const {
        if (p)
            return p;
        throw std::runtime_error("unbound Ptr");
    }

private:
    T* p;
    Cntr cntptr;
};


#endif //GUARD_Ptr

最佳答案

您的头文件已编译，没有任何问题。似乎代码的模板实例化存在问题。请确保由class T保留的Ptr应符合模板。检查复制构造函数是私有的还是公共的？

请参阅我在http://codepad.org/m7aSJ9pa处运行的示例。

关于c++ - 为什么模板化的类在初始化列表中而不是方法主体中识别另一个类的构造函数？，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/28037242/