C++ 基于继承的类型参数更改父虚函数的行为

我有一个继承层次结构，有一个基类和两个派生类

在基类中，我有一个虚拟函数：

virtual void interact(const Base &other) const;

在派生类中，它们都具有以下两个功能，这是必需的，因为两个派生类之间的交互不同（即

Derived1

和

Derived1

的交互不同于

Derived1

和

Derived2

）：

我希望能够从

向量

中获取两个对象，并调用虚拟

基

类方法（例如

base1.interact（base2）

），并在派生类中根据派生类型调用正确的函数

有没有办法做到这一点，或者我的方法完全错了

有没有办法做到这一点，或者我的方法完全错了

您正在寻找的技术称为双重分派。
这并非完全错误。例如，模式访问者构建在同一概念之上

下面是一个基于您问题中的详细信息的最小工作示例：

#include<iostream>

struct Derived1;
struct Derived2;

struct Base {
    virtual void interact(const Base &) const = 0;
    virtual void interact(const Derived1 &) const = 0;
    virtual void interact(const Derived2 &) const = 0;
};

struct Derived1: Base {
    void interact(const Base &other) const override {
        other.interact(*this);
    }

    void interact(const Derived1 &) const {
        std::cout << "Derived1/Derived1" << std::endl;
    }

    void interact(const Derived2 &) const {
        std::cout << "Derived2/Derived1" << std::endl;
    }
};

struct Derived2: Base {
    void interact(const Base &other) const override {
        other.interact(*this);
    }

    void interact(const Derived1 &) const {
        std::cout << "Derived1/Derived2" << std::endl;
    }

    void interact(const Derived2 &) const {
        std::cout << "Derived2/Derived2" << std::endl;
    }
};

void foo(const Base &lhs, const Base &rhs) {
    lhs.interact(rhs);
}

int main() {
    foo(Derived1{}, Derived1{});
    foo(Derived1{}, Derived2{});
    foo(Derived2{}, Derived1{});
    foo(Derived2{}, Derived2{});
}

#包括
结构衍生1；
结构衍生2；
结构基{
虚空交互（常数基和）常数=0；
虚拟虚空交互（const Derived1&）const=0；
虚拟虚空交互（const Derived2&）const=0；
};
结构Derived1:Base{
无效交互（常数基和其他）常数覆盖{
其他。互动（*本）；
}
无效交互（常量派生1&）常量{
std：：cout该技术称为“双重分派”，有多种实现方式。同一向量中的两个对象显然属于同一类型（向量的定义）。要“能够从一个向量中获取两个对象”很容易，但它们都属于同一类型。这似乎不是你的计划。我建议不要向下投射。
#include<iostream>

struct Derived1;
struct Derived2;

struct Base {
    virtual void interact(const Base &) const = 0;
    virtual void interact(const Derived1 &) const = 0;
    virtual void interact(const Derived2 &) const = 0;
};

struct Derived1: Base {
    void interact(const Base &other) const override {
        other.interact(*this);
    }

    void interact(const Derived1 &) const {
        std::cout << "Derived1/Derived1" << std::endl;
    }

    void interact(const Derived2 &) const {
        std::cout << "Derived2/Derived1" << std::endl;
    }
};

struct Derived2: Base {
    void interact(const Base &other) const override {
        other.interact(*this);
    }

    void interact(const Derived1 &) const {
        std::cout << "Derived1/Derived2" << std::endl;
    }

    void interact(const Derived2 &) const {
        std::cout << "Derived2/Derived2" << std::endl;
    }
};

void foo(const Base &lhs, const Base &rhs) {
    lhs.interact(rhs);
}

int main() {
    foo(Derived1{}, Derived1{});
    foo(Derived1{}, Derived2{});
    foo(Derived2{}, Derived1{});
    foo(Derived2{}, Derived2{});
}