没有虚函数的C ++动态调度

Question

我有一些遗留代码，而不是虚函数，使用kind字段进行动态调度。 它看起来像这样：

// Base struct shared by all subtypes
// Plain-old data; can't use virtual functions
struct POD
{
    int kind;

    int GetFoo();
    int GetBar();
    int GetBaz();
    int GetXyzzy();
};

enum Kind { Kind_Derived1, Kind_Derived2, Kind_Derived3 /* , ... */ };

struct Derived1: POD
{
    Derived1(): kind(Kind_Derived1) {}

    int GetFoo();
    int GetBar();
    int GetBaz();
    int GetXyzzy();

    // ... plus other type-specific data and function members ...
};

struct Derived2: POD
{
    Derived2(): kind(Kind_Derived2) {}

    int GetFoo();
    int GetBar();
    int GetBaz();
    int GetXyzzy();

    // ... plus other type-specific data and function members ...
};

struct Derived3: POD
{
    Derived3(): kind(Kind_Derived3) {}

    int GetFoo();
    int GetBar();
    int GetBaz();
    int GetXyzzy();

    // ... plus other type-specific data and function members ...
};

// ... and so on for other derived classes ...

然后POD类的函数成员实现如下：

int POD::GetFoo()
{
    // Call kind-specific function
    switch (kind)
    {
    case Kind_Derived1:
        {
        Derived1 *pDerived1 = static_cast<Derived1*>(this);
        return pDerived1->GetFoo();
        }
    case Kind_Derived2:
        {
        Derived2 *pDerived2 = static_cast<Derived2*>(this);
        return pDerived2->GetFoo();
        }
    case Kind_Derived3:
        {
        Derived3 *pDerived3 = static_cast<Derived3*>(this);
        return pDerived3->GetFoo();
        }

    // ... and so on for other derived classes ...

    default:
        throw UnknownKindException(kind, "GetFoo");
    }
}

POD::GetBar() ， POD::GetBaz() ， POD::GetXyzzy()和其他成员的实现方式类似。

这个例子很简单。 实际代码有大约12种不同的POD子类型，以及几十种方法。 POD新子类型和新方法经常被添加，因此每次我们这样做时，我们都必须更新所有这些switch语句。

处理此问题的典型方法是在POD类中声明函数成员virtual ，但我们不能这样做，因为对象驻留在共享内存中。 有很多代码依赖于这些结构是普通的数据，所以即使我能找到某种方式在共享内存对象中使用虚函数，我也不想这样做。

因此，我正在寻找关于清理它的最佳方法的建议，以便所有关于如何调用子类型方法的知识集中在一个地方，而不是分散在几十个函数中的几十个switch语句中。

对我来说，我可以创建某种适配器类来包装POD并使用模板来最小化冗余。 但在我开始这条道路之前，我想知道其他人是如何处理这个问题的。

Answer 1

您可以使用跳转表。 这是大多数虚拟调度在幕后的样子，你可以手动构建它。

template<typename T> int get_derived_foo(POD*ptr) {
    return static_cast<T>(ptr)->GetFoo();
}
int (*)(POD*) funcs[] = {
    get_derived_foo<Derived1>,
    get_derived_foo<Derived2>,
    get_derived_foo<Derived3>
};
int POD::GetFoo() {
    return funcs[kind](this);
}

举个简短​​的例子。

共享内存的限制究竟是什么？ 我意识到我在这里不够了解。 这是否意味着我不能使用指针，因为另一个进程中的某个人会尝试使用这些指针？

您可以使用字符串映射，其中每个进程都获取它自己的映射副本。 你必须将它传递给GetFoo（），以便它可以找到它。

struct POD {
    int GetFoo(std::map<int, std::function<int()>& ref) {
        return ref[kind]();
    }
};

编辑：当然，你不必在这里使用字符串，你可以使用int。 我只是用它作为例子。 我应该改回来。 事实上，这个解决方案非常灵活，但重要的是，制作特定于流程的数据的副本，例如函数指针或其他，然后传递它。

Answer 2

