Architect Overloading :: Constructors in C++

strategygamesios sportsappsios puzzlegamesios
 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 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:



    



    



    



    



    

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

 


Tags: create, different, argument, class, foundation, supply, method, displays, values, brick, result, arguments, object

 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++:
Digg it!   Google Bookmarks   Del.icio.us   Yahoo! MyWeb   Furl  Binklist   Reddit!   Stumble Upon   Technorati   Windows Live   Bookmark

Text link code :
Hyper link code:

Also see ...

Permalink
Article In : Computers & Technology  -  C Plus Plus Programming Tutorials