Zakres wa˙zno ´sci, przekazywanie obiektów, obiekty

tymczasowe

Bogdan Kreczmer

ZPCiR IIAiR PWr

pokój 307 budynek C3

bogdan.kreczmer@pwr.wroc.pl

2005–2010 Bogdan Kreczmer

Niniejszy dokument zawiera materiały do wykładu na temat programowania obiektowego. Jest on udost ˛epniony pod

warunkiem wykorzystania wył ˛

acznie do własnych prywatnych potrzeb i mo˙ze on by´c kopiowany wył ˛

acznie w cało´sci, razem z

niniejsz ˛

a stron ˛

a tytułow ˛

Zakres wa˙zno ´sci deklaracji

class PrzykladKlasy { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

const char

∗

const

Nazwa;

public :

PrzykladKlasy( const char

∗

Nazwa ): Nazwa(Nazwa)

{ cout

”++ Konstruktor obiektu: ”

Nazwa

endl; }

∼

PrzykladKlasy( ) { cout

”

−−

Destruktor obiektu: ”

Nazwa

endl; }

}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

PrzykladKlasy ObA(”A”)

;

int main( )
{

cout

”main: 1”

endl;

PrzykladKlasy ObB(”B”)

;

cout

”main: 2”

endl;

{

PrzykladKlasy ObC(”C”)

;

}

cout

”main: 3”

endl;

}

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Zakres wa˙zno ´sci deklaracji

class PrzykladKlasy { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

const char

∗

const

Nazwa;

public :

PrzykladKlasy( const char

∗

Nazwa ): Nazwa(Nazwa)

{ cout

”++ Konstruktor obiektu: ”

Nazwa

endl; }

∼

PrzykladKlasy( ) { cout

”

−−

Destruktor obiektu: ”

Nazwa

endl; }

}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

PrzykladKlasy ObA(”A”)

;

int main( )
{

cout

”main: 1”

endl;

PrzykladKlasy ObB(”B”)

;

cout

”main: 2”

endl;

{

PrzykladKlasy ObC(”C”)

;

}

cout

”main: 3”

endl;

}

Wynik działania:

++ Konstruktor obiektu:

main:

++ Konstruktor obiektu:

main:

++ Konstruktor obiektu:

−− Destruktor obiektu:

main:

−− Destruktor obiektu:

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Zakres wa˙zno ´sci deklaracji

class PrzykladKlasy { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

const char

∗

const

Nazwa;

public :

PrzykladKlasy( const char

∗

Nazwa ): Nazwa(Nazwa)

{ cout

”++ Konstruktor obiektu: ”

Nazwa

endl; }

∼

PrzykladKlasy( ) { cout

”

−−

Destruktor obiektu: ”

Nazwa

endl; }

}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

PrzykladKlasy ObA(”A”)

;

int main( )
{

cout

”main: 1”

endl;

PrzykladKlasy ObB(”B”)

;

cout

”main: 2”

endl;

{

PrzykladKlasy ObC(”C”)

;

}

cout

”main: 3”

endl;

}

Wynik działania:

++ Konstruktor obiektu:

main:

++ Konstruktor obiektu:

main:

++ Konstruktor obiektu:

−− Destruktor obiektu:

main:

−− Destruktor obiektu:

Utworzenie bloku instrukcji wyznacza czas ˙zycia tworzonych statycznie obiektów.

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Obszar istnienia zmiennych dynamicznych

class PrzykladKlasy { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

const char

∗

const

Nazwa;

public :

PrzykladKlasy( const char

∗

Nazwa ): Nazwa(Nazwa)

{ cout

”++ Konstruktor obiektu: ”

Nazwa

endl; }

∼

PrzykladKlasy( ) { cout

”

−−

Destruktor obiektu: ”

Nazwa

endl; }

}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

int main( )
{

cout

”main: 1”

endl;

PrzykladKlasy

∗

wOb1;

{

PrzykladKlasy

∗

wOb2 =

new PrzykladKlasy(”X”)

;

wOb1 = wOb2;

}

cout

”main: 2”

endl;

delete wOb1;

cout

”main: 3”

endl;

}

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Obszar istnienia zmiennych dynamicznych

class PrzykladKlasy { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

const char

∗

const

Nazwa;

public :

PrzykladKlasy( const char

∗

Nazwa ): Nazwa(Nazwa)

{ cout

”++ Konstruktor obiektu: ”

Nazwa

endl; }

∼

PrzykladKlasy( ) { cout

”

−−

Destruktor obiektu: ”

Nazwa

endl; }

}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

int main( )
{

cout

”main: 1”

endl;

PrzykladKlasy

∗

wOb1;

{

PrzykladKlasy

∗

wOb2 =

new PrzykladKlasy(”X”)

;

wOb1 = wOb2;

}

cout

”main: 2”

endl;

delete wOb1;

cout

”main: 3”

endl;

}

Wynik działania:

main:

++ Konstruktor obiektu:

main:

−− Destruktor obiektu:

main:

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Obszar istnienia zmiennych dynamicznych

class PrzykladKlasy { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

const char

∗

const

Nazwa;

public :

PrzykladKlasy( const char

∗

Nazwa ): Nazwa(Nazwa)

{ cout

”++ Konstruktor obiektu: ”

Nazwa

endl; }

∼

PrzykladKlasy( ) { cout

”

−−

Destruktor obiektu: ”

Nazwa

endl; }

}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

int main( )
{

cout

”main: 1”

endl;

PrzykladKlasy

∗

wOb1;

{

PrzykladKlasy

∗

wOb2 =

new PrzykladKlasy(”X”)

;

wOb1 = wOb2;

}

cout

”main: 2”

endl;

delete wOb1;

cout

”main: 3”

endl;

}

Wynik działania:

main:

++ Konstruktor obiektu:

main:

−− Destruktor obiektu:

main:

Zmienne tworzone dynamicznie istniej ˛

a niezale˙znie od zakresu wa˙zno´sci deklaracji zmiennej wska´z-

nikowej. Ich destruktory uruchamiane s ˛

a tylko i wył ˛

acznie w momencie u˙zycia operatora

delete.

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Definiowanie zmiennych w ”locie”

class PrzykladKlasy { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

const char

∗

const

Nazwa;

public :

PrzykladKlasy( const char

∗

Nazwa ): Nazwa(Nazwa)

{ cout

”++ Konstruktor obiektu: ”

Nazwa

endl; }

∼

PrzykladKlasy( )

{ cout

”

−−

Destruktor obiektu: ”

Nazwa

endl; }

}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

int main( )
{

int Zm = 0;

cout

”main: 1”

endl;

if (Zm == 0) { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

KlasaTest ObA(”A”);

}

else { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

KlasaTest ObB(”B”);

} // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

cout

”main: 2”

endl;

}

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Definiowanie zmiennych w ”locie”

class PrzykladKlasy { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

const char

∗

const

Nazwa;

public :

PrzykladKlasy( const char

∗

Nazwa ): Nazwa(Nazwa)

{ cout

”++ Konstruktor obiektu: ”

Nazwa

endl; }

∼

PrzykladKlasy( )

{ cout

”

−−

Destruktor obiektu: ”

Nazwa

endl; }

}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

int main( )
{

int Zm = 0;

cout

”main: 1”

endl;

if (Zm == 0) { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

KlasaTest ObA(”A”);

}

else { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

KlasaTest ObB(”B”);

} // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

cout

”main: 2”

endl;

}

Wynik działania:

main:

++ Konstruktor obiektu:

- Destruktor obiektu:

main:

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Definiowanie zmiennych w ”locie”

class PrzykladKlasy { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

const char

∗

const

Nazwa;

public :

PrzykladKlasy( const char

∗

Nazwa ): Nazwa(Nazwa)

{ cout

”++ Konstruktor obiektu: ”

Nazwa

endl; }

∼

PrzykladKlasy( )

{ cout

”

−−

Destruktor obiektu: ”

Nazwa

endl; }

}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

int main( )
{

int Zm = 0;

cout

”main: 1”

endl;

if (Zm == 0) { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

KlasaTest ObA(”A”);

}

else { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

KlasaTest ObB(”B”);

} // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

cout

”main: 2”

endl;

}

Wynik działania:

main:

++ Konstruktor obiektu:

- Destruktor obiektu:

main:

Mechanizmy definiowania zmiennych w j ˛ezyku C++ pozwalaj ˛

a je tworzy´c w tych miejscach, w któ-

rych faktycznie s ˛

a potrzebne.

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Definiowanie zmiennych w ”locie”

class PrzykladKlasy { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

const char

∗

const

Nazwa;

public :

PrzykladKlasy( const char

∗

Nazwa ): Nazwa(Nazwa)

{ cout

”++ Konstruktor obiektu: ”

Nazwa

endl; }

∼

PrzykladKlasy( )

{ cout

”

−−

Destruktor obiektu: ”

Nazwa

endl; }

}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

