static_cast<> behaviour on class with implicit conversion operator that returns a const reference

Question

I have the following class (stripped down to contain only the relevant parts):

#include <string>

class Text
{
private:
    std::string _text;

public:
    Text(std::string&& text) :
        _text(std::move(text))
    {
    }

    operator const std::string&() const
    {
        return _text;
    }
};

My question is: if I want to obtain a const std::string&, can I do it like this without any penalty:

 Text text("fred");

 auto& s = static_cast<std::string>(text);

Or will this construct an intermediate std::string that I end up getting a reference to? Is there a standard approach to this kind of scenario? I am reasonably new to C++.

Answer 1

No, when you're calling static_cast<std::string>(text), you're calling the implicitly defined copy constructor and creating a temporary object.

However, if you would be calling

auto& s = static_cast<const std::string&>(text);

,then you would correctly be calling the explicit conversion operator operator const Noisy&().

Let's try it out

struct Noisy {
    Noisy() { std::cout << "Default construct" << std::endl; }
    Noisy(const Noisy&) { std::cout << "Copy construct" << std::endl; }
    Noisy(Noisy&&) { std::cout << "Move construct" << std::endl; }
    Noisy& operator=(const Noisy&) { std::cout << "C-assign" << std::endl; return *this; }
    Noisy& operator=(Noisy&&) { std::cout << "M-assign" << std::endl; return *this; }
    ~Noisy() { std::cout << "Destructor" << std::endl; }
};

class Text {
public:
    Text(Noisy&& text) : _text(std::move(text)) {}
    operator const Noisy&() const { return _text; }
private:
    Noisy _text;
};

Test 1

int main() {
    Text text(Noisy{});
    const auto& s = static_cast<Noisy>(text); // Needs 'const' to bind to temporary.
}

Default construct
Move construct
Destructor
Copy construct
Destructor
Destructor

Test 2

int main() {
    Text text(Noisy{});
    auto& s = static_cast<const Noisy&>(text);
}

Default construct
Move construct
Destructor
Destructor

_{Note: Compiled using option -fno-elide-constructors to avoid copy elision optimizations.}