C ++中具有多个参数类型的虚拟方法

Question

Lets say I have a base class A that I want to have a method getName that can take in either an integer or a string as the argument. So I create:

virtual string getName(int index) = 0;
virtual string getName(string key) = 0;

Now, I want to create two different subclasses B and C. B only needs the getName(int index) and C only needs the getName(string key) . However, if I dont overwrite both methods in both subclasses, I get an error. But if I do this, then B and C will have an empty methods because they dont need the other case of getName

How can I overcome this problem?

Answer 1

It sounds like you actually want two different interfaces: one that supports getName(int) and one that supports getName(string) .

struct GetNameInt {
    virtual string getName(int index) = 0;
};

struct GetNameStr {
    virtual string getName(string key) = 0;
};

struct B : GetNameInt { /* ... */ };
struct C : GetNameStr { /* ... */ };

---

If you really need a single base class with the same interface, and you only know at run-time whether you'll need a string or an int , you might want to use std::variant :

struct GetName {
    virtual string getName(std::variant<int, string>) = 0;
};

Answer 2

You're not using inheritance properly. I strongly recommend reading more about the SOLID principles .

You need to split the class A into two classes (interfaces) - Aa and Ab, where Aa would hold getName(int index) and would have getName(string key), like:

class A {
//does not define neither of the getName methods
}

class Aa {
    virtual string getName(int index) = 0;
}

class Ab {
    virtual string getName(string key) = 0;
}

class B : A, Aa {
    //inherits from A and defines string getName(int index)
}

class C : A, Ab {
    //inherits from A and defines string getName(string key)
}

Answer 3

Ok, the best I can come up with to keep a common parent between B and C while still preserving some type safety and compile time check:

struct CommonA //protect this if possible
{
    template<class type>
    string getGenericName(type index);
    virtual ~CommonA() {}
};

template<class indexType>
struct A : CommonA
{
    virtual string getName(indexType index) = 0;
};

struct B : A<int>
{
    string getName(int index) override {cout << index << "\n"; }
};
struct C : A<string>
{
    string getName(string index) override {cout << index << "\n"; }
};

template<class type>
string CommonA::getGenericName(type index)
{
    cout << "generic call: \n"; 
    return dynamic_cast<A<type>*>(this)->getName(index);
}

int main()
{
  CommonA b = B();
  CommonA c = C();
  b.getGenericName(1);
  c.getGenericName(string("hello world"));
}

Note that this solution is not a standard OOP solution but a template solution.

Edit: my templated A<> class is the same as Vittorio Romeo's solution using template instead of name pasting (name pasting is evil)

Answer 4

By simply don't making them pure virtual, but just virtual:

struct Blub
{
    virtual void do1() {} // default definition
    virtual void do2() = 0; //has to be overridden
};