Why is the wrong ctor being called?

Question

I have code that works as expected:

EscapedString es("Abc&def");
EscapedString es2("");
es2 = es;     // es2 == Abc%26def

And code that doesn't work as expected:

EscapedString es("Abc&def");
EscapedString es2 = es;    // es == Abc%2526def

In the second case, the CTOR2 is called instead of CTOR3 even though es is an EscapedString.

EscapedString es(EscapedString("Abc?def"));

Does the right thing, but I can't seem to set a breakpoint on CTOR3 so I'm not sure it is working correctly, or the code has been optimized away or it is accidentally working.

The class is below:

class EscapedString : public std::string {
public:
    EscapedString(const char *szUnEscaped) {  // CTOR1
        *this = szUnEscaped;
    }

    EscapedString(const std::string &strUnEscaped) {   // CTOR2
        *this = strUnEscaped;
    }

    explicit EscapedString(const EscapedString &strEscaped) {   // CTOR3
        *this = strEscaped;  // Can't set breakpoint here
    }

    EscapedString &operator=(const std::string &strUnEscaped) {
        char *szEscaped = curl_easy_escape(NULL, strUnEscaped.c_str(), strUnEscaped.length());
        this->assign(szEscaped);
        curl_free(szEscaped);
        return *this;
    }
    EscapedString &operator=(const char *szUnEscaped) {
        char *szEscaped = curl_easy_escape(NULL, szUnEscaped, strlen(szUnEscaped));
        this->assign(szEscaped);
        curl_free(szEscaped);
        return *this;
    }
    EscapedString &operator=(const EscapedString &strEscaped) {
        // Don't re-escape the escaped value
        this->assign(static_cast<const std::string &>(strEscaped));
        return *this;
    }
};

Answer 1

Normally, EscapedString es2 = es; will call the copy constructor, however you explicitly told it not to by making the copy constructor explicit :

explicit EscapedString(const EscapedString &strEscaped)

A constructor marked explicit can never be called by means of automatic type conversions. It can only be called, well... explicitly, which you have done here:

EscapedString es(EscapedString("Abc?def"));

Here's what happens when the compiler encounters EscapedString es2 = es; .

First the compiler sees if it can use the copy constructor and finds that it can't, because it was marked explicit . So it looks for another constructor to call. Since EscapedString is derived from std::string , the compiler is able to cast es as a const std::string& and call:

EscapedString &operator=(const std::string &strUnEscaped)