conversion-operator

Consider the following class, just as a simple example: #include <iostream> #include <string> using namespace std; class point { public: int _x{ 0 }; int _y{ 0 }; point() {} point(int x, int y) : _x{ x }, _y{ y } {} operator string() const { return '[' + to_string(_x) + ',' + to_string(_y) + ']'; } friend ostream& operator<<(ostream& os, const point& p) { // Which one? Why? os << static_cast<string>(p); // Option 1 os << p.operator string(); // Option 2 return os; } }; Should one call a conversion operator directly, or rather just call static_cast and let that do the job? Those two lines will

I am a bit confused by this. Lets assume I have a helper class Data class Data { public: Data(const QVariant &value) : m_Variant(value) { } operator QString() const { return m_Variant.toString(); } private: QVariant m_Variant; }; then when I do this: Data d("text"); QString str = d; //str becomes "text" it works but when I continue to do: Data d2("text2"); str = d2; //does not compile it fails complaining: ambiguous overload for 'operator=' (operand types are 'QString' and 'Data') candidates are: ... QString &operator=(const QString &); QString &operator=(QString &&); QString &operator=(const

I am just looking for clarification on how C++ works, this isn't really about solving a particular problem in my code. In C++ you can say that type A should implicitly convert to type B in two different ways. If you are the author of A you can add something like this to A: operator B() { // code } If you are the author of B you can add something like this to B: B(const A &a) { // code } Either one of these, if I understand correctly, will allow A to implicitly convert to B. So if both are defined which one is used? Is that even allowed? NOTE: I understand that you should probably never be in a

Here's a short example that reproduces this “no viable conversion” with lemon for clang but valid for g++ difference in compiler behavior. #include <iostream> struct A { int i; }; #ifndef UNSCREW_CLANG using cast_type = const A; #else using cast_type = A; #endif struct B { operator cast_type () const { return A{i}; } int i; }; int main () { A a{0}; B b{1}; #ifndef CLANG_WORKAROUND a = b; #else a = b.operator cast_type (); #endif std::cout << a.i << std::endl; return EXIT_SUCCESS; } live at godbolt's g++ (4.9, 5.2) compiles that silently; whereas clang++ (3.5, 3.7) compiles it if using cast

Given the following conversion operators struct A { template<typename T> explicit operator T&& () &&; template<typename T> explicit operator T& () &; template<typename T> explicit operator const T& () const&; }; struct B {}; I would expect the following conversions to be all valid, yet some give compile errors ( live example ): A a; A&& ar = std::move(a); A& al = a; const A& ac = a; B&& bm(std::move(a)); // 1. OK B&& bt(A{}); // 2. OK B&& br(ar); // 3. error: no viable conversion from A to B B& bl(al); // 4. OK const B& bz(al); // 5. OK const B& bc(ac); // 6. OK B cm(std::move(a)); // 7. error