C++ 基于继承关系的模板友谊

我不确定这是否可以实现。假设我有两个类模板

Foo

和

FooOwner

，并且

FooOwner

有一个指向

Foo

的指针成员，其中

U

是

T

的子类

我想让

FooOwner

成为

Foo

的朋友，但前提是

U

是

T

的子类。可能吗？如果没有，是否有足够接近的解决方法

template<typename T>
class FooOwner {
private:
    Foo<T>* p;  // This can point to a object of type Foo<U>
                // where U is a subclass of T
};

// NOTE: Foo<Derived> is always a subclass of Foo<Base>

template<typename T>
class Foo {
private:
    template<typename U>  // Constrain U to be a superclass of T?
    friend class FooOwner;
};

模板
类食品所有者{
私人：
Foo*p；//这可以指向Foo类型的对象
//其中U是T的一个子类
};
//注意：Foo始终是Foo的一个子类
模板
福班{
私人：
模板//约束U为T的超类？
朋友类食物拥有者；
};

我不确定您想要达到什么目标，但也许类型特征可以帮助您：

#include <type_traits>

class A {};

class B : A {};

class C {};

int main() 
{
    std::is_base_of<A, B>::value; // true
    std::is_base_of<C, B>::value; // false
}

#包括
A类{}；
B类：A{}；
C类{}；
int main（）
{
std：：是以下各项的基础：

std:：conditional由于
FooOwner
似乎不是Foo外部接口的一部分，您可以在
Foo
中声明它：

template<typename T>
class Foo {
private:
    template<typename U>  // Constrain U to be a superclass of T?
    friend class FooOwner;

    template< typename U>
    class FooOwner {
    public:
        FooOwner(std::enable_if<std::is_base_of<T, U>::value, U*> uptr) : p(uptr){} // (rough idea) 
    private:
        Foo<U>* p;  // This can point to a object of type Foo<U>
                    // where U is a subclass of T
    };    
};


如果您想将FooOwner保持在Foo的外部，您可以以类似的方式使其成为
U
和
T
的模板。
您的意思是FooOwner有两个类型参数吗？
template FooOwner
。\U堆栈否，它只知道
T
，并且依赖于
T
作为多态类型才能正常工作。它是这与我们如何将
std:：unique\U ptr
指向
派生的
类型的对象基本相同。你的描述和你的代码之间存在差异。根据描述
FooOwner
中
p
的类型应该是
Foo*
。但是，你从哪里获得
U
类型呢？@Leon我应该说“有一个
Foo
类型的指针，它实际上可以指向
Foo
类型的对象，其中
U
是
T
的一个子类。”一般来说，
Foo
指针不能合法地指向
Foo
对象，因为
Foo
和
Foo
之间没有继承关系（即使
U
是
T
的子类）。这只有在专门化
Foo
时才有可能。是这样吗？
std::enable_if<std::is_base_of<A, B>::value, A>::type
  // will be defined only if B is derived from A

template<typename T>
class Foo {
private:
    template<typename U>  // Constrain U to be a superclass of T?
    friend class FooOwner;

    template< typename U>
    class FooOwner {
    public:
        FooOwner(std::enable_if<std::is_base_of<T, U>::value, U*> uptr) : p(uptr){} // (rough idea) 
    private:
        Foo<U>* p;  // This can point to a object of type Foo<U>
                    // where U is a subclass of T
    };    
};

template<typename T>
class Foo {
private:
    template<typename U, typename = std::enable_if<std::is_base_of<T, U>::value>> 
    friend class FooOwner;

    template<typename U, typename = std::enable_if<std::is_base_of<T, U>::value>> 
    class FooOwner {
    private:
        Foo<U>* p;  // This can point to a object of type Foo<U>
                    // where U is a subclass of T
    };    
};

template<typename U, typename = T> 
class FooOwner {
   . . . 
};