从std :: basic_string取消继承

Question

Basically, I have a large project that uses a custom utility class c_string that inherits from std::basic_string<char> . For numerous reasons, I would like to edit this class so that

1. It does not derive from std::basic_string<char>
2. I do not have to re-implement all the functions
3. I do not have to touch every file that uses c_string

So I want to change from:

class c_string : public std::basic_string<char>
{
public:
    typedef std::basic_string<char> Base;

    c_string() : Base() {}
}

To:

class c_string
{

...

public:

    ...

    c_string() {...}
}

So, I'm wondering if anyone has a good strategy for making this change with minimal impact.

Answer 1

If your class adds custom functionality (that your project needs) over std::string , then you're out of luck: you will either have to encapsulate std::string (and implement all methods to forward to std::string implementation) or inherit from std::string (inheriting from std::string is not a good idea in general).

If your class doesn't add extra functionality over std::string , then replace class c_string { ... } with typedef std::string c_string; .

Answer 2

There is another thing you can do and that is to change the public inheritance with private inheritance. Doing that, you will get a bunch of compile errors, because all of string's memberfunctions are now private to the clients of your class. You can then selectively make these public:

class my_string: std::string {
public:
    typedef std::string base; // convenience
    using base::const_iterator;
    using base::begin;
    using base::end;
};

You should understand private derivation not as "my_string is a std::string" but "my_string is implemented in terms of std::string". This technique avoids some of the downsides (implicit conversion, slicing etc) of deriving from a type that is not intended to be a baseclass, like std::string. Doing this conversion is easy, it's just work with little risk of breaking anything. Afterwards though, you have control over the forwarded interfaces, which makes conversion and refactoring much easier.

Answer 3

I can't see any way that you could avoid at least wrapping all the functions. The most straightforward way would be to have a private basic_string member, and just write wrappers that call the same function on that member.

Answer 4

I have nearly the same problem as zdp. Not inherit from std::string leads in a lot of code not to use methods (we have a lot like this) as void Foo(string &s_) where a string is the parameter in the function and the user puts a my_string to Foo(). In short therm: Inherit from std::string and you can send your my_string to any function which takes a my_string OR a std::string as parameter. I would like to rewrite my my_string class but there are a lot of code with this problem in other hands and a lot of people have to change their code too. One bad choice 14 years ago....... sh..