Problem z protected/ niedozwolone odwołanie

#include <iostream>
using namespace std;

class samochod {
protected:
    int stan, paliwo, spalanie, pojemnosc_baku, przebieg;
    int uruchom_silnik();
    void zatrzymaj_silnik();
    int jedz(unsigned);
    void tankuj(int);
    void prezentuj();

    samochod(int domyslny = 0)
        : stan(domyslny)
        , paliwo(100)
        , spalanie(10)
        , pojemnosc_baku(200)
        , przebieg(1500)
    {
        cout << "Start(domyslny)\n";
    };
    samochod(int stan_, int paliwo_, int spalanie_, int pojemnosc_baku_,
        int przebieg_)
        : stan(stan_)
        , paliwo(paliwo_)
        , spalanie(spalanie_)
        , przebieg(przebieg_)
        , pojemnosc_baku(pojemnosc_baku_)
    {
        cout << "Start:\n";
        prezentuj();
    }
    samochod(const samochod& kopia_sam)
        : stan(kopia_sam.stan)
        , paliwo(kopia_sam.paliwo)
        , spalanie(kopia_sam.spalanie)
        , pojemnosc_baku(kopia_sam.pojemnosc_baku)
        , przebieg(kopia_sam.przebieg)
    {
        cout << "Kopia car\n";
        prezentuj();
    }
    ~samochod() { cout << "koniec\n"; }
};

void samochod::prezentuj()
{
    cout << "stan:" << stan << endl;
    cout << "paliwo:" << paliwo << endl;
    cout << "spalanie:" << spalanie << endl;
    cout << "pojemnosc_baku:" << pojemnosc_baku << endl;
    cout << "przebieg:" << przebieg << endl;
}

class samochod_osobowy : public samochod {
public:
    int ilosc_miejsc;
    samochod_osobowy(int domyslny = 4)
        : samochod()
        , ilosc_miejsc(domyslny){};

    samochod_osobowy(int stan_, int paliwo_, int spalanie_, int pojemnosc_baku_,
        int przebieg_, int ilosc_miejsc_)
        : samochod(stan_, paliwo_, spalanie_, pojemnosc_baku_,
              przebieg_)
        , ilosc_miejsc(ilosc_miejsc_){};

    void prezentuj()
    {
        samochod::prezentuj();
        cout << "ilosc miejsc:" << ilosc_miejsc << endl;
    }
    samochod_osobowy(const samochod_osobowy& kopia_samochod_osobowy)
        : samochod(kopia_samochod_osobowy)
        , ilosc_miejsc(kopia_samochod_osobowy.ilosc_miejsc)
    {
        cout << "Konstruktor kopiujacy sam_osob\n\n";
        prezentuj();
    }
    ~samochod_osobowy() { cout << "koniec_sam_osob.\n"; }
};

class samochod_ciezarowy : public samochod {
public:
    int max_ladownosc;
    int ladunek;
    void laduj(int);
    void rozladuj(int);

    samochod_ciezarowy(int domyslna1 = 40, int domyslna2 = 35)
        : samochod()
        , max_ladownosc(domyslna1)
        , ladunek(domyslna2){};
    samochod_ciezarowy(int stan_, int paliwo_, int spalanie_, int pojemnosc_baku_,
        int przebieg_, int ilosc_miejsc_, int max_ladownosc_, int ladunek_)
        : samochod(stan_, paliwo_, spalanie_, pojemnosc_baku_,
              przebieg_)
        , max_ladownosc(max_ladownosc_)
        , ladunek(ladunek_){};
    samochod_ciezarowy(const samochod_ciezarowy& kopia_sam_ciez)
        : samochod(kopia_sam_ciez)
        , max_ladownosc(kopia_sam_ciez.max_ladownosc)
        , ladunek(kopia_sam_ciez.ladunek)
    {
        cout << "Kostruktor kopiujacy sam_ciez\n\n";
        prezentuj();
    }
    void prezentuj()
    {
        samochod::prezentuj();
        cout << "max_ladownosc:" << max_ladownosc << endl;
        cout << "ladunek:" << ladunek << "\n\n";
    }
    ~samochod_ciezarowy() { cout << "koniec_sam_ciez.\n"; }
};
void samochod_ciezarowy::laduj(int ilosc_ton)
{
    if (ilosc_ton + ladunek <= max_ladownosc)
        ladunek += ilosc_ton;
    else
        cout << "nie moge tego zrobic\n";
}
void samochod_ciezarowy::rozladuj(int ilosc_ton)
{
    if (ladunek - ilosc_ton < 0)
        cout << "nie moge tego zrobic\n";
    else
        ladunek -= ilosc_ton;
}

int main(int argc, char** argv)
{

    string wybor;
    samochod car_deflaut;
    //samochod car(0, 200, 20, 1000, 2300);
    //samochod car_copy(car);
    samochod_osobowy car_osobowy_deflaut;
    samochod_osobowy car_osobowy(0, 200, 20, 1000, 2300, 7);
    samochod_osobowy car_osobowy_copy(car_osobowy);
    samochod_ciezarowy car_ciezarowy;
    samochod_ciezarowy car_ciezarowy_copy(car_ciezarowy);
    car_ciezarowy.rozladuj(35);
    car_ciezarowy.prezentuj();
    car_ciezarowy_copy.prezentuj();

    return 0;
}