C++ jest zbyt uprzejmy.

class Base {
private:
    int a;
public:
    Base(){}
    Base( int a ) : a(a) { }

    Base& operator=(const Base& rhs){   }
    void setA(int a){ this->a = a;}
    int getA(){ return a;}
};

class Derived : public Base {
public:
    int getB(){ return b;}
    Derived(int b) :  b(b){}


    Derived& operator=(const Derived& rhs){
        this->b = rhs.b;
    }
private:
    int b;
};

int main() {
    Base b(3);
    Derived d(9);
    d.setA(44);

    Derived cd = d;


    cout << cd.getA() << " " <<  cd.getB() << endl;

    return 0;
}

W powyższym kodzie jak widać podejmuję decyzję, że sam zdefinuję sobie operatory =. Jak widać w klase bazowej nie chcę, aby cokolwiek było kopiowane.
Stąd pytanie, skąd obiek cd ma wartość w składowej a wartość 44 skoro ja nie dopusczam do kopiowania? ( pomijam już fakt, że ja powinienem explicite wołać operator przypisania dla klasy Base w klasie Derived jeżeli chciałbym żeby została zdefiniowana część Base.
Skąd taka uprzejmość C++, wbrew temu co pisze Scott Meyers w ( bądź co bądź dość starej ) książce Effective C++?

Bo został użyty konstruktor kopiujący a nie operator =

 #include <iostream>

using namespace std;

class Base {
private:
    int a;
public:
    Base(){}
    Base( int a ) : a(a) { }
 
    Base& operator=(const Base& rhs) {}
    Base(const Base& rhs) {}
    void setA(int a){ this->a = a;}
    int getA(){ return a;}
};
 
class Derived : public Base {
public:
    int getB(){ return b;}
    Derived(int b) :  b(b){}
 
 
    Derived& operator=(const Derived& rhs){
        this->b = rhs.b;
    }
private:
    int b;
};
 
int main() {
    Base b(3);
    Derived d(9);
    d.setA(44);
 
    Derived cd = d;
 
 
    cout << cd.getA() << " " <<  cd.getB() << endl;
 
    return 0;
}

http://ideone.com/DnuA0L

a dlaczego pozwolił sobie na taką bezczelność skoro pisze wprost: '='.
W takim razie:
Kiedy jest użyty konstruktor kop, a kiedy op=?

Konstruktor kopiujący użyty jest tylko w momencie inicjalizowania obiektu jakąś(jakimiś) wartością(wartościami), operator przypisania może tylko przypisać wartość do już istniejącego i zainicjalizowanego wcześniej obiektu.

Bo to:

T x = y;

nazywa się copy initialization.

Operator przypisania nie jest brany pod uwagę.

W przypadku Twojego kodu poszukiwany jest konstruktor konwertujący (czyli taki, który nie jest explicit i wymaga jednego argumentu) w klasie Derived, który przyjmuje argument typu Derived. Oczywiście jest to konstruktor kopiujący, który zostanie wygenerowany przez kompilator.

    Derived b(3); // konstruktor
    Derived d(9); // konstruktor
 
    Derived cd = d; // konstruktor kopiujący
    cd = b; // operator przypisania

Oczywiście jest to konstruktor kopiujący, który zostanie wygenerowany przez kompilator.

Ponoć kompilator nie generuje konstruktorów sam, jeżeli weźmie się za to user. Jak to jest?

Dla tego:

cd = b; // operator przypisania

też obydwie wartości się kopiują i nie wiem dlaczego.

Poczytaj o "Rule of three/five/zero":

1. https://en.wikipedia.org/wiki/Rule_of_three_%28C%2B%2B_programming%29
2. http://en.cppreference.com/w/cpp/language/rule_of_three