如何通过主类类型的对象访问子类内的枚举？

Question

正如这个问题的标题中提到的，有没有语法可以做到这一点？

class Food : public Edible {
public:
    class Fruit : public FruitBase { //note: Fruit must be a class and a subclass of Food.
    public:    
        enum Type {                  //note: Type must be inside Fruit and must be a plain enum.(not enum class)
            APPLE,
            GRAPES,
            ORANGE,
        };
        //...
    };
    enum { CAKE, CHOCOLATE };
    //...
};

void func(){
    Food snack;
    //...
    auto typeA = snack.Fruit::APPLE;    //<---this is syntax error.
    auto typeG = snack.GRAPES;          //<---also syntax error. 
    auto typeO = Food::Fruit::ORANGE;   //<---this is OK, but not my target.

    auto typeC = snack.CAKE;           //<---this is OK.

    //...


}

我更喜欢typeG 的语法。我的第二个偏好是typeA。我目前在我的代码中使用typeO，但我需要从对象snack 而不是类Food 访问这些枚举常量。由于typeC 是可能的，我希望还有一种方法可以在子类中的枚举上执行此操作。

Answer 1

类似这样的：

class Food {
public:
    class Fruit {      
    public:                       
        enum  Type {                                
            APPLE,
            GRAPES,
            ORANGE,
        };
        Type type;
    };
    Fruit fruit;

    enum class Foodies{ CAKE, CHOCOLATE };
    Foodies foodies;
};

void func() {
    typedef Food::Fruit::Type FruitType;

    Food snack; 
    auto typeA = snack.fruit.type = FruitType::APPLE;
}

Answer 2

更新

您可以在Food 内创建Fruit 的实例，这样您就可以访问Food 内的Fruit 的成员。像这样：

class Food : public Edible 
{
public:
    class Fruit : public FruitBase 
    { 
    public:
        enum Type{ APPLE, GRAPES, ORANGE };
    };
    static Fruit fruit; // -> this is what I was talking about

    enum { CAKE, CHOCOLATE };
};


int main()
{
    Food food;
    auto apple = food.fruit.APPLE; // this is not so different of your 'typeG'
}

现在关于Fruit 需要是Food 的子类，但Fruit 已经是FruitBase 的子类，所以多重继承是另一个问题，也许this 可以帮助你。

旧

为什么不只使用这样的继承：

#include <iostream>

class Fruit 
{
public:
    enum Type { APPLE, GRAPES, ORANGE };
};

class Food : public Fruit
{
public:
    enum Foods { CAKE, CHOCOLATE };
};

int main()
{

    Food food;
    auto apple =  food.Type::APPLE;
}

如果你真的更喜欢typeG，你可以让enum Type类Fruit的范围 像这样：

#include <iostream>

class Fruit 
{
public:
    enum { APPLE, GRAPES, ORANGE };
};

class Food : public Fruit
{
public:
    enum Foods { CAKE, CHOCOLATE };
};

int main()
{

    Food food;
    auto apple = food.APPLE;
}