Question

是否有在C ++中使用dynamic_cast的替代方法？

例如，在下面的代码中，我希望能够拥有Cat个对象。但只有Cat个对象而不是Dog个对象。我知道这反对从Mammal派生类，因为它不是非常多态，但我仍然想知道我是否可以在没有dynamic_cast的情况下执行此操作。

我的班级声明

class Mammal
{
       public: 
             virtual void Speak() const {cout << "Mammals yay!\n";}
};
class Cat: public Mammal
{
    public:
        void Speak() const{cout << "Meow\n";}
        void Purr() const {cout <"rrrrrrrr\n";}
};

class Dog: public Mammal
{
   public:
       void Speak() const{cout << "Woof!\n";}
};

在主要

int main()
{

    Mammal *pMammal;

    pMammal = new Cat;

    pMammal->Purr();     //How would I call this without having to use dynamic_cast?

    return 0;
}

Answer 1

如果您知道有一组固定的实现，则可以创建为您执行转换的virtual函数。这比dynamic_cast便宜。

所以：

struct Cat;
struct Mammal {
  virtual Cat* AsCat(){ return nullptr; }
};
struct Cat : Mammal {
  virtual Cat* AsCat() { return this; }
};

我在C ++ 11中用template tomfoolery做了这个，所以你甚至可以让它看起来像个演员。

#include <utility>
#include <iostream>

template<typename T>
struct fast_castable_leaf {
  virtual T* do_fast_cast(T* unused=nullptr) { return nullptr; }
  virtual T const* do_fast_cast(T* unused=nullptr) const { return nullptr; }
  virtual ~fast_castable_leaf() {}
};
template<typename Tuple>
struct fast_castable;
template<template<typename...>class Tuple>
struct fast_castable<Tuple<>> {
  virtual ~fast_castable() {}
};
template<template<typename...>class Tuple, typename T, typename... Ts>
struct fast_castable<Tuple<T,Ts...>>:
  fast_castable_leaf<T>,
  fast_castable<Tuple<Ts...>>
{};
template<typename T> struct block_deduction { typedef T type; };
template<typename T> using NoDeduction = typename block_deduction<T>::type;
template<typename T>
T* fast_cast( NoDeduction<fast_castable_leaf<T>>* src ) {
  return src->do_fast_cast();
}
template<typename T>
T const* fast_cast( NoDeduction<fast_castable_leaf<T>> const* src ) {
  return src->do_fast_cast();
}

template<typename T, typename D>
struct fast_cast_allowed : std::integral_constant<bool,
  std::is_base_of<T,D>::value || std::is_same<T,D>::value
> {};

template<typename D, typename B, typename Tuple>
struct implement_fast_cast;

template<typename D, typename B, template<typename...>class Tuple>
struct implement_fast_cast<D,B,Tuple<>> : B {};
template<typename D, typename B, template<typename...>class Tuple, typename T, typename... Ts>
struct implement_fast_cast<D,B,Tuple<T,Ts...>> : implement_fast_cast<D, B, Tuple<Ts...>> {
private:
  D* do_cast_work(std::true_type) { return static_cast<D*>(this); }
  D const* do_cast_work(std::true_type) const { return static_cast<D const*>(this); }
  std::nullptr_t do_cast_work(std::false_type) { return nullptr; }
  std::nullptr_t do_cast_work(std::false_type) const { return nullptr; }
public:
  T* do_fast_cast( T* unused = nullptr ) override { return do_cast_work( fast_cast_allowed<T,D>() ); }
  T const* do_fast_cast( T* unused = nullptr ) const override { return do_cast_work( fast_cast_allowed<T,D>() ); }
};

以上框架的一个例子：

struct Dog;
struct Cat;
struct Moose;
template<typename...>struct Types {};
typedef Types<Dog, Cat, Moose> Mammal_Types;

// A Mammal can be fast-casted to any of the Mammal_Types:
struct Mammal : fast_castable<Mammal_Types>
{};

// Cat wants to implement any legal fast_casts it can for Mammal in the
// set of Mammal_Types.  You can save on overhead by doing Types<Cat> instead
// of Mammal_Types, but this is less error prone:
struct Cat : implement_fast_cast< Cat, Mammal, Mammal_Types >
{};

int main() {
  Cat c;
  Mammal* m=&c;
  // so m is a pointer to a cat, but looks like a mammal.  We use
  // fast cast in order to turn it back into a Cat:
  Cat* c2 = fast_cast<Cat>(m);
  // and we test that it fails when we try to turn it into a Dog:
  Dog* d2 = fast_cast<Dog>(m);
  // This prints out a pointer value for c2, and 0 for d2:
  std::cout << c2 << "," << d2 << "\n";
}

Live Example

可以将其清理为支持更标准的fast_cast<Cat*>而不是fast_cast<Cat>，以及fast_cast<Cat&>，然后通过将其设为私有来阻止对do_fast_cast的直接访问和fast_cast一个friend，并允许某些方法在您需要的情况下获得virtual继承。