您可以尝试使用奇怪的重复模板模式 。 它有点复杂，但是当你不能使用纯虚函数时它会很有帮助。

Answer 3

这是一种使用虚方法实现跳转表的方法，不需要Pod类或派生类实际具有虚函数。

目标是简化在许多类中添加和删除方法。

要添加方法，需要使用清晰且通用的模式将其添加到Pod，需要将纯虚函数添加到PodInterface，并且必须使用清晰且通用的模式将转发函数添加到PodFunc。

派生类只需要一个文件静态初始化对象来设置，否则看起来就像他们已经做的那样。

// Pod header

#include <boost/shared_ptr.hpp>
enum Kind { Kind_Derived1, Kind_Derived2, Kind_Derived3 /* , ... */ };

struct Pod
{
    int kind;

    int GetFoo();
    int GetBar();
    int GetBaz();
};

struct PodInterface
{
    virtual ~PodInterface();

    virtual int GetFoo(Pod* p) const = 0;
    virtual int GetBar(Pod* p) const = 0;
    virtual int GetBaz(Pod* p) const = 0;

    static void
    do_init(
            boost::shared_ptr<PodInterface const> const& p,
            int kind);
};

template<class T> struct PodFuncs : public PodInterface
{
    struct Init
    {
        Init(int kind)
        {
            boost::shared_ptr<PodInterface> t(new PodFuncs);
            PodInterface::do_init(t, kind);
        }
    };

    ~PodFuncs() { }

    int GetFoo(Pod* p) const { return static_cast<T*>(p)->GetFoo(); }
    int GetBar(Pod* p) const { return static_cast<T*>(p)->GetBar(); }
    int GetBaz(Pod* p) const { return static_cast<T*>(p)->GetBaz(); }
};


//
// Pod Implementation
//

#include <map>

typedef std::map<int, boost::shared_ptr<PodInterface const> > FuncMap;

static FuncMap& get_funcmap()
{
    // Replace with other approach for static initialisation order as appropriate.
    static FuncMap s_funcmap;
    return s_funcmap;
}

//
// struct Pod methods
//

int Pod::GetFoo()
{
    return get_funcmap()[kind]->GetFoo(this);
}

//
// struct PodInterface methods, in same file as s_funcs
//

PodInterface::~PodInterface()
{
}

void
PodInterface::do_init(
        boost::shared_ptr<PodInterface const> const& p,
        int kind)
{
    // Could do checking for duplicates here.
    get_funcmap()[kind] = p;
}

//
// Derived1
//

struct Derived1 : Pod
{
    Derived1() { kind = Kind_Derived1; }

    int GetFoo();
    int GetBar();
    int GetBaz();

    // Whatever else.
};

//
// Derived1 implementation
//

static const PodFuncs<Derived1>::Init s_interface_init(Kind_Derived1);

int Derived1::GetFoo() { /* Implement */ }
int Derived1::GetBar() { /* Implement */ }
int Derived1::GetBaz() { /* Implement */ } 

Answer 4

这是我现在要走的模板 - 元编程路径。 这是我喜欢它：

• 添加对新类型的支持仅需要更新LAST_KIND并添加新的KindTraits 。
• 添加新功能有一个简单的模式。
• 如有必要，功能可以专门用于特定种类。
• 如果我搞砸了什么，我可以期待编译时错误和警告，而不是神秘的运行时错误行为。

有几个问题：

• POD的实现现在依赖于所有派生类的接口。 （在现有的实现中已经是这样，所以我并不担心，但它有点气味。）
• 我指望编译器足够聪明，可以生成大致相当于基于switch的代码的代码。
• 许多C ++程序员在看到这个问题时都会头脑发热。

这是代码：

// Declare first and last kinds
const int FIRST_KIND = Kind_Derived1;
const int LAST_KIND = Kind_Derived3;

// Provide a compile-time mapping from a kind code to a subtype
template <int KIND>
struct KindTraits
{
    typedef void Subtype;
};
template <> KindTraits<Kind_Derived1> { typedef Derived1 Subtype; };
template <> KindTraits<Kind_Derived2> { typedef Derived2 Subtype; };
template <> KindTraits<Kind_Derived3> { typedef Derived3 Subtype; };

