C ++ 17의 변형에 포함 된 유형에 대한 무의미한 메서드를 처리하는 방법

특정 컨테이너 클래스가 사용자 지정 클래스의 변형을 보유해야하는 경우를 다루고 있습니다 (특히 벡터에서 그러한 인스턴스를 수집하기 위해). 차례로 이것들은 서로 상호 연관되어 있습니다. 코드 예제에서이 변형의 유형은 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_;
};

이제 (펭귄과 다른 새들을 무시하고) , 새들은 보통 잠수 할 수없고, 물고기는 날개 가 없습니다 (적어도 들어 본 적 없음) . 그러나 코드를 요청할 가능성을 제공한다 wing_span_인스턴스로 a의 AnimalContainer사용 클래스 a.WingSpan(),이 동물은이어야 Bird뿐만 아니라 depth_of_dive_사용하는 것은 a.DepthOfDive(), 그것이되어야 Fish. 또한, 각 Bird과 Fish하는 (생리 학적 비현실적인) 무게 즉, 추정 할 수 a.EstimatedWeight()호출 할 수 있습니다.

기본적으로 컴파일러 오류를 피하기 위해 메서드 WingSpan()가 Fish 클래스에 DepthOfDive()추가되고 Bird 클래스에 추가됩니다.

이러한 더미 메서드 추가는 특히 두 개 이상의 변형 (여기 Fish및 Bird)이 관련되거나 이러한 클래스에 많은 메서드가 포함 된 경우 매우 번거로울 수 있습니다 .

한 가지 가능성은 특정 클래스에 대해 방문자를 오버로드하고 다른 모든 경우 (다시 일반 람다 사용)에서 경고를 반환하는 것처럼 보이지만 이로 인해 프로세스가 약간 향상되지만 매우 번거 롭습니다 (아래 두 번째 코드 예제 참조). .

복사 및 붙여 넣기가 덜 필요한보다 포괄적 인 방법으로이를 처리하는 방법에 대한 제안이 있습니까? 이 개념에 일반적인 문제가있는 경우 조언도 환영합니다.

그건 그렇고, 동물 컨테이너 클래스는 나중에 더미 함수의 의도하지 않은 호출을 피하기 위해 사용자를 안내하는 다른 클래스에 배치됩니다.

첫 번째 작업 코드 예제

#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;
}