Copy Constructor, Assignment, Equality

Transcription

1 CS 246: Software Abstraction and Specification Lecture 4 Copy Constructor, Assignment, Equality Readings: Eckel, Vol. 1 Ch. 11 References and the Copy-Constructor Ch. 12 Operator Overloading (operator=) U Waterloo CS246se (Spring 2011) p.1/21

2 Copying Objects How many times is an object copied in the following code? class Money { ; Money operator+ (Money m, Money n); int main() { Money m(10, 30); Money n(m); Money p = m; p = p + n; U Waterloo CS246se (Spring 2011) p.2/21

3 Copying Objects with Pointers Shallow copy copies the object and its pointers' addresses, so that the original and copied pointers refer to the same object. day_ = 17 month_ year_ = 2011 day_ = 17 month_ year_ = 2011 "Jan" "Feb" "Mar" "Apr" "May" Deep copy copies the object and what its pointers point to, so that the pointer data members refer to distinct objects. p1 code_ "N2L 3G1" p2 code_ "N2L 3G1" U Waterloo CS246se (Spring 2011) p.3/21

4 Copy Constructor A copy constructor constructs a new object whose value is equal to an existing object. We can define our own, which the compiler uses whenever it needs to copy an object. class Password { Password(const Password&); // copy constructor private: string *passwd_; Password::Password (const Password &p) { if (p.passwd_ == 0) { passwd_ = 0; else { passwd_ = new string( *(p.passwd_) ); U Waterloo CS246se (Spring 2011) p.4/21

5 Copy Constructor class MyClass { MyClass(const MyClass&); // copy constructor private: A a_; // object type B *b_; // pointer type int c_; // simple data type ; MyClass::MyClass (const MyClass &m) : a_(m.a_), c_(m.c_) { if (m.b_ == 0) { b_ = 0; else { b_ = new B(*m.b_); Best Practice: copy simple data members and object members via their copy constructors, invoked in the constructor's initialization list. U Waterloo CS246se (Spring 2011) p.5/21

6 Copy Constructor class MyClass { MyClass(const MyClass&); // copy constructor private: A a_; // object type B *b_; // pointer type int c_; // simple data type ; Call to Class A's copy constructor MyClass::MyClass (const MyClass &m) : a_(m.a_), c_(m.c_) { if (m.b_ == 0) { b_ = 0; else { b_ = new B(*m.b_); Best Practice: copy simple data members and object members via their copy constructors, invoked in the constructor's initialization list. Uninitialized members are constructed (via default constructor) and assigned (via the member's assignment operator) inside the method. U Waterloo CS246se (Spring 2011) p.6/21

7 HowMany Example class HowMany { string name_; // Object identifier static int objectcount_; HowMany(const string& id = "") : name_(id) { ++objectcount_; printcount("howmany()"); ~HowMany() { --objectcount_; printcount("~howmany()"); // The copy-constructor: HowMany(const HowMany& h) : name_(h.name_) { name_ += " copy"; ++objectcount_; printcount("howmany(const HowMany&)"); void printcount(const string& Location = "") const { if(location.size()!= 0) { cout << Location << endl; cout << '\t' << name_ << ": "objectcount = " << objectcount_ << endl; ; int HowMany::objectCount = 0; Bruck U Waterloo Eckel, CS246se Thinking (Spring C ) Vol. p.7/21 1

8 HowMany Example // Pass and return BY VALUE: 1) HowMany f(howmany x) { 2) x.printcount("x argument inside f()"); 3) cout << "Returning from f()" << endl; 4) return x; 5) 6) int main() { 7) HowMany h("h"); 8) cout << "Entering f()" << endl; 9) HowMany h2 = f(h); 10) h2.printcount("h2 after call to f()"); 11) cout << "After call to f()" << endl; 12) Bruck Eckel, Thinking in C++ Vol. 1 U Waterloo CS246se (Spring 2011) p.8/21

9 Compiler-Generated Copy Constructor If we do not declare a copy constructor for our class, the compiler will generate one for us: based on memberwise initialization simple data members: bitwise copy pointer members: bitwise copy member objects: "recursively" calls members' copy constructors class MyClass { // NO copy constructor - compiler will generate one private: A a_; // member object B *b_; // pointer member int c_; // simple data member ; Best Practice: Define your own copy constructor. U Waterloo CS246se (Spring 2011) p.9/21

10 Preventing Pass-by-Value We can prohibit copy construction (and all pass-by-value) by declaring this method as a private method and never defining it. class Password { private: string *passwd_; Password(const Password&); // copy constructor // declared but never defined U Waterloo CS246se (Spring 2011) p.10/21

11 Singleton Design Pattern Can ensure that exactly one object instance of our class exists (singleton design pattern) via static member objects and a private copy constructor. class Egg { static Egg e; // singleton instance int i; // data member Egg(int ii) : i(ii) { // unimplemented constructor Egg(const Egg&); // unimplemented copy-constructor static Egg* instance() { return &e; int val() const { return i; ; Egg Egg::e(47); // initialization of singleton Bruck Eckel, Thinking in C++ Vol. 1 U Waterloo CS246se (Spring 2011) p.11/21

12 Assignment Operator Similar to the copy constructor, except that the destination of the copy already exists. MyType a; MyType b(a); MyType c = a; b = c; // default construction // copy construction // copy construction // assignment U Waterloo CS246se (Spring 2011) p.12/21

13 Overloading Assignment class Rational { Rational(int num=0, int denom=1); Rational& operator=(const Rational&); // must be member func private: int num_; int denom_; ; Rational& operator= (const Rational &r) { num_ = r.num_; // copy member values denom_ = r.denom_; return *this; // return reference to self U Waterloo CS246se (Spring 2011) p.13/21

14 Standard Format of operator= class MyClass { MyClass& operator= (const MyClass&); // overloading assignment private: A a_; // object type B *b_; // pointer type int c_; // simple data type ; MyClass& MyClass::operator= (const MyClass &mc) { if (&mc!= this) { // 1. Check self assignment a_ = mc.a_; c_ = mc.c_; // 2. (Re)use member's assignment operations delete b_; // 3. Assign to pointer member if (mc.b_ == 0) // design decision: shallow or deep copy b_ = 0; // (don't forget to manage memory!) else { b_ = new B(*mc.b_); return *this; // 4. Return reference to self U Waterloo CS246se (Spring 2011) p.14/21

15 Password Example class Password { Password& operator= (const Password&); // assignment private: string *passwd_; Password& operator= (const Password &p) { if (&p!= this) { delete passwd_; if (p.passwd_ == 0) { passwd_ = 0; else { passwd_ = new string( *p.passwd_ ); return *this; U Waterloo CS246se (Spring 2011) p.15/21

16 Compiler-Generated Assignment Operator If we do not overload the assignment operator for our class, the compiler will create an operator= member function for us: based on memberwise assignment: simple data members: bitwise copy pointer members: bitwise copy (may not be what we want) member objects: "recursively" calls members' assignment ops class MyClass { // NO overloaded operator= - compiler will generate one private: A a_; // member object B *b_; // pointer member int c_; // simple data member ; Best Practice: Define your own assignment operator. U Waterloo CS246se (Spring 2011) p.16/21

17 Equality The compiler will NOT generate a comparison operator for us. We have to define our own. bool operator== (const Password &p) const { return *passwd_ == p.passwd_; U Waterloo CS246se (Spring 2011) p.17/21

18 Copy, Assignment, Equality MyType a; MyType b(a); MyType c = a; b = c; // default construction // copy construction // copy construction // assignment The copy constructor, equality, and assignment methods should be compatible with one another copying an object should be the same (==) as assigning the values of an existing object to the initial values of a new object a copied/assigned object should be equal (==) to the original U Waterloo CS246se (Spring 2011) p.18/21

19 class Dog { string nm_; Summary of Essential Methods Dog(const string& name) : nm_(name) { cout << "Creating Dog: " << *this << endl; ~Dog() { cout << "Deleting Dog: " << *this << endl; // Compiler-generated copy-constructor & operator= are OK // Create a Dog from a Dog pointer: Dog(const Dog* dp, const string& msg) : nm_(dp->nm_ + msg) { cout << "Copied dog " << *this << " from " << *dp << endl; friend ostream& operator<<(ostream& os, const Dog& d) { return os << "[" << d.nm_ << "]"; ; Bruck Eckel, Thinking in C++ Vol. 1 U Waterloo CS246se (Spring 2011) p.19/21

20 class DogHouse { Dog* d_; string house_; Summary of Essential Methods DogHouse(Dog* dog, const string& hname) : d_(dog), house_(hname){ DogHouse(const DogHouse& dh) : d_(new Dog(dh.d_, " copy-constructed")), house_(dh.house_ + " copy-constructed") { ~DogHouse() { delete d_; DogHouse& operator=(const DogHouse& dh) { // Check for self-assignment: if (&dh!= this) { delete d_; d_ = new Dog(dh.d_, " assigned"); house_ = dh.house_ + " assigned"; return *this; Dog* getdog() const { return d_; friend ostream& operator<<(ostream& os, const DogHouse& dh) { return os << "[" << dh.house_ << "] contains " << *dh.d_; Bruck ; Eckel, Thinking in C++ Vol. 1 U Waterloo CS246se (Spring 2011) p.20/21

21 Summary of Essential Methods int main() { DogHouse fidos(new Dog("Fido"), "FidoHouse"); cout << fidos << endl; DogHouse fidos2 = fidos; // Copy construction cout << fidos2 << endl; DogHouse fidos3(new Dog("Spot"), "SpotHouse"); cout << fidos3 << endl; fidos3 = fidos2; cout << fidos3 << endl; // Assignment Bruck Eckel, Thinking in C++ Vol. 1 U Waterloo CS246se (Spring 2011) p.21/21