Konstruktory w c++

Cześc, z takiego czegoś będę mięć kartkówkę

 #include <iostream>
using namespace std;

class A
{
    public:
    int *x;
    A(int arg)
    {
        //arg = 3;
        x = new int;
        *x = arg;
    }

    ~A()
    {
        delete x;
    }

    A(A &argument)
    {
        x = new int;
        *x = *(argument.x);
    }

    A &operator= (A &q)
    {
        if(this==&q) { return *this; }
        delete x;
        x = new int;
        *x = *(q.x);
        return *this;
    }
};

/*void f(A arg)
{
    *(arg.x) = 2;
}*/



int main()
{
    A y(2);
    A q(3);
    A g(7);
    y.operator=(q.operator=(g));  // przypisanie y=(q=g)
    //*(y.x)=3;
    //f(y);
    cout << *(y.x) << endl;
    cout << *(q.x) << endl;
    cout << *(g.x) << endl;

}

wytłumaczy ktoś ten kawałek kodu, z góry dzięki?

     A &operator= (A &q)
    {
        if(this==&q) { return *this; }
        delete x;
        x = new int;
        *x = *(q.x);
        return *this;
    }
};

http://en.cppreference.com/w/cpp/language/copy_assignment

W programie, który wstawiłeś został zdefiniowany operator= dla klasy A. Spowodało to że, nie został wygenerowany defaultowy operator=.

A &operator= (A &q)
	{
		if (this == &q) { return *this; } //jezeli chcemy pod obiekt, którym "ja jestem" przypisac ten sam obiekt to nic nie robimy, po prostu zwracamy "siebie" i wychodzimy (this jest specjalnym wskaźnikiem, żeby dostać się do jego wartości używamy *, czyli operatora dereferencji)
		delete x; //usuwamy zmienną typu int pokazywaną przez wskaznik x
		x = new int; //tworzymy nową zmienną typu, która będzie pokazywana przez wskaznik x
		*x = *(q.x); //dobieramy sie do zmiennej int pokazywanej przez wskaznik x
		//i przypisujemy pod nią wartosc ktora uzyskamy po dobraniu sie zmiennej typu int ktora jest pokazywana przez wskaznik q.x
		//(chodzi o wskaznik ktory jest skladnikiem klasy A, dostajemy sie do niego przez obiekt q który podajemy w parametrze)
		return *this;//juz wykonalismy przypisanie do obiektu ktorym jest "ja sam", wiec zwracamy jego wartosc
	} 

To jest implementacja operatora przypisania, czyli ta funkcja jest wywołana np. w przypadku

obiektTypuA_1 = obiektTypuA_2;

co jest równoważne

obiektTypuA_1.operator=(obiektTypuA_2);

Sama implementacja jest dosyć kulawa, np. sygnatura powinna być

A& operator=(const A& q)

warto mieć const w tym miejscu, po szczegóły odsyłam do google'a pod c++ const correctness

if (this == &q) { return *this; }

To jest sprawdzanie przypadku

obiekt1 = obiekt1

wtedy chcemy, żeby funkcja nic nie robiła, tylko od razu zwróciła referencję do obiektu, na którym operujemy

delete x;
x = new int;
*x = *(q.x);

Skopiowanie wartości x z obiektu q do naszego obiektu (czyli właściwa funkcjonalność tej funkcji). Tyle że w tym konkretnym przypadku 2 pierwsze linie są zupełnie niepotrzebne.