Question

我有一个程序，我有一个名为Flower的超级班和Rose，Lily，Jasmine的子类。

花保护成员有2个变量描述花的特征和具有getter函数的公共成员和一个纯虚函数（称为字符串getColor（））打印子类花的颜色。它还有一个公共成员函数，可以打印每个花的特征（void printFlower（string name））。

我正在尝试为Rose，Lily和Jasmine实现类，我不得不在类中使用public access修饰符。因此，类中的所有内容都必须是受保护的或私有的（甚至是构造函数）。我知道Rose，Lily和Jasmine公开继承了父类Flower。

在我的主要功能中，我有这个：

int main(){

Rose rose;
Flower * pointer = &rose;
rose.printFlower("red");

Lily lily;
pointer = &lily;
lily.printFlower("white"); // not sure what color lilies are

Jasmine jas;
pointer = &jas;
jas.printFlower("orange");
return 0;
}

我的任务是不在Rose，Lily和Jasmine类中使用公共访问修饰符，但如果我愿意，我可以公开继承Flower。那么，有没有办法使用私有构造函数（使用Flower作为朋友）或类似的东西来实现这一目标？

编辑：我意识到我提供的信息很少，所以我在这里编辑问题。以下是Flower超级班的宣言，我无法改变。

class Flower{
protected:
    bool isPopular;
    bool isThorny;

public:
    Flower(bool isPopular, bool isThorny){
        this->isPopular = isPopular;
        this->isThorny = isThorny;
    }

    bool getIsPopular(){
        return this->isPopular;
    }

    bool getIsThorny(){
        return this->isThorny;
    }
    virtual string getColor() = 0;

    void printFlower(string name){
        cout << "A " << name << " has '" << this->getColor() << "' color and is "
    << (this->getIsThorny()?"":"not ") << "thorny, and is " << (this->getIsPopular()?"":"not ")
    << "very popular." << endl;
    }
};

我的任务基本上是图片中的以下内容： Task for declaring derived-classes

任务将运行main并在从main调用时打印printFlower函数。我唯一的限制是我不能在Rose，Lily和Jasmine的类声明中使用公共访问修饰符，但我可以并且公开继承花。即。玫瑰级：公共花（）{} 我有没有办法让Rose，Lily和Jasmine成为私人或受保护的所有成员？

Answer 1

显然，你被引导到对工厂模式的某种看法。解决方案是在Flower中定义一个工厂函数，它将进行实例化。

我将展示如何做到这一点。为了说明为什么这可能有用，我将把工厂变成一个从运行时参数到编译时类型的简单转换器：

class Flower
{
public:
  virtual ~Flower() = default;

  static std::unique_ptr<Flower> create(const std::string &species)
  {
    std::unique_ptr<Flower> result;
    if (species == "rose")
    {
        result = std::make_unique<Rose>();
    }   
    else if (species == "lily")
    {
        result = std::make_unique<Lily>();
    }  
    else 
    {
        throw std::invalid_argument("No such flower");
    }
    return result;
  }
};

class Rose : public Flower
{
  friend Flower;
  Rose() = default;
};

class Lily : public Flower
{
  friend Flower;
  Lily() = default;
};


int main(int argc, char **argv)
{
  auto rose = Flower::create("rose");
  auto lily = Flower::create("lily");
  auto whatTheUserRequested = Flower::create(argv[1]);
}

Answer 2

使用像这样的工厂函数

class FlowerFactory
{
    Flower* getFlower(string flowerName)
    {
        if(flowerName == "Rose")
        {
            return new Rose();
        }
        if(flowerName == "Lily")
        {
            return new Lily();
        }
        if(flowerName == "Jasmine")
        {
            return new Jasmine();
        }
    }
}

//Base class
class Flower
{
};

class Jasmine : public Flower
{
    //other things here..

    friend FlowerFactory;
};

class Rose : public Flower
{
    //other things here..

    friend FlowerFactory;
};

class Lily : public Flower
{
    //other things here..

    friend FlowerFactory;
};

Answer 3

您的指示是不使用访问说明符，还是您的所有成员都不是私有的？如果是前者，则可以使用struct代替class来默认获取公共访问。例如：

struct Rose : Flower { Rose() : Flower(...) {} string getColor() const override { return "red"; } };

如何从C ++中的main函数访问类中的私有构造函数？

3 个答案: