Question

I would like the following code to be equivalent:

f = "abc";
h.data = f;

---

EDIT: I’d also like the ability to do the following:

f += "def"; // f.data == "abcdef";
std::string s = f; // s = "abcdef";

std::cout << f << std::endl;
std::cin >> f;

std::vector<std::string> v (f);
v.push_back(h);

// This would be overkill.
printf("%s", (f + std::string("...\n")).c_str());

Would I need to “inherit” std::string or something? (I’m new to this stuff, so could you show me how?)

---

Here’s my class:

class Foo
{
public:
    std::string data;
} f, h;

Answer 1

EDIT: I’d also like the ability to do the following: […]

[ This would have been better served as a new question but I don’t think you could have foreseen that. ]

No, you don’t need to inherit from std::string. One possible way to do what you want is to add a conversion operator. (I won’t address how to implement operator+=, it can be looked up elsewhere.)

class foo {
    std::string data;
public:
    foo&
    operator=(std::string); // See Kerrek's answer for implementation

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

This will do what you want. But I strongly advise you not to use that. Surprising implicit conversions are frowned upon; I recommend reading Herb Sutter to learn why.

Alternatively you can make the conversion operator explicit (as in, declaring it explicit operator std::string const&() const;) to suppress implicit conversions. But that’s quite less convenient and readable than adding a member function with an appropriate name:

class foo {
    // as before

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

    std::string const&
    as_string() const
    { return data; }
};

foo f;

// Contrast the uses:
// std::string s0 = f; Not ok; would be an implicit conversion
std::string s0(f); // Ok; explicit conversion
std::string s1 = f.as_string(); // Ok; std::string s1(f.as_string()) works too

std::vector<std::string> v;
// v.push_back(f); Not ok; would use an implicit conversion
v.push_back(static_cast<std::string const&>(f)); // Ok; inconvenient
v.push_back(f.as_string()); // Ok; convenient

Whatever you choose, I still recommend implementing appropriate operators for working with streams:

std::ostream&
operator<<(std::ostream& os, foo const& f)
{
    return os << f.as_string();
}

std::istream&
operator>>(std::istream& is, foo& f)
{
    std::string extracted;
    if(is >> extracted) {
        f = std::move(extracted);
    }
    return is;
}