[C++] Różne obszary pamięci po operacji przypisania


(luki1992) #1

Witam serdecznie, mam problem z jednym poleceniem w ćwiczeniu z C++, mianowicie pytanie jest takie:

"Co należy dodać do definicji klasy, aby obiekty posiadały różne obszary pamięci po

wykonaniu operacji przypisania?"

No i myślałem nad tym chwilę, ale niestety nic nie wymyśliłem. Wpadłem na pomysł, że coś tu trzeba zrobić z tym konstruktorem albo jakoś go wywołać no ale niestety nie wiem jak do końca. Bardzo o proszę o pomoc. Oto kody:

Plik **.cpp:

#include 

using namespace std;

#include "lab8_pr2.h"



WEKTOR::WEKTOR (int wym, int *a)

{

	wymiar = wym;

	tab= new int[wymiar];

 	for(int i=0; i
 	WEKTOR();

 	cout << "WEKTOR #1"<< endl;

}


/ ********************************************************************************* /


WEKTOR::WEKTOR()

{

	wymiar = 0;

	tab=NULL; 

    cout << "WEKTOR #2"<< endl;


}


/ ********************************************************************************* /


WEKTOR::~WEKTOR ()

{

    if( tab != NULL)

        delete [] tab;

    cout << "~WEKTOR" << endl;

}


/ ********************************************************************************** /


void WEKTOR::ustaw(int *tab)

{

	for(int i=0; i< this->wymiar; ++i)

        {

		this->tab[i]= tab[i];

        }               

 }

/ ********************************************************************************* /


void WEKTOR::wypisz()

{

	cout << "Wspolrzedne wektora to: ";

	for(int i=0; i < this->wymiar; ++i) 

	{

		cout << this->tab[i] << " ";

	}

 	cout << endl;

}


/ ********************************************************************************* /

void WEKTOR::wypisz_ws_tab()

{

	cout << "wskaznik do tablicy tab = " << this->tab << endl;

}


/ ********************************************************************************* /

main()

{


	int wymiar, stala,i;

	cout << "Podaj wymiar :";

	cin >> wymiar;  

    int *tablica = new int[wymiar];

    for(i=0; i
    {

        cout << "podaj " << i+1 << " wspolrzedna: " ;

        cin >> tablica[i];

    }    


    cout << endl << "Podaj stala :";      

	cin >> stala;    

	WEKTOR w1(wymiar, tablica);

    cout << " w1 = " ;

	w1.wypisz();  

	w1.wypisz_ws_tab();


	WEKTOR w2=w1; //tu wywolywany jest konstruktor kopiujący

    cout << " w2 = ";

    w2.wypisz();

    w2.wypisz_ws_tab();


    WEKTOR *w3=new WEKTOR;

    w3->wypisz_ws_tab();

	*w3=w1; //wywoływany operator przypisania

    cout << " w3 = ";

	w3->wypisz();

    w3->wypisz_ws_tab();


    for(i=0; i
    {

             tablica[i]*=stala;

    }  


    w1.ustaw(tablica);

    cout << "Wartosci wsp. wektorow po zmianie wartości wektora w1" << endl;

    cout <<" w1 = ";

    w1.wypisz(); //wypisz zawartość tablicy

    w1.wypisz_ws_tab(); //wypisz wartość wskaźnika


    cout <<" w2 = ";

    w2.wypisz();

    w2.wypisz_ws_tab();


    cout <<" w3 = ";

    w3->wypisz();

    w3->wypisz_ws_tab();


    int a;

	cin >> a;


	delete tablica;

}

Plik nagłówkowy: **.h

#ifndef LAB8PR2_H_

#define LAB8PR2_H_

using namespace std;


class WEKTOR

{

private:

   int *tab;

   int wymiar; 

  public:

    WEKTOR(int, int*);

    WEKTOR();

    ~WEKTOR();

    void ustaw(int*);

    void wypisz();

    void wypisz_ws_tab();

	};




#endif /*LAB8PR2_H_*/

(kostek135) #2

Moim zdaniem chodzi o przeciążenie operator=, i zaimplementowaniu w nim deep-copy. Domyślnie przekopiuje ci tylko wartość wskaźnika, a więc adres do już używanej pamięci przez obiekt macierzysty. Generalnie tyczy się to wszystkiego co zostało stworzone dynamicznie.


(Sawyer47) #3

Jeśli klasa ma wskaźnik na coś alokowanego dynamicznie to w większości przypadków chcesz zdefiniować operator przypisania, kontruktor kopiujący i destruktor (a od C++11 też wersje przyjmujące &&), aby poprawnie kopiować/zwalniać tę pamięć.