C++ References vs Pointers

1. Reference must be initialized when it is created. Pointers can be initialized at any time.

2. Reference cannot be null it is to be initialized with other variable.

3. Reference is initialized to one object, it cannot be changed to refer to other object where as
pointer can point to any other object at any time

Stack Unwinding

What is Stack Unwinding ?

The process of searching ‘‘up through the stack’’ to find a handler for an exception is commonly

called ‘‘stack unwinding.’’ As the call stack is unwound, the destructors for constructed

local objects are invoked.


--------------------------------------------------------------------------------------------------------------------------

When an exception is thrown and control passes from a try block to a handler, the C++ run time calls destructors for all automatic objects constructed since the beginning of the try block. This process is called stack unwinding. The automatic objects are destroyed in reverse order of their construction

Consider the following code

void g()
{ 
    throw std::exception();
}
 
void f()
{
    std::string str = "Hello"; // This string is newly allocated
    g();
}
 
int main()
{
    try
    {
        f();
    }
    catch(...) 
    { }
}

The flow of the program:

• main() calls f()
• f() creates a local variable named str
• str constructor allocates a memory chunk to hold the string "Hello"
• f() calls g()
• g()throws an exception
• f() does not catch the exception.

Because the exception was not caught, we now need to exit f() in a clean fashion.

At this point, all the destructors of local variables previous to the throw

are called—This is called 'stack unwinding'.

• The destructor of str is called, which releases the memory occupied by it.

As you can see, the mechanism of 'stack unwinding' is essential to prevent resource leaks—without it, str would never be destroyed, and the memory it used would be lost until the end of the program (even until the next loss of power, or cold boot depending on the Operative System memory management).

• main() catches the exception
• The program continues.

The 'stack unwinding' guarantees destructors of local variables (stack variables) will be called when we leave its scope.

Object Slicing in C++

Object Slicing in C++

when a derived class object is assigned to a base class object, additional attributes of a derived class object are sliced off to form the base class object.
We can avoid above unexpected behavior with the use of pointers or references. Object slicing doesn’t occur when pointers or references to objects are passed as function arguments since a pointer or reference of any type takes same amount of memory. For example, if we change the global method myfunc() in the above program to following, object slicing doesn’t happen.

Sol :  Object Slicing:Virtual function should however always be called either a pointer or a reference.

In C++, a derived class object can be assigned to a base class object, but the other way is not possible.

class Base { int x, y; };   class Derived : public Base { int z, w; };   int main() {     Derived d;     Base b = d; // Object Slicing,  z and w of d are sliced off }

Object slicing happens when a derived class object is assigned to a base class object, additional attributes of a derived class object are sliced off to form the base class object.

#include <iostream> using namespace std;   class Base { protected:     int i; public:     Base(int a)     { i = a; }     virtual void display()     { cout << "I am Base class object, i = " << i << endl; } };   class Derived : public Base {     int j; public:     Derived(int a, int b) : Base(a) { j = b; }     virtual void display()     { cout << "I am Derived class object, i = "            << i << ", j = " << j << endl;  } };   // Global method, Base class object is passed by value void somefunc (Base obj) {     obj.display(); }   int main() {     Base b(33);     Derived d(45, 54);     somefunc(b);     somefunc(d);  // Object Slicing, the member j of d is sliced off     return 0; }

Output:

I am Base class object, i = 33
I am Base class object, i = 45

We can avoid above unexpected behavior with the use of pointers or references. Object slicing doesn’t occur when pointers or references to objects are passed as function arguments since a pointer or reference of any type takes same amount of memory. For example, if we change the global method myfunc() in the above program to following, object slicing doesn’t happen.

// rest of code is similar to above void somefunc (Base &obj) {     obj.display(); }           // rest of code is similar to above

Output:

I am Base class object, i = 33
I am Derived class object, i = 45, j = 54

We get the same output if we use pointers and change the program to following.

// rest of code is similar to above void somefunc (Base *objp) {     objp->display(); }   int main() {     Base *bp = new Base(33) ;     Derived *dp = new Derived(45, 54);     somefunc(bp);     somefunc(dp);  // No Object Slicing     return 0; }

Output:

I am Base class object, i = 33
I am Derived class object, i = 45, j = 54

Object slicing can be prevented by making the base class function pure virtual there by disallowing object creation. It is not possible to create the object of a class which contains a pure virtual method.