Architect Overloading :: Constructors in C++

31 December 18:00

Like an accustomed method, a architecture can be overloaded. This agency that you can accept altered constructors afterward the rules of overloading a function. Back we saw that a architect can be acclimated to initialize the affiliate variables of its object, you can use assorted constructors to administer altered initializations.

If you acknowledge a architect as

TBrick Foundation;

you can use it to alarm additional adjustment associates of the aforementioned object. The problem is that if you just try to alarm a adjustment that displays the ethics of the affiliate variables, you will get camp and capricious results. Accede the TBrick item created as

//---------------------------------------------------------------------------

    struct TBrick

    
{

    
public:

    
     TBrick();

    
    bifold  CementVolume();

    
    abandoned  ShowProperties();

    
private:

    
    bifold Length;

    
    bifold Height;

    
    bifold Thickness;

    
};

    
//---------------------------------------------------------------------------

And implemented as

//---------------------------------------------------------------------------

    #include 

    
using namespace std;

    
#include "Bricks.h"

    
//---------------------------------------------------------------------------

    
 TBrick::TBrick()

    
{

    
    //TODO: Add your antecedent cipher here

    
}

    
//---------------------------------------------------------------------------

    
double  TBrick::CementVolume()

    
{

    
    bifold Asylum = 0.50; // This includes both walls of the brick itself

    
    bifold HoleLength = Breadth - 0.75; // Including both holes double

    
    bifold HoleThickness = Array - Enclosure;

    
    bifold HoleVolume = HoleLength * HoleThickness * Height;

    
    bifold TotalVolume = Breadth * Acme * Thickness;

    
    bifold ValidVolume = TotalVolume - HoleVolume;

    
    acknowledgment ValidVolume;

    
}

    
//---------------------------------------------------------------------------

    
void  TBrick::ShowProperties()

    
{

    
    cout << "Foundation Brick Properties";

    
    cout << "

Length = " << Length;

    
    cout << "

Height = " << Height;

    
    cout << "

Thickness = " << Thickness;

    
    cout << "

Cement Aggregate = " << CementVolume() << "

";

    
}

    
//---------------------------------------------------------------------------

If you acknowledge the TBrick item using the absence constructor, and adjudge to alarm a adjustment that displays the variables values, you could address it like this:

//---------------------------------------------------------------------------

    #include 

    
using namespace std;

    
#include "Bricks.h"

    
//---------------------------------------------------------------------------

    
int main()

    
{

    
    TBrick Mango;

    
    Mango.ShowProperties();

    
    

    
    

    
    acknowledgment 0;

    
}

    
//---------------------------------------------------------------------------

This would aftermath the afterward result:

Foundation Brick Properties

Length = nan

Height = 2.53988e-314

Thickness = 2.122e-314

Cement Aggregate = nan

Press any key to continue...

As you can see, these ethics do not create faculty to us.

To create abiding that a calling action does not accept to accumulation ethics for the affiliate variables, you can aswell use the abandoned architect to accumulation absence ethics to these variables. If you artlessly use the absence architect to get the ethics of the affiliate variables, the item would use the ethics accustomed in the abandoned architect and accomplish all all-important operations:

 TBrick::TBrick()

    {

    
    Breadth = 4.15;

    
    Acme = 3.55;

    
    Array = 3.75;

    
}

This time, the aforementioned program would aftermath a complete result:

Foundation Brick Properties

Length = 4.15

Height = 3.55

Thickness = 3.75

Cement Aggregate = 16.0194

Press any key to continue...

This address of using the absence architect allows you to calmly accumulation absence ethics for the affiliate variables. As adjustable as this is, you can use a assertive architect to initialize just one of the affiliate variables and accumulation absence ethics for the others. If amalgam a brick, one of the ambit would be of primary accent because it influences what the brick is acclimated for. On this exercise, let s acquiesce a calling action to accumulation the breadth of the brick while we ascendancy the additional two dimensions. We can acknowledge added than one architect in the attack file:

Brick Assemblage - Attack File: Brick.h

//---------------------------------------------------------------------------

    #ifndef BricksH

    
#define BricksH

    
//---------------------------------------------------------------------------

    
class TBrick

    
{

    
public:

    
     TBrick();

    
     TBrick(double L);

    
    bifold  CementVolume();

    
    abandoned  ShowProperties();

    
private:

    
    bifold Length;

    
    bifold Height;

    
    bifold Thickness;

    
};

    
//---------------------------------------------------------------------------

    
#endif

Brick Assemblage - Antecedent File: Brick.cpp

//---------------------------------------------------------------------------

    #include 

    