// If kind matches, then do the appropriate typecast and return result;
// otherwise, try the next kind.
template <int KIND>
int GetFooForKind(POD *pod)
{
    if (pod->kind == KIND)
        return static_cast<KindTraits<KIND>::Subtype>(pod)->GetFoo();
    else
        return GetFooForKind<KIND + 1>();  // try the next kind
}

// Specialization for LAST_KIND+1 
template <> int GetFooForKind<LAST_KIND + 1>(POD *pod)
{
    // kind didn't match anything in FIRST_KIND..LAST_KIND
    throw UnknownKindException(kind, "GetFoo");
}

// Now POD's function members can be implemented like this:

int POD::GetFoo()
{
    return GetFooForKind<FIRST_KIND>(this);
}

Answer 5

扩展您最终得到的解决方案，以下解决了程序初始化时派生函数的映射：

#include <typeinfo>
#include <iostream>
#include <functional>
#include <vector>

enum Kind
{
    Kind_First,
    Kind_Derived1 = Kind_First,
    Kind_Derived2,
    Kind_Total
};

struct POD
{
    size_t kind;

    int GetFoo();
    int GetBar();
};

struct VTable
{
    std::function<int(POD*)> GetFoo;
    std::function<int(POD*)> GetBar;
};

template<int KIND>
struct KindTraits
{
    typedef POD KindType;
};

template<int KIND>
void InitRegistry(std::vector<VTable> &t)
{
    typedef typename KindTraits<KIND>::KindType KindType;

    size_t i = KIND;
    t[i].GetFoo = [](POD *p) -> int {
        return static_cast<KindType*>(p)->GetFoo();
    };
    t[i].GetBar = [](POD *p) -> int {
        return static_cast<KindType*>(p)->GetBar();
    };

    InitRegistry<KIND+1>(t);
}
template<>
void InitRegistry<Kind_Total>(std::vector<VTable> &t)
{
}

struct Registry
{
    std::vector<VTable> table;

    Registry()
    {
        table.resize(Kind_Total);
        InitRegistry<Kind_First>(table);
    }
};

Registry reg;

int POD::GetFoo() { return reg.table[kind].GetFoo(this); }
int POD::GetBar() { return reg.table[kind].GetBar(this); }

struct Derived1 : POD
{
    Derived1() { kind = Kind_Derived1; }

    int GetFoo() { return 0; }
    int GetBar() { return 1; }
};
template<> struct KindTraits<Kind_Derived1> { typedef Derived1 KindType; };

struct Derived2 : POD
{
    Derived2() { kind = Kind_Derived2; }

    int GetFoo() { return 2; }
    int GetBar() { return 3; }
};
template<> struct KindTraits<Kind_Derived2> { typedef Derived2 KindType; };

int main()
{
    Derived1 d1;
    Derived2 d2;
    POD *p;

    p = static_cast<POD*>(&d1);
    std::cout << p->GetFoo() << '\n';
    p = static_cast<POD*>(&d2);
    std::cout << p->GetBar() << '\n';
}

Answer 6

以下是使用奇怪重复模板模式的示例。 如果您在编译时了解更多信息，这可能适合您的需求。

template<class DerivedType>
struct POD
{
    int GetFoo()
    {
        return static_cast<DerivedType*>(this)->GetFoo();
    }
    int GetBar()
    {
        return static_cast<DerivedType*>(this).GetBar();
    }
    int GetBaz()
    {
        return static_cast<DerivedType*>(this).GetBaz();
    }
    int GetXyzzy()
    {
        return static_cast<DerivedType*>(this).GetXyzzy();
    }
};

struct Derived1 : public POD<Derived1>
{
    int GetFoo()
    {
        return 1;
    }
    //define all implementations
};

struct Derived2 : public POD<Derived2>
{
    //define all implementations

};

int main()
{
    Derived1 d1;
    cout << d1.GetFoo() << endl;
    POD<Derived1> *p = new Derived1;
    cout << p->GetFoo() << endl;
    return 0;
}