Gain insights into dynamic memory allocation, creating classes, and functions. Delve into inheritance, I/O, exception handling. Explore 90+ examples to master advanced C++ functionalities.

c.tar.gz

ConsoleInputJob

IOjob83

IOjob84

Lesson26and27

If you’re looking to sharpen up your C++ programming skills, then you’re in the right place. You will start with learning about dynamic memory allocation, how to create classes, and constructors. 

In the latter half of the course, inheritance, functions, I/O, exception handling, and more. Throughout the course, you will study over 90 carefully designed examples aimed to enhance your understanding of the C++ language.  

By the time you finish this course, you will be able to use more advanced functionality in your C++ programs.

C++ Programming for Experienced Engineers

# Problem
	                        
What purpose does a **copy constructor** serve and how is it *different* from a normal constructor?

# Coding solution	
Here is a solution to the problem above.
	                        



// Program to demonstrate cases when copy constructor is called

#include <iostream>


class Circle
{
	private :
		int radius ;
		float x, y ;

	public :
		Circle( )
		{
			radius = x = y = 0 ;
		}
		Circle ( int rr, float xx, float yy )
		{
			radius = rr ;
			x = xx ;
			y = yy ;
		}
		Circle ( const Circle& c )
		{
			std::cout << "Copy constructor invoked" << std::endl ;
			radius = c.radius ;
			x = c.x ;
			y = c.y ;
		}	
		void showData( )
		{
			std::cout << "Radius = " << radius << std::endl ;
			std::cout << "X-Coordinate = " << x << std::endl  ;
			std::cout << "Y-Coordinate = " << y << std::endl ;
		}
		void setData ( Circle c )
		{
			radius = c.radius ;
			x = c.x ;
			y = c.y ;
		}
} ;

Circle fun( ) 
{
	Circle c ;
	return c ;
}

int main( )
{
	Circle c1 ( 10, 2.5, 3.5 ) ;
	
	Circle c2 = c1 ;
	c2.showData( ) ;
	
	Circle c3 ;
	c3.setData ( c1 ) ;
	c3.showData( ) ;
		
	Circle c4 = fun( ) ;
	c4.showData( ) ;
		
	return 0 ;
}


# Explanation	 	                        

A *copy constructor* gets invoked in *three* situations. These are as follows:

1. When instantiating one object and initializing it with values from another object
2. When passing an object to a function by value
3. When an object is returned from a function by value

When an object is passed by **value**, the copy that the function operates on is created using a *copy constructor*. If we pass the **address** or **reference** of the object, the *copy constructor would not be invoked since the copies of the objects are not to be created.*

When an object is returned from a function, the *copy constructor* is invoked to *create a copy of the value returned by the function*. However, from the sample run we see that the *copy constructor* is called only *twice*. Once while **initializing** `c2` and again while **passing** `c1` to the `setData( )` function. Contrary to our expectation, it doesn't get called when `c4` is created. This is because the compiler performs a **"return value optimization"** and eliminates the call to the copy constructor to create a copy of the object.
However, in some cases the compiler cannot do this optimization. For example, if you change the definition to `fun( )` as shown below and re-execute the program, you would find that this time the *copy constructor* gets called while returning an object from `fun( )`.
```C++
Circle fun( ) 
{
	Circle cthis, cthat ;
	int i = 0 ;

	return ( i ? cthis : cthat ) ;
}
```

Understand the purpose and significance of copy constructors.

Getting Off the Ground

Starters

Basic C++ Examples

Class Organization Examples

Class Constructor Examples

Classes and Objects Examples

More Classes and Objects Examples

Function Examples

Function Overloading Examples

Operator Overloading Examples

Free Store Examples

Inheritance Examples

Virtual Function Examples

Input Output Examples

Template Examples

Exception Handling Examples

STL Examples

Miscellaneous Examples

Conclusion

Significance of Copy Constructor

Problem