int main( )
{

cout

”main: 1”

endl;

for ( int licznik = 0; licznik

2; ++licznik ) { // . . . . . . . . .

KlasaTest ObA(”A”);

cout

” Licznik: ”

licznik

endl;

} // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

cout

”main: 2”

endl;

cout

” Licznik: ”

hhh

((

(

licznik

endl;

}

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Definiowanie zmiennych w ”locie”

class PrzykladKlasy { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

const char

∗

const

Nazwa;

public :

PrzykladKlasy( const char

∗

Nazwa ): Nazwa(Nazwa)

{ cout

”++ Konstruktor obiektu: ”

Nazwa

endl; }

∼

PrzykladKlasy( )

{ cout

”

−−

Destruktor obiektu: ”

Nazwa

endl; }

}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

int main( )
{

cout

”main: 1”

endl;

for ( int licznik = 0; licznik

2; ++licznik ) { // . . . . . . . . .

KlasaTest ObA(”A”);

cout

” Licznik: ”

licznik

endl;

} // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

cout

”main: 2”

endl;

cout

” Licznik: ”

hhh

((

(

licznik

endl;

}

Wynik działania:

main:

++ Konstruktor obiektu:

Licznik:

- Destruktor obiektu:

++ Konstruktor obiektu:

Licznik:

- Destruktor obiektu:

main:

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Definiowanie zmiennych w ”locie”

class PrzykladKlasy { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

const char

∗

const

Nazwa;

public :

PrzykladKlasy( const char

∗

Nazwa ): Nazwa(Nazwa)

{ cout

”++ Konstruktor obiektu: ”

Nazwa

endl; }

∼

PrzykladKlasy( )

{ cout

”

−−

Destruktor obiektu: ”

Nazwa

endl; }

}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

int main( )
{

cout

”main: 1”

endl;

for ( int licznik = 0; licznik

2; ++licznik ) { // . . . . . . . . .

KlasaTest ObA(”A”);

cout

” Licznik: ”

licznik

endl;

} // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

cout

”main: 2”

endl;

cout

” Licznik: ”

hhh

((

(

licznik

endl;

}

Wynik działania:

main:

++ Konstruktor obiektu:

Licznik:

- Destruktor obiektu:

++ Konstruktor obiektu:

Licznik:

- Destruktor obiektu:

main:

W instrukcji

for mo˙zna definiowa´c i inicjalizowa´c zmienne pełni ˛

ace rol ˛e liczników lub w inny sposób

wykorzystywane w trakcie iteracji p ˛etli. Pozwala to utworzy´c zmienn ˛

a dopiero w tym miejscu, w

którym jest potrzebna. Deklarowanie zmiennych i obiektów wewn ˛

atrz bloku instrukcji

for wi ˛

a˙ze si ˛e z

ich kreowaniem i destrukcj ˛

a przy ka˙zdej iteracji p ˛etli.

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Definiowanie zmiennych w ”locie”

if ( int Zm = Funkcja( ) ) {

// Zakres widoczno´sci zmiennej

}

else {

// Zakres widoczno´sci zmiennej

}

switch ( int Zm = Funkcja( ) ) {

// Zakres widoczno´sci zmiennej

}

while ( int Zm = Funkcja( ) ) {

// Zakres widoczno´sci zmiennej

}

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Definiowanie zmiennych w ”locie”

if ( int Zm = Funkcja( ) ) {

// Zakres widoczno´sci zmiennej

}

else {

// Zakres widoczno´sci zmiennej

}

switch ( int Zm = Funkcja( ) ) {

// Zakres widoczno´sci zmiennej

}

while ( int Zm = Funkcja( ) ) {

// Zakres widoczno´sci zmiennej

}

W przypadku instrukcji iteracyjnych kreacja i destrukcja zmiennej przebiega tyle razy, ile razy wyko-

nana zostanie dana p ˛etla.

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Definiowanie zmiennych w ”locie”

{

int Zm = Funkcja( );

. . .

}

while ( int Zm = Funkcja( ) ) {

// Zakres widoczno´sci zmiennej

}

{

(

int Zm = Funkcja( ) ) != 0

hhh

((

(

hhh

((

(

;

. . .

}

while (

hhh

((

(

hhh

((

(

int Zm = Funkcja( ) ) != 0 ) {

// Zakres widoczno´sci zmiennej

}

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Definiowanie zmiennych w ”locie”

{

int Zm = Funkcja( );

. . .

}

while ( int Zm = Funkcja( ) ) {

// Zakres widoczno´sci zmiennej

}

{

(

int Zm = Funkcja( ) ) != 0

hhh

((

(

hhh

((

(

;

. . .

}

while (

hhh

((

(

hhh

((

(

int Zm = Funkcja( ) ) != 0 ) {

// Zakres widoczno´sci zmiennej

}

Definiowanie zmiennych w ”locie” nie mo˙ze ł ˛

aczy´c ze sob ˛

a dodatkowych operacji podobnie jak zwy-

kłe definiowanie zmiennych.

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Przekazywanie parametru przez warto ´s ´c

class KlasaTest { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

const char

∗

const

Nazwa;

public :

void Metoda( KlasaTest Ob )

{ cout

”... Metoda uruchomiona”

endl; }

KlasaTest( const char

∗

Nazwa ): Nazwa(Nazwa)

{ cout

”++ Konstruktor obiektu: ”

Nazwa

endl; }

∼

KlasaTest( ) { cout

”

−−

Destruktor obiektu: ”

Nazwa

endl; }

}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

int main( )
{

cout

”main: 1”

endl;

KlasaTest ObA(”A”);

cout

”main: 2”

endl;

ObA.Metoda(ObA)

;

cout

”main: 3”

endl;

}

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Przekazywanie parametru przez warto ´s ´c

class KlasaTest { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

const char

∗

const

Nazwa;

public :

void Metoda( KlasaTest Ob )

{ cout

”... Metoda uruchomiona”

endl; }

KlasaTest( const char

∗

Nazwa ): Nazwa(Nazwa)

{ cout

”++ Konstruktor obiektu: ”

Nazwa

endl; }

∼

KlasaTest( ) { cout

”

−−

Destruktor obiektu: ”

Nazwa

endl; }

}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

int main( )
{

cout

”main: 1”

endl;

KlasaTest ObA(”A”);

cout

”main: 2”

endl;

ObA.Metoda(ObA)

;

cout

”main: 3”

endl;

}

Wynik działania:

main:

++ Konstruktor obiektu:

main:

...

Metoda uruchomiona

−− Destruktor obiektu:

main:

−− Destruktor obiektu:

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Przekazywanie parametru przez warto ´s ´c

class KlasaTest { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

const char

∗

const

Nazwa;

public :

void Metoda( KlasaTest Ob )

{ cout

”... Metoda uruchomiona”

endl; }

KlasaTest( const char

∗

Nazwa ): Nazwa(Nazwa)

{ cout

”++ Konstruktor obiektu: ”

Nazwa

endl; }

∼

KlasaTest( ) { cout

”

−−

Destruktor obiektu: ”

Nazwa

endl; }

}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

int main( )
{

cout

”main: 1”

endl;

KlasaTest ObA(”A”);

cout

”main: 2”

endl;

ObA.Metoda(ObA)

;

cout

”main: 3”

endl;

}

Wynik działania:

main:

++ Konstruktor obiektu:

main:

...

Metoda uruchomiona

−− Destruktor obiektu:

main:

−− Destruktor obiektu:

Przy przekazywaniu parametru poprzez warto´s´c na poziomie funkcji/metody tworzona jest kopia

obiektu. Zako ´nczenie działania funkcji/metody ko ´nczy “˙zycie” tej kopii. Ale co z konstruktorem???

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Konstruktor kopiuj ˛

acy

class KlasaTest { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

const char

∗

const

Nazwa;

public :

void Metoda( KlasaTest Ob ) { cout

”... Metoda uruchomiona”

endl; }

KlasaTest( const KlasaTest & Ob ): Nazwa(Ob. Nazwa)

{ cout

”++ Konstruktor kopiujacy: ”

Nazwa

endl; }

KlasaTest( const char

∗

Nazwa ): Nazwa(Nazwa)

{ cout

”++ Konstruktor obiektu: ”

Nazwa

endl; }

∼

KlasaTest( ) { cout

”

−−

Destruktor obiektu: ”

Nazwa

endl; }

}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

int main( )
{

cout

”main: 1”

endl;

KlasaTest ObA(”A”);

cout

”main: 2”

endl;

ObA.Metoda(ObA)

;

cout

”main: 3”

endl;

}

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Konstruktor kopiuj ˛

acy

class KlasaTest { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

const char

∗

const

Nazwa;

public :

void Metoda( KlasaTest Ob ) { cout

”... Metoda uruchomiona”

endl; }

KlasaTest( const KlasaTest & Ob ): Nazwa(Ob. Nazwa)

{ cout

”++ Konstruktor kopiujacy: ”

Nazwa

endl; }

KlasaTest( const char

∗

Nazwa ): Nazwa(Nazwa)

{ cout

”++ Konstruktor obiektu: ”

Nazwa

endl; }

∼

KlasaTest( ) { cout

”

−−

Destruktor obiektu: ”

Nazwa

endl; }

}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

int main( )
{

cout

”main: 1”

endl;

KlasaTest ObA(”A”);

cout

”main: 2”

endl;

ObA.Metoda(ObA)

;

cout

”main: 3”

endl;

}

Wynik działania:

main:

++ Konstruktor obiektu:

main:

++ Konstruktor kopiujacy:

...

Metoda uruchomiona

−− Destruktor obiektu:

main:

−− Destruktor obiektu:

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Konstruktor kopiuj ˛

acy

class KlasaTest { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

const char

∗

const

Nazwa;

public :

void Metoda( KlasaTest Ob ) { cout

”... Metoda uruchomiona”

endl; }

KlasaTest( const KlasaTest & Ob ): Nazwa(Ob. Nazwa)

{ cout

”++ Konstruktor kopiujacy: ”

Nazwa

endl; }

KlasaTest( const char

∗

Nazwa ): Nazwa(Nazwa)

{ cout

”++ Konstruktor obiektu: ”

Nazwa

endl; }

∼

KlasaTest( ) { cout

”

−−

Destruktor obiektu: ”

Nazwa

endl; }

}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

int main( )
{

cout

”main: 1”

endl;

KlasaTest ObA(”A”);

cout

”main: 2”

endl;

ObA.Metoda(ObA)

;

cout

”main: 3”

endl;

}

Wynik działania:

main:

++ Konstruktor obiektu:

main:

++ Konstruktor kopiujacy:

...

Metoda uruchomiona

−− Destruktor obiektu:

main:

−− Destruktor obiektu:

Przy tworzeniu kopii obiektu wywoływany jest niejawnie konstruktor kopiuj ˛

acy. W ka˙zdej klasie za-

wsze istnieje taki konstruktor niezale˙znie od innych konstruktorów.

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Konstruktor kopiuj ˛

acy

class KlasaTest { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

const char

∗

const

Nazwa;

KlasaTest( const KlasaTest & Ob ): Nazwa(Ob. Nazwa)

{ cout

”++ Konstruktor kopiujacy: ”

Nazwa

endl; }

public :

void Metoda( KlasaTest Ob ) { cout

”... Metoda uruchomiona”

endl; }

KlasaTest( const char

∗

Nazwa ): Nazwa(Nazwa)

{ cout

”++ Konstruktor obiektu: ”

Nazwa

endl; }

∼

KlasaTest( ) { cout

”

−−

Destruktor obiektu: ”

Nazwa

endl; }

}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

int main( )
{

KlasaTest ObA(”A”);

hhh

((

(

ObA.Metoda(ObA)

;

}

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Konstruktor kopiuj ˛

acy

class KlasaTest { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

const char

∗

const

Nazwa;

KlasaTest( const KlasaTest & Ob ): Nazwa(Ob. Nazwa)

{ cout

”++ Konstruktor kopiujacy: ”

Nazwa

endl; }

public :

void Metoda( KlasaTest Ob ) { cout

”... Metoda uruchomiona”

endl; }

KlasaTest( const char

∗

Nazwa ): Nazwa(Nazwa)

{ cout

”++ Konstruktor obiektu: ”

Nazwa

endl; }

∼

KlasaTest( ) { cout

”

−−

Destruktor obiektu: ”

Nazwa

endl; }

}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

int main( )
{

KlasaTest ObA(”A”);

hhh

((

(

ObA.Metoda(ObA)

;

}

Konstruktor kopiuj ˛

acy musi by´c dost ˛epny przed wywołaniem samej metody. Aby wi ˛ec mo˙zliwe było

jego wywołanie musi on by´c dost ˛epny na poziomie funkcji, z której wywoływana jest dana metoda.

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Przekazanie parametru przez referencj ˛e

class KlasaTest { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

const char

∗

const

Nazwa;

public :

void Metoda( KlasaTest & Ob ) { cout

”... Metoda uruchomiona”

endl; }

KlasaTest( const KlasaTest & Ob ): Nazwa(Ob. Nazwa)

{ cout

”++ Konstruktor kopiujacy: ”

Nazwa

endl; }

KlasaTest( const char

∗

Nazwa ): Nazwa(Nazwa)

{ cout

”++ Konstruktor obiektu: ”

Nazwa

endl; }

∼

KlasaTest( ) { cout

”

−−

Destruktor obiektu: ”

Nazwa

endl; }

}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

int main( )
{

cout

”main: 1”

endl;

KlasaTest ObA(”A”);

cout

”main: 2”

endl;

ObA.Metoda(ObA)

;

cout

”main: 3”

endl;

}

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Przekazanie parametru przez referencj ˛e

class KlasaTest { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

const char

∗

const

Nazwa;

public :

void Metoda( KlasaTest & Ob ) { cout

”... Metoda uruchomiona”

endl; }

KlasaTest( const KlasaTest & Ob ): Nazwa(Ob. Nazwa)

{ cout

”++ Konstruktor kopiujacy: ”

Nazwa

endl; }

KlasaTest( const char

∗

Nazwa ): Nazwa(Nazwa)

{ cout

”++ Konstruktor obiektu: ”

Nazwa

endl; }

∼

KlasaTest( ) { cout

”

−−

Destruktor obiektu: ”

Nazwa

endl; }

}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

int main( )
{

cout

”main: 1”

endl;

KlasaTest ObA(”A”);

cout

”main: 2”

endl;

ObA.Metoda(ObA)

;

cout

”main: 3”

endl;

}

Wynik działania:

main:

++ Konstruktor obiektu:

main:

...

Metoda uruchomiona

main:

−− Destruktor obiektu:

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Przekazanie parametru przez referencj ˛e

class KlasaTest { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

const char

∗

const

Nazwa;

public :

void Metoda( KlasaTest & Ob ) { cout

”... Metoda uruchomiona”

endl; }

KlasaTest( const KlasaTest & Ob ): Nazwa(Ob. Nazwa)

{ cout

”++ Konstruktor kopiujacy: ”

Nazwa

endl; }

KlasaTest( const char

∗

Nazwa ): Nazwa(Nazwa)

{ cout

”++ Konstruktor obiektu: ”

Nazwa

endl; }

∼

KlasaTest( ) { cout

”

−−

Destruktor obiektu: ”

Nazwa

endl; }

}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

int main( )
{

cout

”main: 1”

endl;

KlasaTest ObA(”A”);

cout

”main: 2”

endl;

ObA.Metoda(ObA)

;

cout

”main: 3”

endl;

}

Wynik działania:

main:

++ Konstruktor obiektu:

main:

...

Metoda uruchomiona

main:

−− Destruktor obiektu:

Przekazywanie parametru poprzez referencj ˛e podobnie jak przekazywanie go przez wska´znik, nie

powoduje uruchomienia operacji kopiowania, gdy˙z metoda/funkcja działa na “oryginalnej” zmiennej.

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Zwracanie obiektu przez warto ´s ´c

class KlasaTest { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

const char

∗

const

Nazwa;

public :

KlasaTest

Metoda( )

{ cout

”... Metoda uruchomiona”

endl;

return KlasaTest( ”X” ); }

KlasaTest( const KlasaTest & Ob ): Nazwa(Ob. Nazwa)

{ cout

”++ Konstruktor kopiujacy: ”

Nazwa

endl; }

// . . . . . . . . . . . . . . . . . . . .

KlasaTest( const char

∗

Nazwa ): Nazwa(Nazwa)

{ cout

”++ Konstruktor obiektu: ”

Nazwa

endl; }

// . . . . . . . . . . . . . . . . . . . . . .

∼

KlasaTest( )

{ cout

”

−−

Destruktor obiektu: ”

Nazwa

endl; }

// . . . . . . . . . . . . . . . . . . . . . . . .

}; //. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

int main( )
{

cout

”main: 1”

endl;

KlasaTest ObA(”A”);

cout

”main: 2”

endl;

ObA =

ObA.Metoda( )

;

cout

”main: 3”

endl;

}

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Zwracanie obiektu przez warto ´s ´c

class KlasaTest { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

const char

∗

const

Nazwa;

public :

KlasaTest

Metoda( )

{ cout

”... Metoda uruchomiona”

endl;

return KlasaTest( ”X” ); }

KlasaTest( const KlasaTest & Ob ): Nazwa(Ob. Nazwa)

{ cout

”++ Konstruktor kopiujacy: ”

Nazwa

endl; }

// . . . . . . . . . . . . . . . . . . . .

KlasaTest( const char

∗

Nazwa ): Nazwa(Nazwa)

{ cout

”++ Konstruktor obiektu: ”

Nazwa

endl; }

// . . . . . . . . . . . . . . . . . . . . . .

∼

KlasaTest( )

{ cout

”

−−

Destruktor obiektu: ”

Nazwa

endl; }

// . . . . . . . . . . . . . . . . . . . . . . . .

int main( )
{

cout

”main: 1”

endl;

KlasaTest ObA(”A”);

cout

”main: 2”

endl;

ObA =

ObA.Metoda( )

;

cout

”main: 3”

endl;

}

Wynik działania:

main:

++ Konstruktor obiektu:

main:

...

Metoda uruchomiona

++ Konstruktor obiektu:

−− Destruktor obiektu:

main:

−− Destruktor obiektu:

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Zwracanie obiektu przez warto ´s ´c

class KlasaTest { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

const char

∗

const

Nazwa;

public :

KlasaTest

Metoda( )

{ cout

”... Metoda uruchomiona”

endl;

return KlasaTest( ”X” ); }

KlasaTest( const KlasaTest & Ob ): Nazwa(Ob. Nazwa)

{ cout

”++ Konstruktor kopiujacy: ”

Nazwa

endl; }

// . . . . . . . . . . . . . . . . . . . .

KlasaTest( const char

∗

Nazwa ): Nazwa(Nazwa)

{ cout

”++ Konstruktor obiektu: ”

Nazwa

endl; }

// . . . . . . . . . . . . . . . . . . . . . .

∼

KlasaTest( )

{ cout

”

−−

Destruktor obiektu: ”

Nazwa

endl; }

// . . . . . . . . . . . . . . . . . . . . . . . .

int main( )
{

cout

”main: 1”

endl;

KlasaTest ObA(”A”);

cout

”main: 2”

endl;

ObA =

ObA.Metoda( )

;

cout

”main: 3”

endl;

}

Wynik działania:

main:

++ Konstruktor obiektu:

main:

...

Metoda uruchomiona

++ Konstruktor obiektu:

−− Destruktor obiektu:

main:

−− Destruktor obiektu:

Obiekt zwracany ma charakter obiektu tymczasowego, którego istnienie umo˙zliwia przekazanie da-

nych na ”zewn ˛

atrz” funkcji/metody. Po wykonaniu tego zadana jest unicestwiany.

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Operator przypisania

class KlasaTest { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

const char

∗

const

Nazwa;

public :

KlasaTest Metoda( ) { cout

”... Metoda uruchomiona”

endl;

return KlasaTest( ”X” ); }

KlasaTest & operator = ( constKlasaTest & Ob )

{ cout

”... Przypisanie: ”

Nazwa

” <

−

”

Ob. Nazwa

endl;

return

∗

this ; }

KlasaTest( const KlasaTest & Ob ):

Nazwa(Ob. Nazwa) { cout

”++ Konstruktor kopiujacy: ”

Nazwa

endl; }

KlasaTest( const char

∗

Nazwa ):

Nazwa(Nazwa) { cout

”++ Konstruktor obiektu: ”

Nazwa

endl; }

∼

KlasaTest( )

{ cout

”

−−

Destruktor obiektu: ”

Nazwa

endl; }

int main( )
{

cout

”main: 1”

endl;

KlasaTest ObA(”A”);

cout

”main: 2”

endl;

ObA = ObA.Metoda( )

;

cout

”main: 3”

endl;

}

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Operator przypisania

class KlasaTest { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

const char

∗

const

Nazwa;

public :

KlasaTest Metoda( ) { cout

”... Metoda uruchomiona”

endl;

return KlasaTest( ”X” ); }

KlasaTest & operator = ( constKlasaTest & Ob )

{ cout

”... Przypisanie: ”

Nazwa

” <

−

”

Ob. Nazwa

endl;

return

∗

this ; }

KlasaTest( const KlasaTest & Ob ):

Nazwa(Ob. Nazwa) { cout

”++ Konstruktor kopiujacy: ”

Nazwa

endl; }

KlasaTest( const char

∗

Nazwa ):

Nazwa(Nazwa) { cout

”++ Konstruktor obiektu: ”

Nazwa

endl; }

∼

KlasaTest( )

{ cout

”

−−

Destruktor obiektu: ”

Nazwa

endl; }

int main( )
{

cout

”main: 1”

endl;

KlasaTest ObA(”A”);

cout

”main: 2”

endl;

ObA = ObA.Metoda( )

;

cout

”main: 3”

endl;

}

Wynik działania:

main:

++ Konstruktor obiektu:

main:

...

Metoda uruchomiona

++ Konstruktor obiektu:

...

Przypisanie:

A <- X

−− Destruktor obiektu:

main:

−− Destruktor obiektu:

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Operator przypisania

class KlasaTest { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

const char

∗

const

Nazwa;

public :

KlasaTest Metoda( ) { cout

”... Metoda uruchomiona”

endl;

return KlasaTest( ”X” ); }

KlasaTest & operator = ( constKlasaTest & Ob )

{ cout

”... Przypisanie: ”

Nazwa

” <

−

”

Ob. Nazwa

endl;

return

∗

this ; }

KlasaTest( const KlasaTest & Ob ):

Nazwa(Ob. Nazwa) { cout

”++ Konstruktor kopiujacy: ”

Nazwa

endl; }

KlasaTest( const char

∗

Nazwa ):

Nazwa(Nazwa) { cout

”++ Konstruktor obiektu: ”

Nazwa

endl; }

∼

KlasaTest( )

{ cout

”

−−

Destruktor obiektu: ”

Nazwa

endl; }

int main( )
{

cout

”main: 1”

endl;

KlasaTest ObA(”A”);

cout

”main: 2”

endl;

ObA = ObA.Metoda( )

;

cout

”main: 3”

endl;

}

Wynik działania:

main:

++ Konstruktor obiektu:

main:

...

Metoda uruchomiona

++ Konstruktor obiektu:

...

Przypisanie:

A <- X

−− Destruktor obiektu:

main:

−− Destruktor obiektu:

Implementacja operatora przypisania ograniczaj ˛

aca zakres kopiowanych pól umo˙zliwiła w tym przy-

padku zachowanie “to˙zsamo´sci” obiektowi, który poddany jest operacji przypisania.

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Obiekt tymczasowy

class KlasaTest { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

const char

∗

const

Nazwa;

public :

KlasaTest Metoda( ) { cout

”... Metoda uruchomiona”

endl;

return KlasaTest( ”X” ); }

KlasaTest & operator = ( constKlasaTest & Ob )

{ cout

”... Przypisanie: ”

Nazwa

” <

−

”

Ob. Nazwa

endl;

return

∗

this ; }

KlasaTest( const KlasaTest & Ob ):

Nazwa(Ob. Nazwa) { cout

”++ Konstruktor kopiujacy: ”

Nazwa

endl; }

KlasaTest( const char

∗

Nazwa ):

Nazwa(Nazwa) { cout

”++ Konstruktor obiektu: ”

Nazwa

endl; }

∼

KlasaTest( )

{ cout

”

−−

Destruktor obiektu: ”

Nazwa

endl; }

int main( )
{

cout

”main: 1”

endl;

KlasaTest ObA(”A”);

cout

”main: 2”

endl;

ObA = ObA.Metoda( ), cout

”... cdn.”

endl

;

cout

”main: 3”

endl;

}

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Obiekt tymczasowy

class KlasaTest { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

const char

∗

const

Nazwa;

public :

KlasaTest Metoda( ) { cout

”... Metoda uruchomiona”

endl;

return KlasaTest( ”X” ); }

KlasaTest & operator = ( constKlasaTest & Ob )

{ cout

”... Przypisanie: ”

Nazwa

” <

−

”

Ob. Nazwa

endl;

return

∗

this ; }

KlasaTest( const KlasaTest & Ob ):

Nazwa(Ob. Nazwa) { cout

”++ Konstruktor kopiujacy: ”

Nazwa

endl; }

KlasaTest( const char

∗

Nazwa ):

Nazwa(Nazwa) { cout

”++ Konstruktor obiektu: ”

Nazwa

endl; }

∼

KlasaTest( )

{ cout

”

−−

Destruktor obiektu: ”

Nazwa

endl; }

int main( )
{

cout

”main: 1”

endl;

KlasaTest ObA(”A”);

cout

”main: 2”

endl;

ObA = ObA.Metoda( ), cout

”... cdn.”

endl

;

cout

”main: 3”

endl;

}

Wynik działania:

main:

++ Konstruktor obiektu:

main:

...

Metoda uruchomiona

++ Konstruktor obiektu:

...

Przypisanie:

A <- X

...

cdn.

−− Destruktor obiektu:

main:

−− Destruktor obiektu:

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Obiekt tymczasowy

class KlasaTest { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

const char

∗

const

Nazwa;

public :

KlasaTest Metoda( ) { cout

”... Metoda uruchomiona”

endl;

return KlasaTest( ”X” ); }

KlasaTest & operator = ( constKlasaTest & Ob )

{ cout

”... Przypisanie: ”

Nazwa

” <

−

”

Ob. Nazwa

endl;

return

∗

this ; }

KlasaTest( const KlasaTest & Ob ):

Nazwa(Ob. Nazwa) { cout

”++ Konstruktor kopiujacy: ”

Nazwa

endl; }

KlasaTest( const char

∗

Nazwa ):

Nazwa(Nazwa) { cout

”++ Konstruktor obiektu: ”

Nazwa

endl; }

∼

KlasaTest( )

{ cout

”

−−

Destruktor obiektu: ”

Nazwa

endl; }

int main( )
{

cout

”main: 1”

endl;

KlasaTest ObA(”A”);

cout

”main: 2”

endl;

ObA = ObA.Metoda( ), cout

”... cdn.”

endl

;

cout

”main: 3”

endl;

}

Wynik działania:

main:

++ Konstruktor obiektu:

main:

...

Metoda uruchomiona

++ Konstruktor obiektu:

...

Przypisanie:

A <- X

...

cdn.

−− Destruktor obiektu:

main:

−− Destruktor obiektu:

Znak ’;’ jest terminatorem wykonywanej operacji. Wyznacza on czas ˙zycia obiektów tymczasowych.

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Zwracanie obiektu przez warto ´s ´c

class KlasaTest { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

const char

∗

const

Nazwa;

public :

KlasaTest

Metoda( )

{ cout

”... Metoda uruchomiona”

endl;

return

∗

this ; }

KlasaTest & operator = ( constKlasaTest & Ob )

{ cout

”... Przypisanie: ”

Nazwa

” <

−

”

Ob. Nazwa

endl;

return

∗

this ; }

KlasaTest( const KlasaTest & Ob ):

Nazwa(Ob. Nazwa) { cout

”++ Konstruktor kopiujacy: ”

Nazwa

endl; }

KlasaTest( const char

∗

Nazwa ):

Nazwa(Nazwa) { cout

”++ Konstruktor obiektu: ”

Nazwa

endl; }

∼

KlasaTest( )

{ cout

”

−−

Destruktor obiektu: ”

Nazwa

endl; }

int main( )
{

cout

”main: 1”

endl;

KlasaTest ObA(”A”);

cout

”main: 2”

endl;

ObA = ObA.Metoda( ), cout

”... cdn.”

endl

;

cout

”main: 3”

endl;

}

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Zwracanie obiektu przez warto ´s ´c

class KlasaTest { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

const char

∗

const

Nazwa;

public :

KlasaTest

Metoda( )

{ cout

”... Metoda uruchomiona”

endl;

return

∗

this ; }

KlasaTest & operator = ( constKlasaTest & Ob )

{ cout

”... Przypisanie: ”

Nazwa

” <

−

”

Ob. Nazwa

endl;

return

∗

this ; }

KlasaTest( const KlasaTest & Ob ):

Nazwa(Ob. Nazwa) { cout

”++ Konstruktor kopiujacy: ”

Nazwa

endl; }

KlasaTest( const char

∗

Nazwa ):

Nazwa(Nazwa) { cout

”++ Konstruktor obiektu: ”

Nazwa

endl; }

∼

KlasaTest( )

{ cout

”

−−

Destruktor obiektu: ”

Nazwa

endl; }

int main( )
{

cout

”main: 1”

endl;

KlasaTest ObA(”A”);

cout

”main: 2”

endl;

ObA = ObA.Metoda( ), cout

”... cdn.”

endl

;

cout

”main: 3”

endl;

}

Wynik działania:

main:

++ Konstruktor obiektu:

main:

...

Metoda uruchomiona

++ Konstruktor kopiujacy:

...

Przypisanie:

A <- A

...

cdn.

−− Destruktor obiektu:

main:

−− Destruktor obiektu:

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Zwracanie obiektu przez warto ´s ´c

class KlasaTest { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

const char

∗

const

Nazwa;

public :

KlasaTest

Metoda( )

{ cout

”... Metoda uruchomiona”

endl;

return

∗

this ; }

KlasaTest & operator = ( constKlasaTest & Ob )

{ cout

”... Przypisanie: ”

Nazwa

” <

−

”

Ob. Nazwa

endl;

return

∗

this ; }

KlasaTest( const KlasaTest & Ob ):

Nazwa(Ob. Nazwa) { cout

”++ Konstruktor kopiujacy: ”

Nazwa

endl; }

KlasaTest( const char

∗

Nazwa ):

Nazwa(Nazwa) { cout

”++ Konstruktor obiektu: ”

Nazwa

endl; }

∼

KlasaTest( )

{ cout

”

−−

Destruktor obiektu: ”

Nazwa

endl; }

int main( )
{

cout

”main: 1”

endl;

KlasaTest ObA(”A”);

cout

”main: 2”

endl;

ObA = ObA.Metoda( ), cout

”... cdn.”

endl

;

cout

”main: 3”

endl;

}

Wynik działania:

main:

++ Konstruktor obiektu:

main:

...

Metoda uruchomiona

++ Konstruktor kopiujacy:

...

Przypisanie:

A <- A

...

cdn.

−− Destruktor obiektu:

main:

−− Destruktor obiektu:

Zwrócenie przez warto´s´c ”samego siebie” powoduje uruchomienie konstruktora kopiuj ˛

acego.

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Zwracanie obiektu przez referencj ˛e

class KlasaTest { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

const char

∗

const

Nazwa;

public :

KlasaTest &

Metoda( )

{ cout

”... Metoda uruchomiona”

endl;

return

∗

this ; }

KlasaTest & operator = ( constKlasaTest & Ob )

{ cout

”... Przypisanie: ”

Nazwa

” <

−

”

Ob. Nazwa

endl;

return

∗

this ; }

KlasaTest( const KlasaTest & Ob ):

Nazwa(Ob. Nazwa) { cout

”++ Konstruktor kopiujacy: ”

Nazwa

endl; }

KlasaTest( const char

∗

Nazwa ):

Nazwa(Nazwa) { cout

”++ Konstruktor obiektu: ”

Nazwa

endl; }

∼

KlasaTest( )

{ cout

”

−−

Destruktor obiektu: ”

Nazwa

endl; }

int main( )
{

cout

”main: 1”

endl;

KlasaTest ObA(”A”);

cout

”main: 2”

endl;

ObA = ObA.Metoda( ), cout

”... cdn.”

endl

;

cout

”main: 3”

endl;

}

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Zwracanie obiektu przez referencj ˛e

class KlasaTest { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

const char

∗

const

Nazwa;

public :

KlasaTest &

Metoda( )

{ cout

”... Metoda uruchomiona”

endl;

return

∗

this ; }

KlasaTest & operator = ( constKlasaTest & Ob )

{ cout

”... Przypisanie: ”

Nazwa

” <

−

”

Ob. Nazwa

endl;

return

∗

this ; }

KlasaTest( const KlasaTest & Ob ):

Nazwa(Ob. Nazwa) { cout

”++ Konstruktor kopiujacy: ”

Nazwa

endl; }

KlasaTest( const char

∗

Nazwa ):

Nazwa(Nazwa) { cout

”++ Konstruktor obiektu: ”

Nazwa

endl; }

∼

KlasaTest( )

{ cout

”

−−

Destruktor obiektu: ”

Nazwa

endl; }

int main( )
{

cout

”main: 1”

endl;

KlasaTest ObA(”A”);

cout

”main: 2”

endl;

ObA = ObA.Metoda( ), cout

”... cdn.”

endl

;

cout

”main: 3”

endl;

}

Wynik działania:

main:

++ Konstruktor obiektu:

main:

...

Metoda uruchomiona

...

Przypisanie:

A <- A

...

cdn.

main:

−− Destruktor obiektu:

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Zwracanie obiektu przez referencj ˛e

class KlasaTest { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

const char

∗

const

Nazwa;

public :

KlasaTest &

Metoda( )

{ cout

”... Metoda uruchomiona”

endl;

return

∗

this ; }

KlasaTest & operator = ( constKlasaTest & Ob )

{ cout

”... Przypisanie: ”

Nazwa

” <

−

”

Ob. Nazwa

endl;

return

∗

this ; }

KlasaTest( const KlasaTest & Ob ):

Nazwa(Ob. Nazwa) { cout

”++ Konstruktor kopiujacy: ”

Nazwa

endl; }

KlasaTest( const char

∗

Nazwa ):

Nazwa(Nazwa) { cout

”++ Konstruktor obiektu: ”

Nazwa

endl; }

∼

KlasaTest( )

{ cout

”

−−

Destruktor obiektu: ”

Nazwa

endl; }

int main( )
{

cout

”main: 1”

endl;

KlasaTest ObA(”A”);

cout

”main: 2”

endl;

ObA = ObA.Metoda( ), cout

”... cdn.”

endl

;

cout

”main: 3”

endl;

}

Wynik działania:

main:

++ Konstruktor obiektu:

main:

...

Metoda uruchomiona

...

Przypisanie:

A <- A

...

cdn.

main:

−− Destruktor obiektu:

Przekazanie obiektu przez referencj ˛e nie wymaga wykonania operacji kopiowania.

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Czas ˙zycia obiektów tymczasowych

class KlasaTest { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

const char

∗

const

Nazwa;

public :

KlasaTest

Metoda

(

KlasaTest Ob) { cout

”... Metoda”

endl;

return KlasaTest( ”X” ); }

KlasaTest & operator = ( constKlasaTest & Ob )

{ cout

”... Przypisanie: ”

Nazwa

” <

−

”

Ob. Nazwa

endl;

return

∗

this ; }

KlasaTest( const KlasaTest & Ob ):

Nazwa(Ob. Nazwa) { cout

”++ Konstruktor kopiujacy: ”

Nazwa

endl; }

KlasaTest( const char

∗

Nazwa ):

Nazwa(Nazwa) { cout

”++ Konstruktor obiektu: ”

Nazwa

endl; }

∼

KlasaTest( )

{ cout

”

−−

Destruktor obiektu: ”

Nazwa

endl; }

int main( )
{

cout

”main: 1”

endl;

KlasaTest ObA(”A”);

cout

”main: 2”

endl;

ObA = ObA.Metoda(ObA), cout

”... cdn.

n”

;

cout

”main: 3”

endl;

}

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Czas ˙zycia obiektów tymczasowych

class KlasaTest { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

const char

∗

const

Nazwa;

public :

KlasaTest

Metoda

(

KlasaTest Ob) { cout

”... Metoda”

endl;

return KlasaTest( ”X” ); }

KlasaTest & operator = ( constKlasaTest & Ob )

{ cout

”... Przypisanie: ”

Nazwa

” <

−

”

Ob. Nazwa

endl;

return

∗

this ; }

KlasaTest( const KlasaTest & Ob ):

Nazwa(Ob. Nazwa) { cout

”++ Konstruktor kopiujacy: ”

Nazwa

endl; }

KlasaTest( const char

∗

Nazwa ):

Nazwa(Nazwa) { cout

”++ Konstruktor obiektu: ”

Nazwa

endl; }

∼

KlasaTest( )

{ cout

”

−−

Destruktor obiektu: ”

Nazwa

endl; }

int main( )
{

cout

”main: 1”

endl;

KlasaTest ObA(”A”);

cout

”main: 2”

endl;

ObA = ObA.Metoda(ObA), cout

”... cdn.

n”

;

cout

”main: 3”

endl;

}

Wynik działania:

main:

++ Konstruktor obiektu:

main:

++ Konstruktor kopiujacy:

...

Metoda

++ Konstruktor obiektu:

...

Przypisanie:

A <- X

...

cdn.

−− Destruktor obiektu:

main:

−− Destruktor obiektu:

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Czas ˙zycia obiektów tymczasowych

class KlasaTest { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

const char

∗

const

Nazwa;

public :

KlasaTest

Metoda

(

KlasaTest Ob) { cout

”... Metoda”

endl;

return KlasaTest( ”X” ); }

KlasaTest & operator = ( constKlasaTest & Ob )

{ cout

”... Przypisanie: ”

Nazwa

” <

−

”

Ob. Nazwa

endl;

return

∗

this ; }

KlasaTest( const KlasaTest & Ob ):

Nazwa(Ob. Nazwa) { cout

”++ Konstruktor kopiujacy: ”

Nazwa

endl; }

KlasaTest( const char

∗

Nazwa ):

Nazwa(Nazwa) { cout

”++ Konstruktor obiektu: ”

Nazwa

endl; }

∼

KlasaTest( )

{ cout

”

−−

Destruktor obiektu: ”

Nazwa

endl; }

int main( )
{

cout

”main: 1”

endl;

KlasaTest ObA(”A”);

cout

”main: 2”

endl;

ObA = ObA.Metoda(ObA), cout

”... cdn.

n”

;

cout

”main: 3”

endl;

}

Wynik działania:

main:

++ Konstruktor obiektu:

main:

++ Konstruktor kopiujacy:

...

Metoda

++ Konstruktor obiektu:

...

Przypisanie:

A <- X

...

cdn.

−− Destruktor obiektu:

main:

−− Destruktor obiektu:

Zako ´nczenie operacji wyznaczone wyst ˛

apieniem znaku ’;’ wy-

znacza czas ˙zycia obiektów tymczasowych.

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Czas ˙zycia obiektów tymczasowych

int main( )
{

NazWektor W a(”a”, 1, 2), W b(”b”, 1, 1), W c(”c”, 1, 0), W d(”d”, 2, 2), W r(”r”);

cout

”—- Poczatek operacji dodawania —————–”

endl;

W r = (W a + W b) + (W c + W d)

;

cout

”—- Koniec operacji dodawania ——————-”

endl;

cout

”—- Rezultat: ”

W r

endl;

}

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Czas ˙zycia obiektów tymczasowych

int main( )
{

NazWektor W a(”a”, 1, 2), W b(”b”, 1, 1), W c(”c”, 1, 0), W d(”d”, 2, 2), W r(”r”);

cout

”—- Poczatek operacji dodawania —————–”

endl;

W r = (W a + W b) + (W c + W d)

;

cout

”—- Koniec operacji dodawania ——————-”

endl;

cout

”—- Rezultat: ”

W r

endl;

}

Wykonywaniu poszczególnych operacji towarzyszy tworzenie si ˛e obiektów tymczasowych. Chc ˛

prze´sledzi´c ten proces, nale˙zy przeci ˛

a˙zy´c odpowiednie konstruktory. Przeci ˛

a˙zenia te musz ˛

a zapew-

nia´c mo˙zliwo´s´c nazwania obiektów, tak aby mo˙zna było prze´sledzi´c okres ˙zycia poszczególnych

obiektów.

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Czas ˙zycia obiektów tymczasowych

class NazWektor { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

static char

ZnakCyfry;

public :

string

Nazwa;

float

x, y;

NazWektor(const char

∗

Nazwa,

float x = 0, float y = 0 );

NazWektor( const NazWektor & W );

∼

NazWektor( );

NazWektor

operator + ( const NazWektor & W ) const;

NazWektor & operator = ( const NazWektor & W );

}; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

char NazWektor:: ZnakCyfry = ’0’;

ostream & operator

(

ostream & ostrm, const NazWektor & W )

{

return ostrm

W. Nazwa

”(”

W. x

”, ”

W. y

”)”;

}

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Czas ˙zycia obiektów tymczasowych

class NazWektor { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

static char

ZnakCyfry;

public :

string

Nazwa;

float

x, y;

NazWektor(const char

∗

Nazwa,

float x = 0, float y = 0 );

NazWektor( const NazWektor & W );

∼

NazWektor( );

NazWektor

operator + ( const NazWektor & W ) const;

NazWektor & operator = ( const NazWektor & W );

}; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

char NazWektor:: ZnakCyfry = ’0’;

ostream & operator

(

ostream & ostrm, const NazWektor & W )

{

return ostrm

W. Nazwa

”(”

W. x

”, ”

W. y

”)”;

}

int main( )
{

NazWektor W( ”a” , 1, 2 );

cout

endl;

}

Wynik działania:

a(1, 2)

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Czas ˙zycia obiektów tymczasowych

class NazWektor { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

static char

ZnakCyfry;

public :

string

Nazwa;

float

x, y;

NazWektor(const char

∗

Nazwa,

float x = 0, float y = 0 );

NazWektor( const NazWektor & W );

∼

NazWektor( );

NazWektor

operator + ( const NazWektor & W ) const;

NazWektor & operator = ( const NazWektor & W );

}; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

char NazWektor:: ZnakCyfry = ’0’;

ostream & operator

(

ostream & ostrm, const NazWektor & W )

{

return ostrm

W. Nazwa

”(”

W. x

”, ”

W. y

”)”;

}

int main( )
{

NazWektor W( ”a” , 1, 2 );

cout

endl;

}

Wynik działania:

a(1, 2)

Wprowadzenie dodatkowego pola statycznego pozwala numerowa´c tworz ˛

ace si ˛e tymczasowe

obiekty. Za´s pole

Nazwa

pozwala nazywa´c ka˙zdy z obiektów.

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Definicje konstruktora i destruktora

class NazWektor { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

static char

ZnakCyfry;

public :

string

Nazwa;

float

x, y;

NazWektor(const char

∗

Nazwa,

float x = 0, float y = 0 )

;

. . .

∼

NazWektor( )

;

. . .

}; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

NazWektor::NazWektor( const char

∗

Nazwa,

float x, float y ): Nazwa(Nazwa)

{

x = x;

y = y; cout

”++ Konstruktor: ”

<< ∗

this

endl;

}

NazWektor::

∼

NazWektor( )

{

cout

”++ Destruktor: ”

<< ∗

this

endl;

}

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Definicje konstruktora i destruktora

class NazWektor { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

static char

ZnakCyfry;

public :

string

Nazwa;

float

x, y;

NazWektor(const char

∗

Nazwa,

float x = 0, float y = 0 )

;

. . .

∼

NazWektor( )

;

. . .

}; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

NazWektor::NazWektor( const char

∗

Nazwa,

float x, float y ): Nazwa(Nazwa)

{

x = x;

y = y; cout

”++ Konstruktor: ”

<< ∗

this

endl;

}

NazWektor::

∼

NazWektor( )

{

cout

”++ Destruktor: ”

<< ∗

this

endl;

}

int main( )
{

NazWektor W( ”a” , 1, 2 );

}

Wynik działania:

++ Konstruktor:

a(1, 2)

−− Destruktor:

a(1, 2)

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Definicje konstruktora i destruktora

class NazWektor { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

static char

ZnakCyfry;

public :

string

Nazwa;

float

x, y;

NazWektor(const char

∗

Nazwa,

float x = 0, float y = 0 )

;

. . .

∼

NazWektor( )

;

. . .

}; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

NazWektor::NazWektor( const char

∗

Nazwa,

float x, float y ): Nazwa(Nazwa)

{

x = x;

y = y; cout

”++ Konstruktor: ”

<< ∗

this

endl;

}

NazWektor::

∼

NazWektor( )

{

cout

”++ Destruktor: ”

<< ∗

this

endl;

}

int main( )
{

NazWektor W( ”a” , 1, 2 );

}

Wynik działania:

++ Konstruktor:

a(1, 2)

−− Destruktor:

a(1, 2)

Wywołanie konstruktora lub destruktora jest sygnalizowane odpowiednim komunikatem na wyj´sciu

standardowym. Podaje on nazw ˛e i warto´sci pól obiektu.

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Konstruktor kopiuj ˛

acy

class NazWektor { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

static char

ZnakCyfry;

public :

string

Nazwa;

float

x, y;

. . .

NazWektor( const NazWektor & W )

;

. . .

}; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

NazWektor::NazWektor( const NazWektor & W ):

Nazwa(”Tmp”)

{

Nazwa += ++ ZnakCyfry;

x = y = 0;

cout

”.. Kopiuje: ”

<< ∗

this

”

endl;

x = W. x;

y = W. y;

}

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Konstruktor kopiuj ˛

acy

class NazWektor { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

static char

ZnakCyfry;

public :

string

Nazwa;

float

x, y;

. . .

NazWektor( const NazWektor & W )

;

. . .

}; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

NazWektor::NazWektor( const NazWektor & W ):

Nazwa(”Tmp”)

{

Nazwa += ++ ZnakCyfry;

x = y = 0;

cout

”.. Kopiuje: ”

<< ∗

this

”

endl;

x = W. x;

y = W. y;

}

int main( )
{

NazWektor W( ”a” , 1, 2 );

NazWektor V(W)

;

}

Wynik działania:

++ Konstruktor:

a(1, 2)

++ Kopiuje:

Tmp1(0,0) <- a(1, 2)

−− Destruktor:

Tmp1(1, 2)

−− Destruktor:

a(1, 2)

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Konstruktor kopiuj ˛

acy

class NazWektor { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

static char

ZnakCyfry;

public :

string

Nazwa;

float

x, y;

. . .

NazWektor( const NazWektor & W )

;

. . .

}; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

NazWektor::NazWektor( const NazWektor & W ):

Nazwa(”Tmp”)

{

Nazwa += ++ ZnakCyfry;

x = y = 0;

cout

”.. Kopiuje: ”

<< ∗

this

”

endl;

x = W. x;

y = W. y;

}

int main( )
{

NazWektor W( ”a” , 1, 2 );

NazWektor V(W)

;

}

Wynik działania:

++ Konstruktor:

a(1, 2)

++ Kopiuje:

Tmp1(0,0) <- a(1, 2)

−− Destruktor:

Tmp1(1, 2)

−− Destruktor:

a(1, 2)

Konstruktor kopiuj ˛

acy w tym rozwi ˛

azaniu nie powoduje przepisanie nazwy obiektu. Jest to nie-

zb ˛edne, aby móc zidentyfikowa´c nowy obiekt. Jego nazwa tworzona jest automatycznie.

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Operator dodawania

class NazWektor { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

static char

ZnakCyfry;

public :

string

Nazwa;

float

x, y;

. . .

NazWektor operator + ( const NazWektor& W ) const

;

. . .

}; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

NazWektor NazWektor::operator + ( const NazWektor& W ) const
{

cout

”.. Dodanie: ”

<< ∗

this

” + ”

endl;

string Nazwa( ”Tmp” );

Nazwa += ++ ZnakCyfry;

return NazWektor( Nazwa.c str(), x+W. x, y+W. y );

}

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Operator dodawania

class NazWektor { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

static char

ZnakCyfry;

public :

string

Nazwa;

float

x, y;

. . .

NazWektor operator + ( const NazWektor& W ) const

;

. . .

}; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

NazWektor NazWektor::operator + ( const NazWektor& W ) const
{

cout

”.. Dodanie: ”

<< ∗

this

” + ”

endl;

string Nazwa( ”Tmp” );

Nazwa += ++ ZnakCyfry;

return NazWektor( Nazwa.c str(), x+W. x, y+W. y );

}

int main( )
{

NazWektor W( ”a” , 1, 2 );

W = W + W

;

}

Wynik działania:

++ Konstruktor:

a(1, 2)

.. Dodanie:

a(1, 2) + a(1,2)

++ Konstruktor:

Tmp1(2, 4)

−− Destruktor:

Tmp1(2, 4)

−− Destruktor:

a(1, 2)

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Operator dodawania

class NazWektor { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

static char

ZnakCyfry;

public :

string

Nazwa;

float

x, y;

. . .

NazWektor operator + ( const NazWektor& W ) const

;

. . .

}; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

NazWektor NazWektor::operator + ( const NazWektor& W ) const
{

cout

”.. Dodanie: ”

<< ∗

this

” + ”

endl;

string Nazwa( ”Tmp” );

Nazwa += ++ ZnakCyfry;

return NazWektor( Nazwa.c str(), x+W. x, y+W. y );

}

int main( )
{

NazWektor W( ”a” , 1, 2 );

W = W + W

;

}

Wynik działania:

++ Konstruktor:

a(1, 2)

.. Dodanie:

a(1, 2) + a(1,2)

++ Konstruktor:

Tmp1(2, 4)

−− Destruktor:

Tmp1(2, 4)

−− Destruktor:

a(1, 2)

W trakcie realizacji operacji dodawania tworzony jest obiekt tymczasowy, który przekazuje ”na ze-

wn ˛

atrz” wynik działania.

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Operator przypisania

class NazWektor { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

static char

ZnakCyfry;

public :

string

Nazwa;

float

x, y;

. . .

NazWektor & operator = ( const NazWektor & W )

;

. . .

}; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

NazWektor & NazWektor::operator = ( const NazWektor & W )
{

cout

”.. Podstawienie: ”

<< ∗

this

” = ”

endl;

x = W. x;

y = W. y;

return

∗

this ;

}

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Operator przypisania

class NazWektor { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

static char

ZnakCyfry;

public :

string

Nazwa;

float

x, y;

. . .

NazWektor & operator = ( const NazWektor & W )

;

. . .

}; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

NazWektor & NazWektor::operator = ( const NazWektor & W )
{

cout

”.. Podstawienie: ”

<< ∗

this

” = ”

endl;

x = W. x;

y = W. y;

return

∗

this ;

}

int main( )
{

NazWektor W( ”a” , 1, 2 );

W = W

;

}

Wynik działania:

++ Konstruktor:

a(1, 2)

.. Podstawienie:

a(1, 2) = a(1,2)

−− Destruktor:

a(1, 2)

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Operator przypisania

class NazWektor { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

static char

ZnakCyfry;

public :

string

Nazwa;

float

x, y;

. . .

NazWektor & operator = ( const NazWektor & W )

;

. . .

}; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

NazWektor & NazWektor::operator = ( const NazWektor & W )
{

cout

”.. Podstawienie: ”

<< ∗

this

” = ”

endl;

x = W. x;

y = W. y;

return

∗

this ;

}

int main( )
{

NazWektor W( ”a” , 1, 2 );

W = W

;

}

Wynik działania:

++ Konstruktor:

a(1, 2)

.. Podstawienie:

a(1, 2) = a(1,2)

−− Destruktor:

a(1, 2)

Realizacja operacji podstawienia nie wymaga tworzenia ˙zadnych obiektów tymczasowych. Zarówno

argument, jak te˙z wynik działania, zwracane s ˛

a przez referencje.

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

W r = (W a + W b) + (W c + W d)

class NazWektor { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

static char

ZnakCyfry;

public :

string

Nazwa;

float

x, y;

NazWektor(const char

∗

Nazwa,

float x = 0, float y = 0);

NazWektor( const NazWektor & W );

∼

NazWektor( );

NazWektor

operator + ( const NazWektor & W ) const;

NazWektor & operator = ( const NazWektor & W );

}; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . .

int main()
{

NazWektor Wa(”a”,1,2), Wb(”b”,1,1), Wc(”c”,1,0), Wd(”d”,2,2);

NazWektor Wr(”r”);
cout

”— Poczatek operacji dodawania ——-”

endl;

Wr = (Wa + Wb) + (Wc + Wd)

;

cout

”— Koniec operacji dodawania ———-”

endl;

cout

”— Rezultat: ”

endl;

}

Wynik działania:

++ Konstruktor: a(1, 2)

++ Konstruktor: b(1, 1)

++ Konstruktor: c(1, 0)

++ Konstruktor: d(2, 2)

++ Konstruktor: r(0, 0)

— Poczatek operacji dodawania ———-
.. Dodanie: c(1, 0) + d(2, 2)
++ Konstruktor: Tmp1(3, 2)
.. Dodanie: a(1, 2) + b(1, 1)
++ Konstruktor: Tmp2(2, 3)
.. Dodanie: Tmp2(2, 3) + Tmp1(3, 2)
++ Konstruktor: Tmp3(5, 5)
.. Podstawienie: r(0, 0) = Tmp3(5, 5)
++ Destruktor: Tmp3(5, 5)
++ Destruktor: Tmp2(2, 3)
++ Destruktor: Tmp1(3, 2)
— Koniec operacji dodawania ————
— Rezultat: r(5, 5)

++ Destruktor: r(5, 5)

++ Destruktor: d(2, 2)

++ Destruktor: c(1, 0)

++ Destruktor: b(1, 1)

++ Destruktor: a(1, 2)

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

W r = (W a + W b) + (W c + W d)

. . .

— Poczatek operacji dodawania ———-

.. Dodanie: c(1, 0) + d(2, 2)

++ Konstruktor: Tmp1(3, 2)

.. Dodanie: a(1, 2) + b(1, 1)

++ Konstruktor: Tmp2(2, 3)

.. Dodanie: Tmp2(2, 3) + Tmp1(3, 2)

++ Konstruktor: Tmp3(5, 5)

.. Podstawienie: r(0, 0) = Tmp3(5, 5)

++ Destruktor: Tmp3(5, 5)

++ Destruktor: Tmp2(2, 3)

++ Destruktor: Tmp1(3, 2)

— Koniec operacji dodawania ————

— Rezultat: r(5, 5)

. . .

W r = (W a + W b) + (

W c + W d);

⇓

W r = (W a + W b) +

Tmp1

;

W r = (

W a + W b) +

Tmp1

;

⇓

W r =

Tmp2

Tmp1

;

W r =

Tmp2

Tmp1

;

⇓

W r =

Tmp3

;

W r =

Tmp3

;

W r

−→

;

W trakcie realizacji całej operacji tworz ˛

a si ˛e obiekty po´srednie, które przekazuj ˛

a wyniki cz ˛e´sciowe.

Wszystkie one ko ´ncz ˛

a swoje istnienie wraz z zako ´nczeniem realizacji danej operacji, tzn. wtedy gdy

sterowanie ”przekroczy” znak ´srednika.

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Zapobieganie tworzeniu obiektów tymczasowych

class Wektor3f { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

public :

float

x, y;

NazWektor3f operator + ( Wektor3f W ) const { return W +=

∗

this ; }

Wektor3f & operator += ( const Wektor3f & W ) { x += W. x;

y = W. y;

return

∗

this ; }

}; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Zapobieganie tworzeniu obiektów tymczasowych

class Wektor3f { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

public :

float

x, y;

NazWektor3f operator + ( Wektor3f W ) const { return W +=

∗

this ; }

Wektor3f & operator += ( const Wektor3f & W ) { x += W. x;

y = W. y;

return

∗

this ; }

Wektor3f

W1, W2, W3;

W1 = W2 + W3;

=⇒

(W1 = W2) += W3;

Ilo´s´c obiektów tymczasowych: 2

Ilo´s´c obiektów tymczasowych: 0

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Zapobieganie tworzeniu obiektów tymczasowych

class Wektor3f { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

public :

float

x, y;

NazWektor3f operator + ( Wektor3f W ) const { return W +=

∗

this ; }

Wektor3f & operator += ( const Wektor3f & W ) { x += W. x;

y = W. y;

return

∗

this ; }

Wektor3f

W1, W2, W3;

W1 = W2 + W3;

=⇒

(W1 = W2) += W3;

Ilo´s´c obiektów tymczasowych: 2

Ilo´s´c obiektów tymczasowych: 0

Stosuj ˛

ac bardziej przemy´slany zapis operacji arytmetycznych mo˙zna całkowicie wyeliminowa´c two-

rzenie si ˛e obiektów tymczasowych.

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Podsumowanie

Przy stosowaniu przeci ˛

a˙ze ´n operatorów zapis zło˙zonych działa ´n zazwy-

czaj wi ˛

a˙ze si ˛e z powstawaniem obiektów tymczasowych.

Ich liczb ˛e

mo˙zna prawie zawsze ograniczy´c lub całkowicie je wyeliminowa´c. Po-
woduje to jednak utrat ˛e czytelno´sci zapisu takiego działania.

W przypadku gdy wymagania czasowe nie s ˛

a krytyczne wła´sciwym mo˙ze

by´c zachowanie przejrzysto´sci zapisu kosztem efektywno´sci wykonywa-
nych operacji. Takie podej´scie jest szczególnie pomocne w pocz ˛

atkowej

fazie tworzenia oprogramowania, gdy˙z zapobiega powstawaniu przypad-
kowych bł ˛edów w implementowanych wzorach.

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Pytania i ´cwiczenia

1. Je˙zeli byłaby mo˙zliwa nast ˛epuj ˛

aca definicja konstruktora kopiuj ˛

acego kopiuj ˛

acego:

class Klasa {

public:

Klasa( Klasa Ob ) { }

};

to jakie byłyby konsekwencje w momencie jego u˙zycia.

2. Zakładaj ˛

ac, ˙ze klasa

Wektor3f jest tak samo zdefiniowana jak w prezentowanym

wcze´sniej przykładzie, nale˙zy wyznaczy´c liczb ˛e powstaj ˛

acych obiektów tymczaso-

wych dla wyra˙zenia:

Wr = Wa + Wb + Wc + Wd;

Zakres wa˙zno´sci, przekazywanie obiektów, obiekty tymczasowe

Document Outline

Strona tytulowa
Obszar waznosci zmiennych
Przezkazywanie parametrow
Zwracanie obiektow
- Przez wartosc
  - Obiekt tymczasowy
- Przez referencje
Istnienie obiektow tymczasowych
Podsumowanie
Pytania i cwiczenia

Wyszukiwarka

Podobne podstrony:
08 Obowiązki pracowników szkoły w zakresie pracy z uczniem z ADHD
zadanie-z-zakresu-prawa-administracyjnego-na-egzamin-radcowski-31.08.2012-r , EGZAMIN RADCOWSKI - py
34 08" 1 WYKLAD Z ZAKRESU KOMUNIKACJI INTERPERSONALNEJ DLA STUDENTOW STUDIOW ZAOCZNYCH P2
Prez 10 08 00 ppt
Prez 11 08 00
Zakres egzaminu FP WSZOP 2007-08, inż. BHP, V semestr
zadanie-z-zakresu-prawa-gospodarczego-na-egzamin-radcowski-31.08.2012-r , EGZAMIN RADCOWSKI - pytani
Prez 01 08 00
Zakres egzamin WMII lato 08
rozporządzenie 16.08.2007 szczegółowy zakres zad i org policji sądowej, WSPOL, I rok semestr II, Pra
zadanie-z-zakresu-prawa-karnego-na-egzamin-radcowski-29.08.2012-r , EGZAMIN RADCOWSKI - pytania, odp
Prez 25 08 00
Prez 13 08 00
08 konstruktor kopiujacy prez
Prez 17 08 00
08 Obowiązki pracowników szkoły w zakresie pracy z uczniem z ADHD

więcej podobnych podstron

08 zakres prez

Document Outline