//What is a constructor for
/*    When a class object is created, the compiler object allocates memory space and automatically calls the constructor -> The constructor does the initialization of the member
     eg: Counter c1;
      Compile the system as an object c1 Each data member (m_value) Allocate memory space and call the constructor Counter( ) Initializes the object automatically, after initialization c1 the m_value Value is set to 0
      Therefore: constructor function: initializes the data member of the object. */
      class Counter
       {
      public:       //Constructor of class Counter, with the class name as the function name and no return type
      Counter(){
      m_value = 0;
      }
      private:
      int m_value;  //Class private data member
      }
 
//Type of constructor
#include <iostream>
using namespace std;
class Complex
{
private :
    double m_real;
    double m_imag;
public:
//* no argument constructor
//If you create a class and you don't write any constructors, the system will automatically generate the default no-argument constructor, which is empty, and does nothing, right
//As long as you write one of the following constructors, the system will not automatically generate such a default constructor, if you want to have one of the following constructors, you need to write it out yourself
    Complex(void)
    {   m_real = 0.0;
        m_imag = 0.0;
    }
//* general constructor (also called overloaded constructor)
//General constructors can have a variety of parameter forms, a class can have more than one general constructor, as long as the number of parameters or different types (based on c++ overloaded function principle)
//For example, you can also write out a constructor for Complex(int num) and create objects that call different constructors depending on the parameters passed in
    Complex(double real, double imag)
    {   m_real = real;
        m_imag = imag;
    }
//* copy constructor (also known as copy constructor)
//The copy constructor parameter is a reference to the class object itself, which is used to copy a new object of this class from an existing object
//If there is no shown write copy constructor, the system creates a copy constructor by default, but when there is a pointer member in the class, there is a risk that the system creates the copy constructor by default, for reasons discussed in the "shallow copy" and "deep copy" articles
    Complex(const Complex & c)
    {   //Copies the data member values from object c
        m_real = c.m_real;
        m_imag = c.m_imag;
    }
//* type conversion constructor, according to a specified type of object to create an object of this class, it is important to note that this is actually a general constructor, but for the occurrence of such a single-parameter constructor, C++ will default to the corresponding parameters of the type to the type of this type,
//Sometimes this transition to privacy is undesirable, so explicit is used to limit the transition.
//For example, a Complex object is created based on an object of type double
    Complex(double r)
    {   m_real = r;
        m_imag = 0.0;
    }
//Equal sign operator overload (also called assignment constructor)
//Note that this is similar to the copy constructor, which copies the value of the class object on the right of = to the object on the left of the equal sign.
//If there is no overloading of the write = operator shown, the system also creates a default overloading of the = operator, doing only basic copying
    Complex &operator=(const Complex &rhs )
    {   //First check whether the object on the right of the equal sign is the object on the left
        if ( this == &rhs )
        {   return *this;
        }
        //Copy the member on the right of the equal sign into the object on the left
        this->m_real = rhs.m_real;
        this->m_imag = rhs.m_imag;
        //A =b=c the system runs b=c and then a=(the return value of b=c, which should be the b object after copying the c value).
        return *this;
    }
};
//Use the class objects defined above to illustrate the use of each constructor:
int main()
{  
    //The parameterless constructor is called, and the initial value of the data member is assigned to 0.0
    Complex c1,c2;
    //The general constructor is called and the initial value of the data member is assigned to the specified value
    Complex c3(1.0,2.5);
    //Of course, you can also use the following form
    // Complex c3 = Complex(1.0,2.5);
    //& have spent Assign the value of the data member of c3 to the previously created object c1
    //& have spent Since c1 has been created in advance, no constructor is called here
    //& have spent Only the = operator overload function is called
    c1 = c3; 
    //& have spent Call the type conversion constructor
    //& have spent The system first calls the cast constructor, which creates 5.2 as a temporary object for this class, and then calls the equals operator overload, which assigns the temporary object to c2
    c2 = 5.2; 
    //Call the copy constructor (there are two ways to call it)
    Complex c5(c3);
    Complex c4 = c3;
    //Note the difference between the = operator overloading, where the object to the left of the equal sign is not created in advance, so you need to call the copy constructor with the parameter c2
    //This is particularly important because this is initialization, not assignment.
    //There are actually two types of initialization in C++ : copy initialization and assignment initialization.
    //C5 USES replication initialization and c4 USES assignment initialization, both of which call the copy constructor.
}