Is this a good reason for non-polymorphic inheritance?

Question

`std::string` (as most — if not all — standard classes) doesn’t have any virtual methods, so creating an inherited class with virtual methods will result in UB (due most likely to the destructor). (correct me if I am wrong). I thought that inheriting without polymorphism it’s ok though, until I read upon the net on this subject. For instance, in this answer: Why should one not derive from c++ std string class? some arguments are given against this practice. The main reason seems to be the slicing problem which will inhibit the added functionality when the derived object is passed to a function in place of a `std::string` parameter, thus making the non-polymorphism not logical. The idiomatic C++ way is to create free functions if one wants to extend the functionality of `string`. And I agree with all that, especially since I am an advocate for free functions instead of monolithic classes. That being said I think that I found a situation that I think actually warrants the non-polymorphi…

Accepted Answer

You don't need to derive a class from `std::string` for this. Just create an unrelated class, say `StringBuilder` that keeps a `std::stringstream` internally. Overload operator << for this class and add a `std::string` cast operator.

Something like this should do the trick (untested):

```
class StringBuilder
{
    std::ostringstream oss;

public:
    operator std::string() const
    {
        return oss.str();
    }

template <class T>
    friend StringBuilder& operator <<(StringBuilder& sb, const T& t)
    {
        sb.oss << t;
        return *this;
    }
};
```

Is this a good reason for non-polymorphic inheritance?

Solution

Problem

Related problems