使用指针作为返回类型实现模板化接口的功能->冲突返回类型错误

Question

我目前正在学习 C++，并且遇到了以下问题：我有一个模板化接口 BaseTemplate，我想在子类中实现它而不使子类本身成为模板。示例代码如下：

template <typename T>
class BaseTemplate
{
    public:
        virtual const T get() const = 0;
};

class Child : public BaseTemplate<int*>
{
    public:
        Child(int value) : myInt{value} {};
        virtual const int* get() const override { return &myInt; };

    private:
        int myInt{0};
};

int main()
{
    Child myChild = Child(10);
    std::cout << myChild.get() << "\n";
    return 0;
}

GCC 产生以下错误：

main.cpp|16|error: conflicting return type specified for ‘virtual const int* Child::get() const’
main.cpp|9|note: overridden function is ‘const T BaseTemplate<T>::get() const [with T = int*]’

我清楚地了解该错误与 virtual const int* get() const override { return &myInt; }; 但我不明白有什么问题。如果我将返回类型（当然在两个类中）更改为int，我。 e.返回一个值而不是指针，它工作正常。那么这里的指针有什么问题呢？

也许它有帮助：在我的实际代码中，我想返回一个指向自定义接口而不是 int 的指针，我相信那里的错误是相关的

file_trees.h|19|error: invalid covariant return type for ‘virtual const IDirectoryNode* FileTree::DepthFirstIterator::getCurrent() const’
iterator_interface.h|10|note: overridden function is ‘const T IIterator<T>::getCurrent() const [with T = IDirectoryNode*]’

Answer 1

这必须归功于const 如何应用于类型。

const T 表示返回值是常量（当然几乎没用）。对于指针，这意味着指针本身是常量，而不是它的目标。

另一方面，const int* 是指向 const int 值的非常量指针。

对于Base<int*>，T=int* 产生int* const，而不是const* int，所以你必须定义int* const get() 虚方法。

对于T=const int*，它将是const int* const。详情请见this question。

Answer 2

当你有一个

int *

这种类型的常量版本不是const int *。它是int * const，或指向int 的常量指针。 const int * 是指向常量int 的指针，这是一个完全不同的类型。

但是，修复返回类型是不够的，因为get() 是const 类方法。将指针指向它的数据指针会生成 const int *，而不是 int *。

这里最简单的解决办法可能是让这个类成员可变：

class Child : public BaseTemplate<int*>
{
    public:
        Child(int value) : myInt{value} {};
        virtual int *const get() const override { return &myInt; };

    private:
        mutable int myInt{0};
};

无需从根本上重新设计整个类层次结构，这是使其编译的最小修复。您应该完全理解成为班级成员mutable 的含义，并理解所有含义。

Answer 3

int* 的const 版本是int* const，它是一个指向整数类型的常量指针，而不是指向const int 的指针。

您的意图可以通过以下方式实现。

template<class T>
struct const_type_handler
{
    using type=const T;
};

template<class T>
struct const_type_handler<T*>
{
    using type=const T*;
};


template <typename T>
class BaseTemplate
{
    public:
        virtual typename const_type_handler<T>::type get() const = 0;
};

class Child : public BaseTemplate<int*>
{
    public:
        Child(int value) : myInt{value} {};
        virtual typename const_type_handler<int*>::type get() const override { return &myInt; };

    private:
        int myInt{0};
};

我知道这会让代码有点乱，但它确实有效！