Ezt elmagyarázná valaki?

//A program már tudja kezelni ezeket a hozzárendeléseket.

unsigned short TheShort = 0;

const CAT *Morcos = new CAT(4,5);

TheShort = *Morcos;

A fordító szerint az a baj,hogy a morcos az egy constans.

Igen igaza van,ez így is van.

De nem értem hát itt nem történik semmilyen változtatás.

A morcosnak én itt nem akarom megváltoztatni az értékét.

itt csak a morcos beleteszi az életkorát a TheUshortba. Tehát a morcoshoz nem rendelődik új érték úgy.hogy nem értem magyarázza el valaki,hogy akkor miért problémázik.

Megérteném hogy mi a baj,ha a morcosnak akarnám az életkorát megváltoztatni mert nem tudnám mert konstans

sőt még új memóriacímre sem mutathat mert ez egy konstans objektumra mutató konstans mutató.

De ezt már nem értem,hogy miért nem tudom a konstans objektumnak az értékét hozzárendelni egy unsigned short változóhoz.

Magyarázza el valaki.

Hisz működnie kellene mert azzal,hogy hozzárendelném nem változna az objektum értéke.

..............................................

Ez meg egy másik probléma amit nem értek: //Hozzáteszem ennek a problémának semmi köze az elsőhöz.

itt a forráskód:

//main.cpp

# include <iostream> //std::cout,std::cin,std::endl

# include <string> //std::string

# include <stdlib.h> //EXIT_SUCCESS

# include <windows.h> //Sleep(1000),exit()

typedef unsigned short ushort; //szinoníma létrehozás

typedef unsigned int uint; //szinoníma létrehozás

using std::cout; //std:: elhagyása

using std::cin; //std:: elhagyása

using std::endl; //std:: elhagyása

using std::string; //std:: elhagyása

//CAT definíció

class CAT

{

public:

CAT(ushort age,ushort weight); //Konstruktor1

CAT(); //Konstruktor2

CAT(ushort age); //Konstruktor3 - beépített típust objektumá.

CAT(const CAT&); //Copy konstruktor

~CAT(); //destruktor

const CAT operator=(const CAT &rhs); //operator=

const CAT& operator++(); //prefix

const CAT operator++(int); //postfix

const CAT operator+(const CAT &rhs); //operator+

operator ushort(); //

void SetAge(ushort age); //SetAge

ushort GetAge()const; //GetAge

void SetWeight(ushort weight); //SetWeight

ushort GetWeight()const; //GetWeight

void IncrementPlusz(); //IncrementPlusz

private:

ushort *itsAge;

ushort *itsWeight;

};

//CAT osztály:definíciók

//Konstruktor:{Konstruktor1,Konstruktor2,Konstruktor3,Copy konstruktor,Destruktor,operator=}

CAT::CAT(ushort age,ushort weight):

itsAge(new ushort(age)),

itsWeight(new ushort(weight))

{cout <<"Konstruktor1 \n";}

CAT::CAT():

itsAge(new ushort(0)),

itsWeight(new ushort(0))

{cout <<"Konstruktor2 \n";}

CAT::CAT(ushort age):

itsAge(new ushort(age)),

itsWeight(new ushort(0))

{cout <<"Konstruktor3 \n";}

CAT::CAT(const CAT &rhs)

{

itsAge = new ushort;

itsWeight = new ushort;

*itsAge = rhs.GetAge();

*itsWeight = rhs.GetWeight();

}

CAT::~CAT()

{

cout <<"Destruktor \n";

delete itsAge;

delete itsWeight;

itsAge = NULL;

itsWeight = NULL;

}

const CAT CAT::operator=(const CAT &rhs)

{

cout <<"operator= \n";

if(this==&rhs)

return *this;

delete itsAge;

delete itsWeight;

itsAge = new ushort;

itsWeight = new ushort;

*itsAge = rhs.GetAge();

*itsWeight = rhs.GetWeight();

return *this;

}

//operator:{operator++ prefix,operator++ postfix,operator+,operator ushort}

const CAT& CAT::operator++()

{

cout <<"operator++ \n";

++*itsAge;

++*itsWeight;

return *this;

}

const CAT CAT::operator++(int)

{

cout <<"operator++ \n";

++*itsAge;

++*itsWeight;

return *this;

}

const CAT CAT::operator+(const CAT &rhs)

{

cout <<"operator+ \n";

return CAT(*itsAge+rhs.GetAge(),*itsWeight+rhs.GetWeight());

}

CAT::operator ushort()

{

cout <<"operator ushort \n";

return(ushort(*itsAge));

}

//Metódusok:{SetAge,GetAge,SetWeight,GetWeight,IncrementPlusz}

void CAT::SetAge(ushort age)

{*itsAge = age;}

ushort CAT::GetAge()const

{return *itsAge;}

void CAT::SetWeight(ushort weight)

{*itsWeight = weight;}

ushort CAT::GetWeight()const

{return *itsWeight;}

//main kezdődik

int main()

{

const ushort TheUshort; /* Miért nem fordul le ha a TheUshort-ot konstansként deklarálom? */

const CAT *const Bolyhos = new CAT(4,5);

const CAT *const Morcos = new CAT(5,6);

CAT *const Cirmi = new CAT();

cout <<"\nBolyhos most "<< Bolyhos->GetAge() <<" eves \n"

<<"Cirmi most "<< Cirmi->GetAge() <<" eves \n"

<<"Morcos most "<< Morcos->GetAge() <<" eves \n\n"

<<"Bolyhos most "<< Bolyhos->GetWeight() <<" kg \n"

<<"Cirmi most "<< Cirmi->GetWeight() <<" kg \n"

<<"Morcos most "<< Morcos->GetWeight() <<" kg \n\n";

*Cirmi = *Cirmi + *Morcos;

cout <<"\nBolyhos most "<< Bolyhos->GetAge() <<" eves \n"

<<"Cirmi most "<< Cirmi->GetAge() <<" eves \n"

<<"Morcos most "<< Morcos->GetAge() <<" eves \n\n"

<<"Bolyhos most "<< Bolyhos->GetWeight() <<" kg \n"

<<"Cirmi most "<< Cirmi->GetWeight() <<" kg \n"

<<"Morcos most "<< Morcos->GetWeight() <<" kg \n\n";

TheUshort = *Cirmi;

cout <<"TheUshort: "<< TheUshort << endl

<<"Morcos most "<< Morcos->GetAge() <<" eves \n"

<<"Morcos most "<< Morcos->GetWeight() <<" kg \n\n";

*Cirmi = TheUshort;

cout <<"\nTheUshort: "<< TheUshort << endl

<<"nMorcos most "<< Morcos->GetAge() <<" eves \n"

<<"Morcos most "<< Morcos->GetWeight() <<" kg \n\n";

delete Bolyhos;

delete Morcos;

delete Cirmi;

return EXIT_SUCCESS;

}

//Miért nem fordul le ha a TheUshort-ot konstansként deklarálom?