C++：可以在编译时检测到虚拟继承吗？

Question

我想在编译时确定是否可以在没有 dynamic_cast 的情况下从指向 Base 的指针转换指向 Derived 的指针。这可能使用模板和元编程吗？这与确定 Base 是否是 Derived 的虚拟基类并不完全相同，因为 Base 可能是 Derived 的虚拟基类的超类。

谢谢， 蒂姆 更新： 我对这种方法感觉很好：

#include <iostream>

using namespace std;

class Foo
{
};

class Bar : public Foo
{
};

class Baz : public virtual Foo
{
};

class Autre : public virtual Bar
{
};

typedef char Small;
class Big { char dummy[2]; };

template<typename B, typename D>
struct is_static_castable
{
    const B* foo;
    char bar[1];
    static Small test(char(*)[sizeof(static_cast<const D*>(foo)) == sizeof(const D*)]);
    static Big test(...);
    enum { value = (sizeof(test(&bar)) == sizeof(Small)) };
};

int main()
{

    cout << "Foo -> Bar: " << is_static_castable<Foo, Bar>::value << "\n";
    cout << "Foo -> Baz: " << is_static_castable<Foo, Baz>::value << "\n";
    cout << "Foo -> Autre: " << is_static_castable<Foo, Autre>::value << "\n";
}

但它不适用于 gcc：

multi-fun.cpp: In instantiation of ‘is_static_castable<Foo, Baz>’:
multi-fun.cpp:38:   instantiated from here
multi-fun.cpp:29: error: cannot convert from base ‘Foo’ to derived type ‘Baz’ via virtual base ‘Foo’
multi-fun.cpp:29: error: array bound is not an integer constant
multi-fun.cpp: In instantiation of ‘is_static_castable<Foo, Autre>’:
multi-fun.cpp:39:   instantiated from here
multi-fun.cpp:29: error: cannot convert from base ‘Foo’ to derived type ‘Autre’ via virtual base ‘Bar’
multi-fun.cpp:29: error: array bound is not an integer constant

我是否对 sizeof() 技巧可以做什么感到困惑？

Answer 1

我曾经遇到过同样的问题。不幸的是，我不太确定虚拟问题。但是：Boost 有一个名为is_base_of 的类（参见here），它可以让你做某事。像下面这样

BOOST_STATIC_ASSERT((boost::is_base_of<Foo, Bar>::value));

此外，Boost 的type_traits 中有一个类is_virtual_base_of，也许这就是你要找的。​​p>

Answer 2

这里有一个解决方案，可以根据类是否是另一个类的子类来重定向编译器以执行某些操作。

class A 
{};

class B : virtual public A
{};

class C : public A
{};

// Default template which will resolve for 
// all classes
template 
< typename T
, typename Enable = void 
>
struct FooTraits
{
    static void foo(){
        std::cout << "normal" << std::endl;
    }
};

// Specialized template which will resolve
// for all sub classes of A
template 
< typename T 
>
struct FooTraits 
    < T
    , typename boost::enable_if
         < boost::is_virtual_base_of< A, T>
         >::type
    >
{
    static void foo(){
        std::cout << "virtual base of A" << std::endl;
    }
};

int main(int argc, const char * argv[] ){
    FooTraits<C>::foo(); // prints "normal"
    FooTraits<B>::foo(); // prints "virtual base of A"
}

如果你想知道 boost 是如何做到的。如果你有课 基类和类 Derived 那么以下成立。

struct X : Derived, virtual Base 
{
   X();
   X(const X&);
   X& operator=(const X&);
   ~X()throw();
};

struct Y : Derived 
{
   Y();
   Y(const Y&);
   Y& operator=(const Y&);
   ~Y()throw();
};

bool is_virtual_base_of = (sizeof(X)==sizeof(Y)));

这是使用多重继承的虚拟继承的技巧。多种的 从同一虚拟基地继承不会导致重复 虚拟基类，因此您可以使用 sizeof 对其进行测试。

Answer 3

