What should I override in inheritance when it comes to simple derivation?

Question

class MyString :public string {
public:
    using string :: string;
    using string :: operator=;
    bool operator== (MyString&);
    bool operator<  (MyString&);
    bool operator>  (MyString&);
    MyString& operator=  (MyString&);
    MyString& operator=  (string&);
    MyString operator() (int, int);
    friend ostream & operator<<(ostream&, MyString&);
};

MyString MyString::operator() (int a, int b) {
    MyString os;
    os = string::substr(a, b);
    return os;
}

Note: I'm using cstring

It's my learning experiment. I am confused when it comes to very simple derivation like code above.

Suppose I just want to add feature that can get substring by (int, int) operator, but I realize I can't use those functions that take MyString parameters.
I have tried to use using for those operators ==, <, > but that doesn't work. The compiler tells me that string don't have those operator, I wonder it's because those functions in string are not virtual?
Is the code in operator() legal base on my functionality set in public:? The compiler doesn't tell me any thing. But I'm quite skeptical.

afaik `std::string`s destructor is non-virtual, ie. it is not really made for inheriting from it — 463035818_is_not_an_ai, Jun 26 '16 at 14:25
Do not derive. Especially not from logically sealed classes. — , Jun 26 '16 at 14:26
@juanchopanza i didnt dare to ask because I wasnt sure if its just my ignorance or something OP made up ;) — 463035818_is_not_an_ai, Jun 26 '16 at 14:27
sorry guys, seems I should avoid using terminology like words. — PeterLai, Jun 26 '16 at 14:57
Don't inherit from any standard library types that aren't specifically intended to be inherited from (like std::ostream and std::istream are). Basically, if it doesn't have a virtual destructor, don't inherit. — Taywee, Jun 26 '16 at 21:20
@tobi303: thanks! I can understand a lot from your explanation :) — PeterLai, Jun 27 '16 at 00:38

score 1 · Accepted Answer · edited May 23 '17 at 12:24

Do not derive from std::string. Some reasons are explained here, so I won't repeat them.

If you want to extend functionality of std::string, you can either

Make a wrapper class

class MyString
{
    std::string underlying_string;
public:
    /* methods */
}

Problem is, that it has nothing to do with std::string anymore. It can't be assigned to std::string, nor passed to function accepting std::string¹. Also it is quite a bit verbose - consider adding all overloads of operator+ (std::string + MyString, MyString + std::string, maybe also MyString + char*, add consts and move semantics) and you are at ~16 methods?

Another option, is to define just helper method.

std::string do_super_cool_thing(const std::string& str, int a, int b)
{
    return magic(str, a, b);
}

Can be helped with non-explicit ctor MyString::MyString(std::string), user defined conversion operator std::string(), but it has different meaning than inheritance.

If you want to pass it to a function accepting std::string, you can define `operator std::string()` on the class. [user-defined conversions](http://en.cppreference.com/w/cpp/language/cast_operator) can be incredibly useful. — Taywee, Jun 26 '16 at 21:22

What should I override in inheritance when it comes to simple derivation?

1 Answers1