使用重载 = 在 C++ 中进行隐式类型转换

Question

in the below code (which is an example for type conversion):

// implicit conversion of classes:
#include <iostream>
using namespace std;

class A {};

class B {
public:
  // conversion from A (constructor):
  B (const A& x) {}
  // conversion from A (assignment):
  B& operator= (const A& x) {return *this;}
  // conversion to A (type-cast operator)
  operator A() {return A();}
};

int main ()
{
  A foo;
  B bar = foo;    // calls constructor
  bar = foo;      // calls assignment
  foo = bar;      // calls type-cast operator
  return 0;
}

in line 21: bar = foo; // calls assignment bar = foo; // calls assignment it calls the overloaded operator =. and in the body of class overloading for "=" operator is written in line 12: B& operator= (const A& x) {return *this;} it's statement says "return this". here this points to bar. and there's just a parameter of type class A: const A& x what does this function do with this parameter? and in line 21 what is converted to what by writing: bar = foo; ?

Answer 1

The real question you might be asking is what does the operator= function used for?

Normally we take some data from the constant reference For example

struct A{
    std::string data;
}

struct B{
    std::string differentData;

    B& operator=(const A& other){
        differentData = other.data;
        return *this;
    }
}

Then if we call code like

int main(){
    A a;
    a.data = "hello";
    B b;
    b = a;

    std::cout << b.differentData;
}

We should get "hello" printing to the console

Since you're not interacting with the class given in the function, all this code is doing is running an empty function.

The return is only used if you chain together equal calls

int main(){
    B b1, b2, b3;

    b3.differentData = "hi";
    b1 = b2 = b3;
    //Pushes hi from b3 >> b2 and returns b2
    //Pushes hi from b2 >> b1 and returns b1
}

Answer 2

what does this function do with this parameter?

Nothing.

what is converted to what by writing: bar = foo;

Nothing. Or equivalently, the state of bar is replaced from the state of foo .