首先，您的代码正在执行指针的 sizeof 而不是取消引用的指针，因此即使 gcc 没有抱怨它也不会工作。

其次，sizeof 技巧必须使用 0 的强制转换，而不是实际的指针或对象——这保证了零开销，并且在你做对之前它不会遵守。

3rd，你需要声明 2 个模板类或结构，一个仅从 D 派生，另一个从 D 和虚拟 B 派生，然后将 0 转换为它们的指针，取消引用它们，然后是 sizeof。

4th - 你有什么重要的理由来尝试使用 static_cast 而不是直接在这里进行政治正确吗？编译器将始终从中推断出您正在寻找更多抱怨，在这种情况下您肯定不是。

顺便说一句，您不需要从 Alexandrescu 获取完整代码 - 只需获取核心技术，基本上就是：

sizeof(*((T*)0))

Alexandrescu 非常擅长在戏法后清理。

哦，请记住，编译器不应该评估 sizeof args 或实例化未使用的模板类和结构 - 所以如果它这样做了，那么它就是一个编译器错误，如果你强迫它这样做，那么它就是你的错误 :-)

一旦你有了它，你需要准确地和积极地定义你的陈述“如果一个指向 Derived 的指针可以从一个指向 Base 的指针转换而不使用 dynamic_cast”实际上意味着在类关系方面 - 只是说“没有运算符/函数 Q" 不能很好地定义问题，你无法解决你无法定义的问题 - 老实说:-)

因此，只需迈出编译的第一个干净步骤，然后尝试定义您提到的两种情况在现实中的不同之处 - 一种具有或做什么而另一种不会。

Answer 4

你试过 Loki 的 SUPERSUBCLASS 吗？

http://loki-lib.sourceforge.net/

Answer 5

一旦转换为基指针，你只能得到一个运行时错误（dynamic_cast）。您可以使用模板参数定义方法并使用模板特化获得编译错误。

Answer 6

在编译时有一个模板破解。

首先你需要创建一个这样的接口类：

template <typename T>
class SomeInterface
{
public:
    inline int getSomething() const;
};

template<typename T>
inline int SomeInterface<T>::getSomething() const
{
    return static_cast<T const*>(this)->T::getSomething();
}

想法是：将this 转换为T 并从中调用具有相同名称和相同参数的方法。 如您所见，包装函数是内联的，因此在运行时不会产生性能或调用堆栈开销。

然后像这样创建实现接口的类：

class SomeClass : public SomeInterface<SomeClass>
{
    friend class SomeInterface<SomeClass>;

public:
    int getSomething() const;
};

然后正常添加派生方法的实现。

这种方式可能看起来不漂亮，但确实可以。

Answer 7

如果你想在编译时知道你可以把派生类作为参数 但是，如果您唯一拥有的是 Base，那么您将无法知道它是否引用了任何 foo、bar 等类。此检查只能在指针转换为 Base 时进行。我认为这就是 dynamic_cast

的全部目的

Answer 8

这可能有点天真（我在 C 中比在 C++ 中强得多）所以我可能不明白你在做什么，但如果它是你在谈论的投射指针，C 风格强制转换工作得很好（例如(D *)foo），或者 C++ 等效的 reinterpret_cast。话虽如此，这可能非常危险，因为您没有任何运行时检查，因此需要确保您正在转换为正确的类型。再说一次，如果你想有一种简单的方法来检查这是否是一个正确的假设，我们又回到了原点。但是，您似乎正在尝试比较上面的 pointers，它们都是相同的（它们基本上是整数）。据我所知，在 C++ 中没有办法在运行时确定对象的类，包括在编译时工作的 sizeof。基本上，没有办法做你想做的事情（至少不是标准 C++），但是实际的转换不会导致任何问题，只是以不正确的方式使用新的转换指针。如果你绝对需要这个功能，你最好在你的基类中包含一个虚函数来报告它是什么类（最好是一个枚举值），然后在你希望确定是否可以转换的任何子类中重载它.