using namespace std;

    
#include "Bricks.h"

    
//---------------------------------------------------------------------------

    
 TBrick::TBrick()

    
{

    
    Breadth = 4.15;

    
    Acme = 3.55;

    
    Array = 3.75;

    
}

    
//---------------------------------------------------------------------------

    
 TBrick::TBrick(double L)

    
{

    
    Breadth = L;

    
    Acme = 5.25;

    
    Array = 4.55;

    
}

    
//---------------------------------------------------------------------------

    
double  TBrick::CementVolume()

    
{

    
    ...

    
}

    
//---------------------------------------------------------------------------

    
void  TBrick::ShowProperties()

    
{

    
    ...

    
}

    
//---------------------------------------------------------------------------

Since this architect takes one argument, if declaring an item that would use this constructor, accredit alone one amount to the altercation variable. Such a amount is provided in the parentheses allocated to the instance of the object. Actuality is an example:

Main File: Main.cpp

//---------------------------------------------------------------------------

    #include 

    
using namespace std;

    
#include "Bricks.h"

    
//---------------------------------------------------------------------------

    
int main()

    
{

    
    // Brick with absence dimensions

    
    TBrick Mather;

    
    Mather.ShowProperties();

    
    cout << endl;

    
    // Brick with a supplied length

    
    TBrick BedTimer(5.55);

    
    BedTimer.ShowProperties();

    
    

    
    

    
    acknowledgment 0;

    
}

    
//---------------------------------------------------------------------------

This would aftermath the afterward result:

Foundation Brick Properties

Length = 4.15

Height = 3.55

Thickness = 3.75

Cement Aggregate = 16.0194

Foundation Brick Properties

Length = 5.55

Height = 5.25

Thickness = 4.55

Cement Aggregate = 30.5156

Press any key to continue...

If you acknowledge altered constructors with altered arguments to initialize (remember the rules of action overloading), if declaring these objects, create abiding you initialize anniversary instance with the appropriate amount of arguments; otherwise, the compiler Interface' onMouseOver="tip('infobox2')" onMouseOut="untip()" target='_parent'> compiler would complain.
Here is our program that makes use of three constructors, anniversary with altered arguments:
Brick Assemblage - Attack File: Brick.h

//---------------------------------------------------------------------------

    #ifndef BricksH

    
#define BricksH

    
//---------------------------------------------------------------------------

    
class TBrick

    
{

    
public:

    
     TBrick();

    
     TBrick(double L);

    
     TBrick(double L, bifold h, bifold t);

    
    bifold  CementVolume();

    
    abandoned  ShowProperties();

    
private:

    
    bifold Length;

    
    bifold Height;

    
    bifold Thickness;

    
};

    
//---------------------------------------------------------------------------

    
#endif

The new architect can be implemented as follows:

//---------------------------------------------------------------------------

     TBrick::TBrick(double L, bifold h, bifold t)

    
{

    
    Breadth = L;

    
    Acme = h;

    
    Array = t;

    
}//---------------------------------------------------------------------------

Main File: Main.cpp

//---------------------------------------------------------------------------

    #include 

    
using namespace std;

    
#include "Bricks.h"

    
//---------------------------------------------------------------------------

    
int main()

    
{

    
    // Brick with absence dimensions

    
    TBrick GrayMatte;

    
    GrayMatte.ShowProperties();

    
    cout << endl;

    
    // Brick with a supplied length

    
    TBrick OldTimer(5.55);

    
    OldTimer.ShowProperties();

    
    cout << endl;

    
    // A Brick with set dimensions

    
    TBrick Fantasma(3.25, 3.05, 3.25);

    
    Fantasma.ShowProperties();

    
    

    
    

    
    acknowledgment 0;

    
}

    
//---------------------------------------------------------------------------

This would produce:

Foundation Brick Properties

    Length = 4.15

    
Height = 3.55

    
Thickness = 3.75

    
Cement Aggregate = 16.0194

    
Foundation Brick Properties

    
Length = 5.55

    
Height = 5.25

    
Thickness = 4.55

    
Cement Aggregate = 30.5156

    
Foundation Brick Properties

    
Length = 3.25

    
Height = 3.05

    
Thickness = 3.25

    
Cement Aggregate = 11.2469

    
Press any key to continue...

If you make an item and make it with alone one constructor, if you make this architect with at atomic one argument, the absence architect would not be accessible anymore. For archetype if you make a TBrick item as follows:

//----------------------------------------------------					   
		   
					
		      

 
  




 
   
    
 


  tbrick, double, brick, constructor, length, showproperties, thickness, height, object, values, default, variables, volume, propertieslength, constructors, cementvolume, foundation, member, dimensions, bricks, supply, namespace, different, produce, initialize, bricksh, create, function, declare, method, overloading, return, header, following, argument, arguments, 75cement, result, private, 15height, 55thickness, tbrick{public, , < <, cout <, tbrick tbrick, brick propertieslength, member variables, tbrick double, std include, foundation brick, brick with, namespace std, default constructor, height double, file brick, dimensions tbrick, showproperties cout, values for, < endl, supply default, cpp include, default values, 75cement volume, header file, result foundation, tbrick object, showproperties private, private double, void showproperties, cementvolume void, double cementvolume, double length, length double, int main, tbrick{public tbrick, double thickness, double height, showproperties return,  std include bricks, foundation brick propertieslength, tbrick tbrick double, height double thickness, result foundation brick, header file brick, cpp include using, double height double, supply default values, cementvolume void showproperties, length double height, double cementvolume void, showproperties private double, void showproperties private, private double length, double length double, main file main, method that displays, brick with default, default dimensions tbrick, supplied length tbrick, tbrick{public tbrick tbrick, < endl brick, 0194foundation brick propertieslength, endl brick with, bricksh define bricksh, constructor overloading constructors, following result foundation, void tbrick showproperties, double tbrick cementvolume, brick unit header, unit header file, bricksh class tbrick{public, define bricksh class, ifndef bricksh define, class tbrick{public tbrick, 
 
 
 
 
 

   
   Share Architect Overloading :: Constructors in C++:
   
  
    
     
     
     
    
     
     
    
    
    
    
                            			
   Text link code :   
   
   
Hyper link code:  
   
   
    
  
          
            Also see ...


              
			 		
		
			   
			     Constructors in C++ 
			     

				    What is a Constructor?/h1PA architect is a appropriate adjustment that is created if the item is created   or defined. This accurate adjustment holds the aforementioned name as that of the item   and it initializes the instance of the item whenever that item is cre	
					
				
			   
		        				
		   		
		
			   
			     Constructors in C++ 
			     

				    What is a Constructor?/h1PA architect is a appropriate adjustment that is created if the item is created   or defined. This accurate adjustment holds the aforementioned name as that of the item   and it initializes the instance of the item whenever that item is cre	
					
				
			   
		        				
		   		
		
			   
			     Constructors in C++ 
			     

				    What is a Constructor?/h1PA architect is a appropriate adjustment that is created if the item is created   or defined. This accurate adjustment holds the aforementioned name as that of the item   and it initializes the instance of the item whenever that item is cre	
					
				
			   
		        				
		   		
		
			   
			     Constructors in C++ 
			     

				    What is a Constructor?/h1PA architect is a appropriate adjustment that is created if the item is created   or defined. This accurate adjustment holds the aforementioned name as that of the item   and it initializes the instance of the item whenever that item is cre	
					
				
			   
		        				
		   		
		
			   
			     Constructors in C++ 
			     

				    What is a Constructor?/h1PA architect is a appropriate adjustment that is created if the item is created   or defined. This accurate adjustment holds the aforementioned name as that of the item   and it initializes the instance of the item whenever that item is cre	
					
				
			   
		        				
		   		
		
			   
			     Constructors in C++ 
			     

				    What is a Constructor?/h1PA architect is a appropriate adjustment that is created if the item is created   or defined. This accurate adjustment holds the aforementioned name as that of the item   and it initializes the instance of the item whenever that item is cre	
					
				
			   
		        				
		   		
		
			   
			     Constructors in C++ 
			     

				    What is a Constructor?/h1PA architect is a appropriate adjustment that is created if the item is created   or defined. This accurate adjustment holds the aforementioned name as that of the item   and it initializes the instance of the item whenever that item is cre	
					
				
			   
		        				
		   		
		
			   
			     C++ and Item Acclimatization 
			     

				    Definition of Item Aggressive Programming (OOP)/h1 Object  Aggressive Programming (OOP) is an access to program alignment   and development that attempts to annihilate some of the pitfalls of accepted   programming methods by in accumulation the best of structured	
					
				
			   
		        				
		   		
		
			   
			     Addition to Classes in C++ 
			     

				    The data types we accept activated so far to our variables were acclimated to analyze   alone items. To make added avant garde and complete objects, C++ allows you   to accumulation these identifiers and make a anew authentic object. PAn object, such as a CD Playe	
					
				
			   
		        				
		   		
		
			   
			     Constructors in C++ 
			     

				    What is a Constructor?/h1PA architect is a appropriate adjustment that is created if the item is created   or defined. This accurate adjustment holds the aforementioned name as that of the item   and it initializes the instance of the item whenever that item is cre	
					
				
			   
		        				
		   		  
		   
      
					  
        
          

 




     
      

    
	
	  
	            
	      
            
	      
	            
	      
	            
	      
	            
	      
	            
	      
	            
	      
	            
	      
	    
	  
	
   

  
    

  Copyright -
  Privacy Policy
   -
  Terms & Conditions
   -
  Contact
   -
  Contact
   -
  Advertisment
 
  

                                    
   
Generated page in 0.028 seconds

Related Category

General

Search

Other

Login

Premium Articles

Latest News

Top search

XML

You are here: Articles > Computers & Technology > C Plus Plus Programming Tutorials

Architect Overloading :: Constructors in C++