Function 返回<error-type>而不是在 C++ 中指向模板 class 的预期原始指针</error-type>

Question

I am having trouble using the first_ variable in my template class (shown below).

template<typename T> class enable_movable_ptr {
public:
    //default constructor
    enable_movable_ptr() : ptr_(nullptr) {};
    enable_movable_ptr(T* p) : ptr_(p) {};

    //...
    //other constructors and operators
    //...

    T* get() {return ptr_; };
    movable_ptr<T>* First() { return first_; };
private:
    T* ptr_;
    movable_ptr<T>* first_ = nullptr;
};

template<typename T> class movable_ptr {
public:
    //Parameterless constructor
    movable_ptr() : trg_(nullptr) {};

    //Constructor from T*
    movable_ptr(T* p) : trg_(p) { add_to_tracked(this); };

    //...
    //other constructors and operators
    //...

    //access to variables
    enable_movable_ptr<T>* get() {return trg_; };
    movable_ptr<T>* Next(enable_movable_ptr<T>& p) {return next_; };
    movable_ptr<T>* Previous(enable_movable_ptr<T>& p) {return prev_; };

    //get_movable
    movable_ptr<T>* get_movable(enable_movable_ptr<T>& p) {};
private:
    enable_movable_ptr<T>* trg_;
    movable_ptr<T>* next_ = nullptr;
    movable_ptr<T>* prev_ = nullptr;
};

template<typename T> movable_ptr<T> get_movable(enable_movable_ptr<T>& p){
    if (p.First() != nullptr)
    {}
};

The problem is, the returned first_ is of the <error-type> type (that's what it shows if I mouse over any first_ or First() in the code, except for the declaration in VS2019), instead of the expected movable_ptr<T>* . However, if I mouse over the declaration of first_ , it shows the correct movable_ptr<T>* type.

From my point of view it seems as if the compiler has the memory of a goldfish, and forgets what the type is even while still within the same class definition. That is most likely not the case, and I suspect there is something I might have done wrong which causes this.

Any ideas on where I went wrong, or how to solve the problem?

Answer 1

Just forward declare movable_ptr before defining enable_movable_ptr .

template<typename T> class movable_ptr;

Otherwise, the compiler doesn't know that movable_ptr is even a thing that might exist.

Also, it's better to not rely on external tooling, such as your IDE, to tell you what is wrong with the code. Let the compiler do that; it very likely knows much more about your code.

Here's where the issue actually comes from (I've removed all the code that is irrelevant to your particular issue)

// you need to forward declare
template <typename T> struct movable_ptr;

template <typename T> struct enable_movable_ptr {
  movable_ptr<T>* first_ = nullptr;  // else compiler won't know what movable_ptr is
};

template <typename T> struct movable_ptr {  
  enable_movable_ptr<T>* trg_;
};

Here's a link to the mcve .