但系统的核心在上面。您可以以单virtual次函数查找为代价进行强制转换，而无需自行维护大部分机器。

替代实施：

template<class...>struct types{using type=types;};

template<typename T>
struct fast_castable_leaf {
  virtual T* do_fast_cast(T* unused=nullptr) { return nullptr; }
  virtual T const* do_fast_cast(T* unused=nullptr) const { return nullptr; }
  virtual ~fast_castable_leaf() {}
};
template<class Tuple>
struct fast_castable;
template<>
struct fast_castable<types<>> {
  virtual ~fast_castable() {}
};
template<class T0, class...Ts>
struct fast_castable<types<T0, Ts...>>:
  fast_castable_leaf<T0>,
  fast_castable<types<Ts...>>
{};
template<class T> struct block_deduction { typedef T type; };
template<class T> using NoDeduction = typename block_deduction<T>::type;
template<class T>
T* fast_cast( NoDeduction<fast_castable_leaf<T>>* src ) {
  return src->do_fast_cast();
}
template<class T>
T const* fast_cast( NoDeduction<fast_castable_leaf<T>> const* src ) {
  return src->do_fast_cast();
}

template<class T, class D>
struct fast_cast_allowed : std::integral_constant<bool,
  std::is_base_of<T,D>::value || std::is_same<T,D>::value
> {};

template<class Self, class Base, class Types>
struct implement_fast_cast;

template<class Self, class Base>
struct implement_fast_cast<Self,Base,types<>> : Base {
private:
  template<class, class, class>
  friend struct implement_fast_cast;

  Self* do_cast_work(std::true_type) { return static_cast<Self*>(this); }
  Self const* do_cast_work(std::true_type) const { return static_cast<Self const*>(this); }
  std::nullptr_t do_cast_work(std::false_type) { return nullptr; }
  std::nullptr_t do_cast_work(std::false_type) const { return nullptr; }
};

template<class Self, class Base, class T0, class... Ts>
struct implement_fast_cast<Self,Base,types<T0,Ts...>> :
  implement_fast_cast<Self, Base, types<Ts...>>
{
public:
  T0* do_fast_cast( T0* unused = nullptr ) override { return this->do_cast_work( fast_cast_allowed<T0,Self>() ); }
  T0 const* do_fast_cast( T0* unused = nullptr ) const override { return this->do_cast_work( fast_cast_allowed<T0,Self>() ); }
};

struct Dog;
struct Cat;
struct Moose;
typedef types<Dog, Cat, Moose> Mammal_Types;

struct Mammal : fast_castable<Mammal_Types>
{};

struct Cat : implement_fast_cast< Cat, Mammal, Mammal_Types >
{};

int main() {
  Cat c;
  Mammal* m=&c;
  Cat* c2 = fast_cast<Cat>(m);
  Dog* d2 = fast_cast<Dog>(m);
  std::cout << c2 << "," << d2 << "\n";
}

某些编译器可能更容易吞下。 Live example

请注意，对于很长的类型列表，上面的内容变得难以处理（在编译时，可能在运行时），因为它依赖于线性继承。

二进制继承系统的编程会有点复杂，但可以解决这个问题。在其中，您将要继承的事物列表拆分为两个大小相等的列表并从两者中继承。实现快速转换必须通过虚拟中介从Base继承。

Answer 2

C ++不支持发送消息，例如Objective C或Smalltalk。要调用方法，您需要为支持该方法的对象提供静态类型句柄。您是否需要使用dynamic_cast<Cat*>(pointer)或者是否可以使用其他内容，例如，static_cast<Cat*>(pointer)是一个单独的问题。

由于dynamic_cast<...>()相对昂贵并且尝试潜在无限数量的不同类是不可行的，因此最好在基类中使用visit()方法，该方法是使用访问者调用的。但是，这些只是获取正确类型引用的技术。

Answer 3

您正在处理指向Mammal类型的指针，并且可能Mammal未定义Purr()。您绝对必须将其强制转换为指向Cat的指针才能访问Purr()。您可以使用C风格的强制转换或dynamic_cast执行此操作，后者通常在C ++中更合适。 dynamic_cast还具有以下优势：您可以使用它在运行时测试Mammal对象是否为Cat，以便您可以决定是否可以致电Purr()。

Answer 4

三种变体：

dynamic_cast，你应该已经知道了。
static_cast，它是编译时强制转换，即a）检查类型的兼容性b）计算基类和派生类之间的偏移并考虑到c）没有运行时检查。
< / LI>
reinterpret_cast，也是编译时强制转换，没有任何类型检查和没有偏移计算。请谨慎使用 - 此强制转换可能会导致很难调试错误。

有关这些演员表的完整参考和示例，请查找一些书籍和教程，例如：http://www.cplusplus.com/doc/tutorial/typecasting/

动态铸造的替代品

4 个答案: