如何处理 C++ 17 中变体中包含的类型的无意义方法

Question

我正在处理需要某个容器类来保存自定义类的变体（尤其是在向量中收集此类实例）的情况。这些又是相互关联的。在代码示例中，此变体中的类型为Bird 和Fish，容器类为AnimalContainer（完整的工作代码见下文）。

课程概览不完整：

using namespace std;
using uint = unsigned int;

class Animal {      
    protected:
        uint length_;
};

class Fish : public Animal {   
    private:
        uint depths_of_dive_;
};

class Bird : public Animal {   
    private:
        uint wing_span_;
};

class AnimalContainer {
    private:
        variant<Bird, Fish> the_animal_;
};

现在（忽略企鹅和其他一些鸟类），鸟类通常不会潜水，鱼没有翅膀（至少没听说过）。但是，代码应该提供通过AnimalContainer 类的实例a 使用a.WingSpan() 请求wing_span_ 的可能性，如果这个动物是Bird，以及使用@987654331 的depth_of_dive_ @，应该是Fish。此外，对于每个Bird 和Fish，可以估计一个（生理上不现实的）权重，即可以调用a.EstimatedWeight()。

基本上为了避免编译器错误，在Fish类中添加了一个方法WingSpan()，在Bird类中添加了DepthOfDive()。

添加这些虚拟方法可能会变得非常麻烦，尤其是当涉及两个以上的变体（此处为Fish 和Bird）时，或者当这些类包含许多方法时。

一种可能性似乎使特定类的访问者超载并在所有其他情况下返回一些警告（再次使用通用 lambda），但即使这稍微改进了过程，它也相当麻烦（参见第二个代码下面的例子）。

您对如何以更全面、需要更少复制和粘贴的方式处理此问题有什么建议吗？如果您对此概念有一般性问题，也欢迎提出建议。

顺便说一下，动物容器类后来被放置在另一个引导用户的类中，以避免意外调用虚拟函数。

第一个工作代码示例

#include <variant>
#include <iostream>

using namespace std;
using uint = unsigned int;


class Animal {
    public:
        Animal(uint length) : length_{length} {}

        uint Length() { return length_; }

    protected:
        uint length_;
};

class Fish : public Animal {
    public:
        Fish(uint length, uint depths_of_dive) : Animal(length), depths_of_dive_{depths_of_dive} {}

        uint DepthOfDive() { return depths_of_dive_; }
        uint EstimatedWeight() { return length_ * length_; }

        uint WingSpan() { cerr << "Usually fishes do not have wings... "; return 0; }

    private:
        uint depths_of_dive_;
};

class Bird : public Animal {
    public:
        Bird(uint length, uint wing_span) : Animal(length), wing_span_{wing_span} {}

        uint WingSpan() { return wing_span_; }
        uint EstimatedWeight() { return wing_span_ * length_; }

        uint DepthOfDive() { cerr << "Usually birds can not dive... "; return 0; }

    private:
        uint wing_span_;
};

class AnimalContainer {
    public:
        AnimalContainer(Bird b) : the_animal_{b} {}
        AnimalContainer(Fish f) : the_animal_{f} {}

        uint Length() {
            return visit([] (auto arg) { return arg.Length(); }, the_animal_);
        }
        uint WingSpan() {
            return visit([] (auto arg) { return arg.WingSpan(); }, the_animal_);
        }
        uint DepthOfDive() {
            return visit([] (auto arg) { return arg.DepthOfDive(); }, the_animal_);
        }
        uint EstimatedWeight() {
            return visit([] (auto arg) { return arg.EstimatedWeight(); }, the_animal_);
        }


    private:
        variant<Bird, Fish> the_animal_;
};

int main()
{
    Fish f(2,3);
    Bird b(2,3);

    AnimalContainer a_1(f);
    AnimalContainer a_2(b);

    cout << a_1.Length() << ' ' << a_1.WingSpan() << ' ' << a_1.DepthOfDive() << ' ' << a_1.EstimatedWeight() << endl; 
    cout << a_2.Length() << ' ' << a_2.WingSpan() << ' ' << a_2.DepthOfDive() << ' ' << a_2.EstimatedWeight() << endl;

    return 0;
}

第二个工作代码示例

#include <variant>
#include <iostream>

using namespace std;
using uint = unsigned int;


class Animal {
    public:
        Animal(uint length) : length_{length} {}

        uint Length() { return length_; }

    protected:
        uint length_;
};

class Fish : public Animal {
    public:
        Fish(uint length, uint depths_of_dive) : Animal(length), depths_of_dive_{depths_of_dive} {}

        uint DepthOfDive() { return depths_of_dive_; }
        uint EstimatedWeight() { return length_ * length_; }

        // no more dummy function

    private:
        uint depths_of_dive_;
};

class Bird : public Animal {
    public:
        Bird(uint length, uint wing_span) : Animal(length), wing_span_{wing_span} {}

        uint WingSpan() { return wing_span_; }
        uint EstimatedWeight() { return wing_span_ * length_; }

        // no more dummy function

    private:
        uint wing_span_;
};

template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;

class AnimalContainer {
    public:
        AnimalContainer(Bird b) : the_animal_{b} {}
        AnimalContainer(Fish f) : the_animal_{f} {}

        uint Length() {
            return visit([] (auto arg) { return arg.Length(); }, the_animal_);
        }
        uint WingSpan() {
            return visit(overloaded { // now overloaded version
                [] (auto) { cerr << "This animal does not have wings... "; return uint(0); },
                [] (Bird arg) { return arg.WingSpan(); }}, the_animal_);
        }
        uint DepthOfDive() {
            return visit(overloaded { // now overloaded version
                [] (auto) { cerr << "This animal can not dive... "; return uint(0); },
                [] (Fish arg) { return arg.DepthOfDive(); }}, the_animal_);
        }
        uint EstimatedWeight() {
            return visit([] (auto arg) { return arg.EstimatedWeight(); }, the_animal_);
        }

    private:
        variant<Bird, Fish> the_animal_;
};

int main()
{
    Fish f(2,3);
    Bird b(2,3);

    AnimalContainer a_1(f);
    AnimalContainer a_2(b);

    cout << a_1.Length() << ' ' << a_1.WingSpan() << ' ' << a_1.DepthOfDive() << ' ' << a_1.EstimatedWeight() << endl; 
    cout << a_2.Length() << ' ' << a_2.WingSpan() << ' ' << a_2.DepthOfDive() << ' ' << a_2.EstimatedWeight() << endl;

    return 0;
}

Answer 1

首先，让我说，我很高兴看到一个新的贡献者提出了一个关于设计的精心设计的问题。欢迎来到 StackOverflow！ :)

正如您正确提到的，您有两种选择：处理具体类或容器中不存在的行为。让我们考虑这两种选择。

具体类

这通常在继承和（动态）多态性的帮助下完成，这是经典的 OOP 方法。在这种情况下，您甚至不应该拥有variant，因为variant 用于不相关的类。当您已经有一个公共基类时，使用它没有多大意义。

相反，在基类中将您需要的整个接口定义为一组虚函数。一个好的做法是在层次结构的顶部有一个纯接口。然后你可以选择有一个提供一些默认实现的中间（可能是抽象的）类。这将使您不必为每个新衍生动物考虑不相关的概念，并避免一些代码重复。

代码可能如下所示（未经测试，仅向您展示概念）：

// Pure interface on top of the hierarchy
class IAnimal {
    public:
        virtual ~IAnimal() = default.

        virtual uint Length() const = 0;
        virtual uint DepthOfDive() const = 0;
        virtual uint EstimatedWeight() const = 0;
        virtual uint WingSpan() const = 0;
};

// Intermediate class with some common implementations 
class Animal : public IAnimal {
    public:
        Animal(uint length) : length_{length} {}

        // We know how to implement this on this level already, so mark this final
        // Otherwise it won't have much sense to have the length_ field
        uint Length() const final { return length_; }

        // Some of these should be overridden by the descendants
        uint DepthOfDive() const override { cerr << "This creature can not dive... "; return 0; }
        uint WingSpan() const override { cerr << "This creature does not have wings... "; return 0; }

    private:
        uint length_;  // Better make it private
};

class Fish : public Animal {
    public:
        Fish(uint length, uint depths_of_dive) : Animal(length), depths_of_dive_{depths_of_dive} {}

        uint DepthOfDive() const { return depths_of_dive_; }
        uint EstimatedWeight() const { return Length() * Length(); }

    private:
        uint depths_of_dive_;
};

class Bird : public Animal {
    public:
        Bird(uint length, uint wing_span) : Animal(length), wing_span_{wing_span} {}

        uint WingSpan() const { return wing_span_; }
        uint EstimatedWeight() const { return wing_span_ * Length(); }

    private:
        uint wing_span_;
};

using AnimalContainer = std::unique_ptr<IAnimal>;

现在，您可以直接使用指向基本接口的指​​针来代替统一容器。经典。

容器

当您没有基类时，拥有一个提供一些通用接口的统一容器可能是有意义的。否则，您最好退回到上面描述的经典 OOP。因此，在这种情况下，您最好完全摆脱 Animal 类，并以所有特定动物所需的方式定义您需要的内容。

至于实现，您的方法实际上非常好，使用花哨的overloaded 模式。我可以建议您考虑的唯一事情是使用单个通用 lambda 作为访问者，其中包含一堆 if constexpr，因为在某些情况下这可能更容易阅读。但这真的取决于你的方法并没有什么不好的。