#include #include #include #include #include class BaseIngredient { protected: const double price; public: BaseIngredient( const double _price ) : price{ _price } {} virtual std::string toStr() const = 0; virtual double getPrice() const { return this->price; } }; struct BaseCone : public BaseIngredient { BaseCone( const double _price ) : BaseIngredient{ _price } {} }; struct Cone : public BaseCone { Cone() : BaseCone{ 0.1 } {} }; struct CakeCone : public Cone { std::string toStr() const override { return "cake cone"; } }; struct SugarCone : public Cone { std::string toStr() const override { return "sugar cone"; } }; struct WaffleCone : public Cone { std::string toStr() const override { return "waffle cone"; } }; class DippedCone : public BaseCone { private: BaseCone& cone; std::string dip; protected: DippedCone( BaseCone& _cone, const std::string& _dip ) : BaseCone{ 0.2 }, cone{ _cone }, dip{ _dip } {} public: std::string toStr() const override { return ( this->cone.toStr() + " dipped into " + this->dip ); } double getPrice() const override { return ( this->cone.getPrice() + this->price ); } }; struct ChocolateDippedCone : public DippedCone { ChocolateDippedCone( BaseCone& _cone ) : DippedCone{ _cone, "chocolate sauce" } {} }; struct SprinkleDippedCone : public DippedCone { SprinkleDippedCone( BaseCone& _cone ) : DippedCone{ _cone, "mixed sprinkles" } {} }; struct BaseScoop : public BaseIngredient { BaseScoop( const double _price ) : BaseIngredient{ _price } {} }; struct Scoop : public BaseScoop { Scoop() : BaseScoop{ 0.9 } {} }; struct VanillaScoop : public Scoop { std::string toStr() const override { return "vanilla-flavoured scoop"; } }; struct ChocolateScoop : public Scoop { std::string toStr() const override { return "chocolate-flavoured scoop"; } }; struct StrawberryScoop : public Scoop { std::string toStr() const override { return "strawberry-flavoured scoop"; } }; struct AppleScoop : public Scoop { std::string toStr() const override { return "apple-flavoured scoop"; } }; struct CookieScoop : public Scoop { std::string toStr() const override { return "cookie-flavoured scoop"; } }; struct MangoScoop : public Scoop { std::string toStr() const override { return "mango-flavoured scoop"; } }; struct LemonScoop : public Scoop { std::string toStr() const override { return "lemon-flavoured scoop"; } }; struct RaspberryScoop : public Scoop { std::string toStr() const override { return "raspberry-flavoured scoop"; } }; class SizedScoop : public BaseScoop { protected: BaseScoop& scoop; std::string size; SizedScoop( BaseScoop& _scoop, const std::string& _size, const double& _price ) : BaseScoop{ _price }, scoop{ _scoop }, size{ _size } {} public: std::string toStr() const override { return ( this->size + ' ' + this->scoop.toStr() ); } double getPrice() const override { return ( this->scoop.getPrice() + this->price ); } }; struct SmallScoop : public SizedScoop { SmallScoop( BaseScoop& scoop ) : SizedScoop{ scoop, "small", -0.2 } {} }; struct BigScoop : public SizedScoop { BigScoop( BaseScoop& scoop ) : SizedScoop{ scoop, "big", 0.2 } {} }; struct HugeScoop : public SizedScoop { HugeScoop( BaseScoop& scoop ) : SizedScoop{ scoop, "huge", 0.4 } {} }; class Icecream { private: BaseCone* cone; std::vector< BaseScoop* > scoops; protected: Icecream() = default; public: Icecream( BaseCone* const _cone, std::initializer_list< BaseScoop* > _list ) : cone{ _cone }, scoops{ _list.begin(), _list.end() } {} virtual std::string toStr() const { std::string description{ "Your icecream consists of a " + this->cone->toStr() + " filled with:\n" }; for ( BaseScoop* const _scoop : this->scoops ) { description += ( "- A " + _scoop->toStr() + "\n" ); } return description; } virtual double getPrice() const { double price{ this->cone->getPrice() }; for ( BaseScoop* const _scoop : this->scoops ) { price += _scoop->getPrice(); } return price; } }; std::ostream& operator << ( std::ostream& os, const Icecream& icecream) { return ( os << icecream.toStr() ); } struct SprinkledIcecream : public Icecream { private: Icecream& icecream; std::string flavour; protected: SprinkledIcecream( Icecream& _icecream, const std::string& _flavour ) : icecream{ _icecream }, flavour{ _flavour } {} public: std::string toStr() const override { return ( this->icecream.toStr() + "It is topped by " + this->flavour + " sprinkles.\n" ); } double getPrice() const override { return ( this->icecream.getPrice() + 0.1 ); } }; struct ChocolateSprinkledIcecream : public SprinkledIcecream { ChocolateSprinkledIcecream( Icecream& icecream ) : SprinkledIcecream{ icecream, "chocolate" } {} }; struct CoconutSprinkledIcecream : public SprinkledIcecream { CoconutSprinkledIcecream( Icecream& icecream ) : SprinkledIcecream{ icecream, "coconut" } {} }; struct ColourfulSprinkledIcecream : public SprinkledIcecream { ColourfulSprinkledIcecream( Icecream& icecream ) : SprinkledIcecream{ icecream, "colourful" } {} }; struct CaramelSprinkledIcecream : public SprinkledIcecream { CaramelSprinkledIcecream( Icecream& icecream ) : SprinkledIcecream{ icecream, "salty caramel" } {} }; struct MarshmallowSprinkledIcecream : public SprinkledIcecream { MarshmallowSprinkledIcecream( Icecream& icecream ) : SprinkledIcecream{ icecream, "marshmallow" } {} }; struct SaucedIcecream : public Icecream { private: Icecream& icecream; std::string flavour; protected: SaucedIcecream( Icecream& _icecream, const std::string& _flavour ) : icecream{ _icecream }, flavour{ _flavour } {} public: std::string toStr() const override { return ( this->icecream.toStr() + "It is garnished with " + this->flavour + " sauce.\n" ); } double getPrice() const override { return ( this->icecream.getPrice() + 0.2 ); } }; struct ChocolateSaucedIcecream : public SaucedIcecream { ChocolateSaucedIcecream( Icecream& icecream ) : SaucedIcecream{ icecream, "chocolate" } {} }; struct RaspberrySaucedIcecream : public SaucedIcecream { RaspberrySaucedIcecream( Icecream& icecream ) : SaucedIcecream{ icecream, "raspberry" } {} }; struct CaramelSaucedIcecream : public SaucedIcecream { CaramelSaucedIcecream( Icecream& icecream ) : SaucedIcecream{ icecream, "caramel" } {} }; struct OreoSaucedIcecream : public SaucedIcecream { OreoSaucedIcecream( Icecream& icecream ) : SaucedIcecream{ icecream, "oreo" } {} }; int main( int argc, char** argv ) { WaffleCone waffle_cone; ChocolateDippedCone chocolate_cone( waffle_cone ); StrawberryScoop strawberry_scoop; HugeScoop huge_scoop( strawberry_scoop ); LemonScoop lemon_scoop; RaspberryScoop raspberry_scoop; SmallScoop small_scoop( raspberry_scoop ); Icecream icecream( &chocolate_cone, { &small_scoop, &lemon_scoop, &huge_scoop } ); ColourfulSprinkledIcecream sprinkled_icecream( icecream ); std::cout << sprinkled_icecream << std::endl; std::cout << "That makes " << std::fixed << std::setprecision( 2 ) << sprinkled_icecream.getPrice() << " $ please.\nEnjoy!" << std::endl; std::cout << "\nOh wait, I'd like to have a sauce as well! Hmm, let's see... oreo sounds great!\n"; OreoSaucedIcecream sauced_icecream{ sprinkled_icecream }; std::cout << "\nComing right up!\n" << sauced_icecream << std::endl; std::cout << "That's a total of " << sauced_icecream.getPrice() << "$ now. Thank you very much!" << std::endl; return EXIT_SUCCESS; }

Ice Cream Machine