バーチャル機能なしで機能を切り替えるより良い方法はありますか？

Question

私はC++を学んでいます。私は基底クラスBaseとその派生クラスDerivedを持っています。そして彼らはpush_backをstd::vector<Base*> vecに入れています。 vec[0] == &Baseとvec[1] == &Derivedと仮定すると、仮想機能なしでvec[0]とvec[1]の機能を切り替えることができます。コードはこの質問の終わりです。仮想関数なしでそれを行うより良い方法はありますか？純粋なデータクラスが必要なので、非メンバ関数を追加してデータクラスのコードを変更しないようにしたい。どうもありがとうございました。あなたはそれが「基本」を必要とし、適切として「TYPE_」、または「int型（無効）」の代わり残念ながら、これはおそらく、あなたの質問に答えていない

void SwitchFunction(Base* ptr) 
{ 
    auto&& type = typeid(*ptr); 
    if (type == typeid(Base)) 
     Function(dynamic_cast<Base*>(ptr)); 
    else if (type == typeid(Derived)) 
     Function(dynamic_cast<Derived*>(ptr)); 
    else std::cout << "invalid type(=" << type.name() << ")" << std::endl; 
} 

「の型ID」を使用する必要はありません

class TypeInterface { 
public: 
    virtual int type(void) = 0; 
    virtual ~TypeInterface() {} 
}; 

class Base : public TypeInterface { 
public: 

    static constexpr int type_ = 1; 
    virtual int type(void) { 
     return type_; 
    } 

    virtual ~Base() {} 
}; 

class Derived : public Base { 
public: 

    static constexpr int type_ = 10; 
    virtual int type(void) { 
     return type_; 
    } 

    virtual ~Derived() {}; 
}; 

void Function(Base* ptr) { 
    std::cout << "function for Base" << std::endl; 
} 

void Function(Derived* ptr) { 
    std::cout << "function for Derived" << std::endl; 
} 

void SwitchFunction(int type, void* ptr) { 
    switch (type) { 
    case 1: { 
     Base* original_type_ptr = static_cast<Base*>(ptr); 
     Function(original_type_ptr); 
     break; 
    } 
    case 10: { 
     Derived* original_type_ptr = static_cast<Derived*>(ptr); 
     Function(original_type_ptr); 
     break; 
    } 
    default: 
     std::cout << "invalid type(=" << type << ")" << std::endl; 
    } 
} 

void test_function_selecter(void) { 

    Base b; 
    Derived d; 

    std::vector<Base*> vec; 

    vec.push_back(&b); 
    vec.push_back(&d); 

    for (auto e: vec) { 
     SwitchFunction(e->type(), e); 
    } 

} 

Answer 1

仮想関数（デストラクタなど）。