Dynamic Memory Review what is static, automatic, dynamic variables? why are dynamic(ally allocated) variables needed what is program stack? function (invocation) frame? what is a heap? how is it used? what is new and delete operations? how are they used? how is dynamically allocated variable accessed? assigned value at declaration time? what is memory leak? loose pointer (again)? how are dynamic arrays allocated? deallocated? how can a pointer be passed by value/by reference to a function? what are dynamically allocated objects?

Objects Containing Dynamically Allocated Members

Objects Containing Dynamic Members if we want to create an object that can shrink and grow as needed? class MyClass{ public: MyClass(int); // constructor private: int *d; int size; }; with the following constructor: MyClass::MyClass(int n){ size=n; d = new int[size]; } then the following declaration creats an object containing an array of 5 integers MyClass myobj(5); and this contains an array of 10 integers (note both objects belong to same class) MyClass myobj2(10); // 10-element array

Destructor however, when myobj goes out of scope, the dynamically allocated array is leaked why? destructor is a function that is called implicitly (without mentioning its name) when object goes out of scope class MyClass{ public: MyClass(int); // constructor ~MyClass(); // destructor private: int *d; int size; }; name of destructor: tilde (~) and name of class MyClass::~MyClass(){ delete [] d; } no need to deallocate automatic variables destructor is never invoked explicitly and does not accept parameters note that destructor is called on every local object when function ends

Copy Constructor what if we have this function (note that the object is passed by value): void myfunc (MyClass); if we invoke it as follows myfunc(myobj); what happens? the function is passed a reference to the same array - copy of the array is not created copy constructor is invoked implicitly when a new copy of an object is created: when function is passed an object by value when function returns an object copy constructor can be invoked at object declaration, how? copy constructor is not invoked when one object is assigned to another (more on that later)

Copy Constructor (cont.) copy constructor is a constructor that accepts an object of the same class passed by reference class MyClass{ public: MyClass(int); // regular constructor MyClass(const MyClass&); // copy constructor private: int *d; int size; }; defined as follows MyClass::MyClass(const MyClass& org){ size=org.size; d = new int[size]; for(int i=0; i< size; ++i) d[i]=org.d[i]; } note that copy constructor can access private members of the parameter object can be invoked at object declaration: MyClass newobj(myobj);

Assignment Overloading what do you think this operation does? secondObj=firstObj; copies the value of pointer leaking the array of the old object and not creating a copy of the array in the new object assignment needs to be overloaded assignment overloading operator accepts by reference the object on the right-hand-side of equation and is invoked by the object on the left-hand-side: lhsobj = rhsobj; class MyClass{ public: … void operator= (const MyClass&); private: int *d; int size; }; can define as follows (not quite right yet): void MyClass::operator= (const MyClass& rhs){ size=rhs.size; delete [] d; d=new int[size]; for (int i=0; i < size; ++i) d[i]=rhs.d[i]; }

Self-Assignment Protection what happens if you do this assignment? myobj=myobj; it is legal in C++ is our overloaded assignment going to handle it right? this is a reserved keyword. It is a pointer to the object that invokes the member function it is passed implicitly to every member function assignment overloading (still not quite right): void MyClass::operator= (const MyClass& rhs){ if (this != &rhs){ // if not same size=rhs.size; delete [] d; d=new int[size]; for (int i=0; i < size; i++) d[i]=rhs.d[i]; }

Stackable Assignment what happens if you do this assignment? thirdObj = secondObj = firstObj; here is the definition that gets above code to work correctly MyClass& MyClass::operator= (const MyClass& rhs){ if (this != &rhs){ // if not same size=rhs.size; delete [] d; d=new int[size]; for (int i=0; i < size; i++) d[i]=rhs.d[i]; } return *this; // return lhs note the return value of the function, it is a reference to an object returned object refers to object used in return-statement similar to pass-by-reference parameter

The BIG Three big three - copy constructor, overloaded assignment and destructor expert opinion - if you need any one of them - most probably you will need all three they are not syntactically related but it is usually safer to define all three if you think you’d need at least one

Objects with Dynamic Members Review What are dynamically allocated objects Objects containing dynamically allocated members? What may be potential problems with the latter? What are the big three operations? What is a destructor? Why is it needed? When is it executed? How is it declared/defined? What is a copy-constructor? Why is it needed? When is it executed? How is it declared/defined? What is operation overloading? What is overloaded assignment? Why is it needed for objects with dynamic members? How is it declared/defined? What is this-pointer? What is protection against self-assignment? How is this-pointer used for that? What is stackability of an operator? How can overloaded assignment be made stackable?