Decorator Design Pattern in c++
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.