amdfanatyk pisze:Klasa k = Klasa();
Tutaj na początku wywoływany jest konstruktor bezparametrowy, dopier późnej konstruktor kopiujący.
Kod: Zaznacz cały
k a, c;
k b = a; // konstruktor kopiujący
c = a; // operator przypisania
amdfanatyk pisze:Twoje stwierdzenie "musisz" nie jest poprawne bo nic nie musi.
To "dobry" z Ciebie programista jeśli w swoich klasach nie zapewniasz
prawidłowego przypisania i inicjalizacji obiektów innym obiektami.
amdfanatyk pisze:Nie muszę używać swojej klasy ani w pierwszym ani w drugim kontekście więc nie muszę definiować konstruktora kopiującego i operatora=.
Jeśli tego nie chcesz to podaj ich deklarację w private, żeby nie można było ich w ogóle wywoływać (nie podawaj definicji, konsolidator nie będzie jej szukał).
amdfanatyk pisze:Tak samo nie muszę definiować operatorów , == itd.
operator= i konstruktor kopiujący są automatycznie generowane przez kompilator i działają nie poprawnie w przypadku dynamicznej alokacji pamięci.
konstruktor kopiujący
Jeśli zostanie wywołany destruktor obiektu a to w b będzie błędny wskaźnik.
operator=
Po przypisaniu (c = a) będziemy mieli wyciek pamięci bo to co na początku wskazywał wskaźnik w obiekcie c nie zostało skasowane, mało tego ten wskaźnik (z c) wskazuje na ten sam obszar pamięci co wskaźnik z obiektu a, więc jeśli coś zmieniamy to w obu obiektach.
Teraz zrozumiałeś? Dlaczego to takie ważne?
Skoro w Twoich kodach wycieki pamięci i błędne wskaźniki to normalka to nic nie musisz robić i wystarczy konstruktor kopiujący i operator= generowany przez kompilator.
[ Dodano: 7 Kwietnia 2008, 23:18 ]
kawafis44 pisze:czy tak będzie dobrze?
Tak będzie dobrze:
Kod: Zaznacz cały
#include <iostream>
using namespace std;
class DynA{
public:
DynA(int inSize = 10);
DynA(const DynA& src);
~DynA();
DynA& operator=(const DynA& rhs);
void setValue(int i, int value);
int getValue(int i) const;
void resize(int newSize);
private:
void copy(const DynA& src);
int* mTab;
int mSize;
};
DynA::DynA(int inSize) : mSize(inSize)
{
mTab = new int[inSize];
}
DynA::DynA(const DynA& src)
{
copy(src);
}
DynA::~DynA()
{
delete[] mTab;
}
DynA& DynA::operator=(const DynA& rhs)
{
if(this == &rhs) {
return *this;
}
delete[] mTab;
copy(rhs);
return *this;
}
void DynA::setValue(int i, int value)
{
mTab[i] = value;
}
int DynA::getValue(int i) const
{
return mTab[i];
}
void DynA::resize(int newSize)
{
int* tmp = new int[newSize];
for(int i = 0; i < mSize && i < newSize; ++i) {
tmp[i] = mTab[i];
}
mSize = newSize;
delete[] mTab;
mTab = tmp;
}
void DynA::copy(const DynA& src)
{
mSize = src.mSize;
mTab = new int[mSize];
for(int i = 0; i < mSize; ++i) {
mTab[i] = src.mTab[i];
}
}
int main(int argc, char** argv)
{
const int kSize1 = 10;
const int kSize2 = 25;
DynA da(kSize1);
DynA d;
for(int i = 0; i < kSize1; ++i) {
da.setValue(i, i + 1);
}
da.resize(25);
for(int i = kSize1; i < kSize2; ++i) {
da.setValue(i, 20);
}
d = da;
d.setValue(0, 5);
DynA c = d;
c.setValue(0, 3);
for(int i = 0; i < kSize2; ++i) {
cout << da.getValue(i) << " ";
}
cout << endl;
for(int i = 0; i < kSize2; ++i) {
cout << d.getValue(i) << " ";
}
cout << endl;
for(int i = 0; i < kSize2; ++i) {
cout << c.getValue(i) << " ";
}
cin.get();
return 0;
}