Decorator Design Pattern in c++ I wrote a version of decorator pattern in c++ as I wasn't able to find any good source of decorator pattern implementation in C++. I want to know if I implemented it correctly. Here is the code-

//implementing the pizza example in c++

#include "bits/stdc++.h"
using namespace std;

class Pizza{
protected:
    string description = "";
    int cost = 0;
public:
    string getdescription(){
        return description;
    }
    int getcost(){
        return cost;
    }
};
//pizzas
class PeppyPaneer: public Pizza{
public:
    PeppyPaneer(){
        cost = 100;
        description = description + " PeppyPaneer";
    }
};
class Magharita: public Pizza{
public:
    Magharita(){
        cost = 200;
        description = description + " Magharita";
    }
};

//toppings
class Barbeque: public Pizza{
public:
    Barbeque(Pizza *pizza){
        cost = pizza-&gt;getcost() + 50;
        description = pizza-&gt;getdescription()+ " Barbeque";
    }
};

class Paneer: public Pizza{
public:
    Paneer(Pizza *pizza){
        cost = pizza-&gt;getcost() + 60;
        description = pizza-&gt;getdescription() + " Paneer";
    }
};


int main(){

    Pizza *pizza = new PeppyPaneer();
    cout &lt;&lt; pizza-&gt;getcost() &lt;&lt; " " &lt;&lt; pizza-&gt;getdescription() &lt;&lt; "\n";

    pizza = new Barbeque(pizza);
    cout &lt;&lt; pizza-&gt;getcost() &lt;&lt; " " &lt;&lt; pizza-&gt;getdescription() &lt;&lt; "\n"; 

    pizza = new Paneer(pizza);
    cout &lt;&lt; pizza-&gt;getcost() &lt;&lt; " " &lt;&lt; pizza-&gt;getdescription() &lt;&lt; "\n";


    return 0;
}
Here are some comments on your code and design.

Don't abuse using namespace std

Putting using namespace std at the top of every program is a bad habit.

Use the required #includes

The code uses std::string which means that it should #include &lt;string&gt;.  It also needs #include &lt;iostream&gt;.

Don't #include headers that aren't needed

The inverse of the advice above is to not include header files that are not needed.  In this case, "bits/stdc++.h" should be removed.  It's not standard and will only increase compilation times, so you should probably avoid it in favor of using the standard #includes as actually needed.

Don't leak memory

Each time your code in main creates a new pizza, it loses any pointer to the old one, making it a certainty that memory is leaked.  There are two ways to deal with that.  One is to use delete to match each new.  Another alternative is to use smart pointers instead.

C++ isn't Java

Code like this looks more like Java than idiomatic C++:

std::string getdescription(){
    return description;
}
int getcost(){
    return cost;
}


Instead of writing generic getters and setters in the Java style, write idiomatic C++ instead:

std::string desc() const {
    return m_description;
}
int cost() const {
    return m_cost;
}


Here I've used a relatively common idiom of prefixing class variables with m_ and omitting the word get.  Additionally, both functions are declared const because they do not alter the underlying object.

Reread the decorator pattern description

I don't think your code actually faithfully implements the decorator pattern. Consider instead a revision to your pizza model in which a new pizza retains a reference to the underlying basic pizza model passed to the constructor.  That would be a better potential illustration for the use of a decorator pattern.  See https://en.wikipedia.org/wiki/Decorator_pattern for more details.