Модел на най-добра практика на C++ за използване на полиморфен член от данни

В този случай е по-добре с отделни конструктори по подразбиране и копиране. Също така, не трябва да вземате адреса на нещо, предадено чрез препратка; може да е обект в стека, който скоро ще изчезне. В случай на вашата функция:

void SomeFunction() {
  Apple a;
  food1.SetFruit(a);
}

a (а следователно и &a) става невалиден, когато функцията се върне, така че food1 ще съдържа невалиден указател.

Тъй като съхранявате указател, трябва да очаквате Food да поеме собствеността върху предадения Fruit.

class Food {
  public:
    Food() : m_fruit(new Fruit()) {}
    Food(Fruit* f) : m_fruit(f) {}
    void SetFruit(Fruit* f) { if(m_fruit != f) { delete m_fruit; m_fruit = f; } }
    Fruit& GetFruit() { return *m_fruit; }
    const Fruit& GetFruit() const { return *m_fruit; }
    int Test() { return m_fruit->GetWeight(); }
  private:
    Fruit* m_fruit;
};

Другата опция е Foodда направи копие на Fruit, което се предава. Това е сложно. В старите времена щяхме да дефинираме метод Fruit::clone(), чиито подкласове ще заменят:

class Fruit {
  public:
    virtual int GetWeight() { return 0; }
    virtual Fruit* clone() const { return new Fruit(*this); }
};

class Apple : public Fruit {
  public:
    virtual int GetWeight() { return 2; }
    virtual Fruit* clone() const { return new Apple(*this); }
};

class Banana : public Fruit {
  public:
    virtual int GetWeight() { return 3; }
    virtual Fruit* clone() const { return new Banana(*this); }
};

Не мисля, че можете да направите виртуален конструктор по начина, по който трябва да го направите по-красив.

Тогава класът Food се променя на:

class Food {
  public:
    Food() : m_fruit(new Fruit()) {}
    Food(const Fruit& f) : m_fruit(f.clone()) {}
    void SetFruit(const Fruit& f) { delete m_fruit; m_fruit = f.clone(); }
    Fruit& GetFruit() { return *m_fruit; }
    const Fruit& GetFruit() const { return *m_fruit; }
    int Test() { return m_fruit->GetWeight(); }
  private:
    Fruit* m_fruit;
};

С тази настройка вашето SomeFunction ще работи, тъй като food1 вече не зависи от съществуването на a.

Няма чист и прост начин да го направите без оператор new, защото различните обекти може да заемат различно количество място в паметта. Така че храната не може да съдържа самия плод, а само указател към плода, който от своя страна трябва да бъде разпределен в купчината. Ето някои алтернативи.

Разгледайте библиотеката boost::any. Съществува именно за да разреши вашия проблем. Недостатъкът е, че той добавя много зависимости от Boost и макар че може да направи кода ви да изглежда прост, би бил по-труден за разбиране за всеки, който не е запознат с библиотеката. Отдолу, разбира се, все още прави ново/изтриване.

За да направите това ръчно, можете да накарате Food да приеме указател към Fruit и да поеме собствеността върху него, като извика delete в неговия деструктор ~Food() (или може да използва интелигентен указател като shared_ptr, scoped_ptr или auto_ptr, за да го изтрие автоматично). Трябва ясно да документирате, че предадената стойност ТРЯБВА да бъде разпределена с new. (Стойността по подразбиране ще представлява специално раздразнение; ще трябва или да я проверите, или да добавите флаг, или да разпределите копие на тази стойност също с operator new.)

Може да искате да можете да вземете всеки плод като аргумент и да го копирате в купчината. Това изисква повече работа, защото не знаете, когато правите копието, кой плод всъщност е. Един често срещан начин за решаването му включва добавяне на виртуален метод clone() към Fruit, който извлечените Fruits трябва да се прилагат по подходящ начин.

Вашият SetFruit() присвоява адреса на f на m_fruit, а не адреса на всичко, което е било предадено. Тъй като f е просто аргумент на функция, той съществува в стека само докато SetFruit() се върне. След това f изчезва и адресът му вече не е валиден. По този начин m_fruit сочи към нещо, което не съществува.

Затова вместо това направете нещо подобно:

class Food {
  public:
    Food(Fruit* f = &defaultFruit) : m_fruit(f) {}
    void SetFruit(Fruit* f) { m_fruit = f; }
    Fruit* GetFruit() { return m_fruit; }
    int Test() { return m_fruit->GetWeight(); }
  private:
    Fruit* m_fruit;
    static const Fruit m_defaultFruit;
};

Полиморфизмът изисква да правите всичко с указатели (или препратки като определени параметри, но това не се отнася за вашия случай).