Type-Defining a Class

Just as you can type-define the name of a built-in data type, you can do the same for any class. As reviewed for primitive types, when doing this, remember that you are not creating a new type: you are only providing a pseudo-name for an existing class. Here is an example:

#ifdef __BORLANDC__

  #pragma argsused

#endif



#include <iostream>

using namespace std;



class Hand

{

  int numberOfFingers;

};



int main( int argc, char * argv[] )

{

    typedef Hand BodyMember;



    return 0;

}

After type-defining a class, you can use the new name to declare a variable as if you were using the actual name of the class. Here is an example:

#ifdef __BORLANDC__

  #pragma argsused

#endif



#include <iostream>

using namespace std;



class Hand

{

  int numberOfFingers;

};



int main( int argc, char * argv[] )

{

    typedef Hand BodyMember;



    BodyMember human;

    return 0;

}

Remember that you can also type-define a class' name globally, that is, outside of any function, and use it in the other functions that would need the new name:

#ifdef __BORLANDC__

  #pragma argsused

#endif



#include <iostream>

using namespace std;



class Hand

{

  int numberOfFingers;

};



typedef Hand BodyMember;



int main( int argc, char * argv[] )

{

    BodyMember human;

    return 0;

}

Class Forward Definition 

Sometimes when creating a class, you may already know the member(s) you want it to have. In some cases, you may want to first communicate the name of the class but you are not ready to list its members. C++ allows you to perform what is referred to a forward definition. In this case, you specify only the type (struct or class) and the name of the class. This allows you to do some tasks that don't require the members of the class. Here is an example:

#ifdef __BORLANDC__

  #pragma argsused

#endif



#include <iostream>

using namespace std;



class Hand;

typedef Hand BodyMember;



// Do anything here



int main( int argc, char * argv[] )

{

    return 0;

}

Once you are ready, you can then complete the class as you see fit. Here is an example:

#ifdef __BORLANDC__

  #pragma argsused

#endif



#include <iostream>

using namespace std;



class Hand;

typedef Hand BodyMember;



// Do anything here



class Hand

{

    int numberOfFingers;

};



int main( int argc, char * argv[] )

{

    BodyMember human;



    return 0;

}

If you use this technique, you still must define the class before you are able to use it. Consider the following code:

#ifdef __BORLANDC__

  #pragma argsused

#endif



#include <iostream>

using namespace std;



class Hand;

typedef Hand BodyMember;



// Do anything here



int main( int argc, char * argv[] )

{

    BodyMember human;



    return 0;

}



class Hand

{

    int numberOfFingers;

};

This code will not compile because, at the time the class is instantiated in main(), its definition is not known, only its emptiness, which is not enough.

The Access Levels of a Class

So far, to make our learning process easier, we declared only one member variable in a class. The primary reason for using a class as opposed to a built-in data type is to be able to group different characteristics used to describe the class and make it as complete as possible. This means that a class is meant to have as many members as you judge necessary. To apply this, in the body of the class, declare the necessary variables, each with a data type and a name, and each declaration ending with a semi-colon. Here is an example:

#ifdef __BORLANDC__

  #pragma argsused

#endif



#include <iostream>

using namespace std;



struct Car

{

        int      Year;

        unsigned NumberOfDoors;

        long     Mileage;

        char     DrivingCondition;

};



int main( int argc, char * argv[] )

{

    return 0;

}

Once again, to access its members outside of the class, you can first declare a variable based on the class. To access a member variable, you type the class' variable name, followed by the period operator. Here is an example:

#include <iostream>

using namespace std;



struct Car

{

	int      Year;

	unsigned NumberOfDoors;

	long     Mileage;

	char     DrivingCondition;

};



int main()

{

	Car vehicle;



	vehicle.Mileage = 42580;



	cout << "Car Characteristics\n";

	cout << "Mileage:   " << vehicle.Mileage << endl;



	return 0;

}

This would produce:

Car Characteristics

Mileage:   42580

A common object in real life is visibly made of two categories of parts: those you can see or touch and those you do not have access to. The parts you can see or touch are considered visible or accessible. In C++, such parts are referred to as public. Those you cannot see or touch are considered hidden. In C++, such parts are referred to as private. Like objects in real life, a class is made of sections that the other parts or other objects cannot “see” and those the other objects can access. The other objects of of the program are sometimes referred to as the clients of the object. The parts the client of an object can touch in a class are considered public and the others are private.

When creating a class, you will define which items are public and which ones are private. The items that are public are created in a section that starts with the public keyword followed by a semi-colon. Here is an example:

#ifdef __BORLANDC__

  #pragma argsused

#endif



#include <iostream>

using namespace std;



struct Car

{

public:

        int      Year;

        unsigned NumberOfDoors;

        long     Mileage;

        char     DrivingCondition;

};



int main( int argc, char * argv[] )

{

      Car vehicle;



      vehicle.Mileage = 42580;

      cout << "Car Characteristics\n";

      cout << "Mileage:   " << vehicle.Mileage;



    return 0;

}

In the same way, the hidden parts are in a section that starts with the private keyword followed by a semi-colon. If you don't specify these sections, all of the members of a class are considered private.

The difference between a class and a structure is that, by default, all of the members of a class are private and, by default, all of the members of a structure are public. That is how it works if you don't create your own public and private sections. For example, the following program will not compile:

#ifdef __BORLANDC__

  #pragma argsused

#endif



#include <iostream>

using namespace std;



class Car

{

        int      Year;

        unsigned NumberOfDoors;

        long     Mileage;

        char     DrivingCondition;

};



int main( int argc, char * argv[] )

{

      Car vehicle;



      vehicle.Mileage = 42580;

      cout << "Car Characteristics\n";

      cout << "Mileage:   " << vehicle.Mileage;



    return 0;

}

The reason is that the Mileage member variable that belongs to a class type is private and therefore cannot be accessed from main(). To resume, when creating your class, you can specify the necessary access levels using the public: and private: sections. Here is an example:

#ifdef __BORLANDC__

  #pragma argsused

#endif



#include <iostream>

using namespace std;



struct Car

{

public:

        int      Year;

        unsigned NumberOfDoors;

        bool     HasAirCondition;

private:

        char     DrivingCondition;

        short    TypeOfTransmission;

        char     Color;

public:

        long     Mileage;

};



int main( int argc, char * argv[] )

{

      Car vehicle;



      vehicle.Mileage = 42580;

      cout << "Car Characteristics\n";

      cout << "Mileage:   " << vehicle.Mileage;



    return 0;

}

As you can see from this class, there are no rules as to the number of public or private sections you can have in a class. There are no rules on the order of the access levels: you can create a public or a private section anywhere in the class, just remember that any member under an access level follows the rules of that access. The fact that you use different public sections does not by any means provide different public levels to the variables. A variable declared as public in one public section has the same public level of access as any other variable that is declared in another public section.

Object Initialization

Initializing Each Member of a Class

Just as variables of primitive types, an object declared from a class can also be initialized. There are various techniques you can use: initializing individual members or initializing the class as a whole.

To initialize a member of a class, access it and assign it an appropriate value using the rules of C++:

• If the member is a numeric type, assign it a number of your choice
• If the member is a char type, assign it a symbol or character in single-quotes
• If the member is of type bool, assign it true or false
• If the member is a string type, assign it a value in double-quotes
• If the member is an array of character, use the strcpy() function to copy a value into it

Here are examples:

Initializing an Object as a Whole

You can also initialize an object as a variable. This time, type the name of the variable followed by the assignment operator, followed by the desired values of the variables listed between an opening and a closing curly brackets. Here are the rules you must follow:

• The list of values must follow the order of the declared member variables of the class
• The values are separated with commas
• None of the members of the class can be another class. For example, no member variable should have been declared as string

Here is an example:

#ifdef __BORLANDC__

  #pragma argsused

#endif



#include <iostream>

using namespace std;



struct Car

{

    char     Make[40];

    char     Model[40];

    int      Year;

    unsigned NumberOfDoors;

    bool     HasAirCondition;

    long     Mileage;

};



int main( int argc, char * argv[] )

{

    Car SUV = { "Toyota", "4-Runner", 1998, 5, true, 57922 };





    cout << "Car Auctions - Vehicle Characteristics";

    cout << "\nYear:    " << SUV.Year;

    cout << "\nMileage: " << SUV.Mileage;

    cout << "\nMake:    " << SUV.Make;

    cout << "\nModel:   " << SUV.Model;

    cout << "\nDoors:   " << SUV.NumberOfDoors;

    cout << "\nHas A/C: " << SUV.HasAirCondition;



    return 0;

}

This would produce:

Car Auctions - Vehicle Characteristics

Year:    1998

Mileage: 57922

Make:    Toyota

Model:   4-Runner

Doors:   5

Has A/C: 1

Static Member Variables

A class can have static member variables. To declare such a variable, precede it with the static keyword. Here is an example:

#ifdef __BORLANDC__

  #pragma argsused

#endif



#include <iostream>

using namespace std;



struct Car

{

    string   Make;

    string   Model;

    int      Year;

    unsigned NumberOfDoors;

    long     Mileage;

    static int CarsCount;

};



int main( int argc, char * argv[] )

{

    Car vehicle;



    vehicle.Year  = 1998;

    vehicle.Mileage = 57922;

    vehicle.Make  = "Toyota";

    vehicle.Model = "4-Runner";

    vehicle.NumberOfDoors = 5;



    cout << "Car Auctions - Vehicle Characteristics";

    cout << "\nYear:    " << vehicle.Year;

    cout << "\nMileage: " << vehicle.Mileage;

    cout << "\nMake:    " << vehicle.Make;

    cout << "\nModel:   " << vehicle.Model;

    cout << "\nDoors:   " << vehicle.NumberOfDoors;



    return 0;

}

When you declare a member variable as static and when the application starts, the compiler creates a copy of that member. This member would be maintained by the compiler while the program is running. If you declare an instance of a class, like the above vehicle variable, the static member is not part of the (vehicle) object: the compiler creates and maintains the CarsCount member, whether you use it or not, whether you declare a Car variable or not.

After creating a class that contains a static member variable, if you intend to use that member, you should (in fact must) first initialize it with the value you want it to hold. Because a static member variable doesn't belong to an object, it must be initialized at file cope, by the class itself and not one of its instances.

To initialize a static member variable, outside of the class, enter its data type, followed by the name of the class, followed by the access operator "::", followed by the name of the member variable, followed by the assignment operator, and followed by a value. Like any other member variable, you can assign any appropriate value to a static member: you decide what value you want it to have. Here is an example:

#ifdef __BORLANDC__

  #pragma argsused

#endif



#include <iostream>

using namespace std;



struct Car

{

    string   Make;

    string   Model;

    int      Year;

    unsigned NumberOfDoors;

    long     Mileage;

    static int CarsCount;

};



int Car::CarsCount = 0;



int main( int argc, char * argv[] )

{

    Car vehicle;



    return 0;

}

After creating and initializing a static member variable, to access it outside of the class, you must qualify it with the name of the class itself and not a variable of that class. Here are two examples:

#ifdef __BORLANDC__

  #pragma argsused

#endif



#include <iostream>

using namespace std;



struct Car

{

    string   Make;

    string   Model;

    int      Year;

    unsigned NumberOfDoors;

    long     Mileage;

    static int CarsCount;

    static string ApplicationTitle;

};



int Car::CarsCount = 1;

string Car::ApplicationTitle = "Four-Corner Car Auctions";



int main( int argc, char * argv[] )

{

    Car vehicle;



    vehicle.Year  = 1998;

    vehicle.Mileage = 57922;

    vehicle.Make  = "Toyota";

    vehicle.Model = "4-Runner";

    vehicle.NumberOfDoors = 5;

    

    cout << Car::ApplicationTitle;

    cout << "\n - Vehicle Characteristics -";

    cout << "\nYear:    " << vehicle.Year;

    cout << "\nMileage: " << vehicle.Mileage;

    cout << "\nMake:    " << vehicle.Make;

    cout << "\nModel:   " << vehicle.Model;

    cout << "\nDoors:   " << vehicle.NumberOfDoors;

    cout << "\nCount:   " << Car::CarsCount;



    return 0;

}

This would produce:

Four-Corner Car Auctions

 - Vehicle Characteristics -

Year:    1998

Mileage: 57922

Make:    Toyota

Model:   4-Runner

Doors:   5

Count:   1

Always remember that a static member doesn't belong to a particular object, in this case vehicle. Therefore, to access it, you use the name of the class with the "::" operator. With this rule in mind, you can assign the value of a static member to a variable of the program. Here is an example:

#ifdef __BORLANDC__

  #pragma argsused

#endif



#include <iostream>

using namespace std;



struct Car

{

    string   Make;

    string   Model;

    int      Year;

    unsigned NumberOfDoors;

    long     Mileage;

    static int CarsCount;

    static string ApplicationTitle;

};



int Car::CarsCount = 1;

string Car::ApplicationTitle = "  Four-Corner Car Auctions";



int main( int argc, char * argv[] )

{

    Car vehicle;



    vehicle.Year  = 1998;

    vehicle.Mileage = 57922;

    vehicle.Make  = "Toyota";

    vehicle.Model = "4-Runner";

    vehicle.NumberOfDoors = 5;



    int numberOfCars = Car::CarsCount;



    cout << Car::ApplicationTitle;

    cout << "\n - Vehicle Characteristics -";

    cout << "\nYear:    " << vehicle.Year;

    cout << "\nMileage: " << vehicle.Mileage;

    cout << "\nMake:    " << vehicle.Make;

    cout << "\nModel:   " << vehicle.Model;

    cout << "\nDoors:   " << vehicle.NumberOfDoors;

    cout << "\nCount:   " << numberOfCars << endl;



    return 0;

}

You can decrement or increment it as you wish:

#ifdef __BORLANDC__

  #pragma argsused

#endif



#include <iostream>

using namespace std;



struct Car

{

    string   Make;

    string   Model;

    int      Year;

    unsigned NumberOfDoors;

    long     Mileage;

    static int CarsCount;

    static string ApplicationTitle;

};



int Car::CarsCount = 1;

string Car::ApplicationTitle = "  Four-Corner Car Auctions";



int main( int argc, char * argv[] )

{

    Car vehicle;



    vehicle.Year  = 1998;

    vehicle.Mileage = 57922;

    vehicle.Make  = "Toyota";

    vehicle.Model = "4-Runner";

    vehicle.NumberOfDoors = 5;



    cout << Car::ApplicationTitle;

    cout << "\n - Vehicle Characteristics -";

    cout << "\nYear:    " << vehicle.Year;

    cout << "\nMileage: " << vehicle.Mileage;

    cout << "\nMake:    " << vehicle.Make;

    cout << "\nModel:   " << vehicle.Model;

    cout << "\nDoors:   " << vehicle.NumberOfDoors;

    cout << "\nCount:   " << Car::CarsCount << endl;



    Car family;



    family.Mileage = 42885;

    family.Model = "Escort";

    family.NumberOfDoors = 4;

    family.Make = "Ford";

    family.Year = 2000;

    Car::CarsCount++;



    cout << "\n - Vehicle Characteristics -";

    cout << "\nYear:    " << family.Year;

    cout << "\nMileage: " << family.Mileage;

    cout << "\nMake:    " << family.Make;

    cout << "\nModel:   " << family.Model;

    cout << "\nDoors:   " << family.NumberOfDoors;

    cout << "\nCount:   " << Car::CarsCount << endl;



    return 0;

}

This would produce:

Four-Corner Car Auctions

 - Vehicle Characteristics -

Year:    1998

Mileage: 57922

Make:    Toyota

Model:   4-Runner

Doors:   5

Count:   1



 - Vehicle Characteristics -

Year:    2000

Mileage: 42885

Make:    Ford

Model:   Escort

Doors:   4

Count:   2

Other Techniques of Creating an Object

Classic C Styles

So far, to declare a variable of a class, we did this in the main() function. C++ supports another technique. You can declare a class when creating it. To do this, type the name of the class' variable between the closing curly bracket and the semi-colon. Here is an example:

#include <iostream>

using namespace std;



struct Car

{

	int      Year;

	unsigned NumberOfDoors;

	long     Mileage;

	char     DrivingCondition;

}vehicle;



int main()

{

	vehicle.Mileage = 42580;

	vehicle.NumberOfDoors = 4;

	vehicle.DrivingCondition = 'G';

	vehicle.Year = 2000;



	cout << "Car Characteristics\n";

	cout << "Year:      " << vehicle.Year << endl;

	cout << "Condition: " << vehicle.DrivingCondition << endl;

	cout << "Mileage:   " << vehicle.Mileage << endl;

	cout << "Doors:     " << vehicle.NumberOfDoors << endl;



	return 0;

}

Just like you would declare more than one variable of a class, you can declare many class instances using this technique, separating them with commas. Here are examples:

#include <iostream>

using namespace std;



struct Car

{

	int      Year;

	unsigned NumberOfDoors;

	long     Mileage;

	char     DrivingCondition;

}Sport, SUV, Bus;



int main()

{

	SUV.Mileage = 28446;

	SUV.NumberOfDoors = 5;

	SUV.DrivingCondition = 'D';

	SUV.Year = 2002;



	Sport.Mileage = 68208;

	Sport.NumberOfDoors = 2;

	Sport.DrivingCondition = 'E';

	Sport.Year = 1998;



	cout << "First Car Characteristics\n";

	cout << "Year:      " << SUV.Year << endl;

	cout << "Condition: " << SUV.DrivingCondition << endl;

	cout << "Mileage:   " << SUV.Mileage << endl;

	cout << "Doors:     " << SUV.NumberOfDoors << endl;

	

	cout << "\nSecond Car Characteristics\n";

	cout << "Year:      " << Sport.Year << endl;

	cout << "Condition: " << Sport.DrivingCondition << endl;

	cout << "Mileage:   " << Sport.Mileage << endl;

	cout << "Doors:     " << Sport.NumberOfDoors << endl;



	return 0;

}

This would produce:

First Car Characteristics

Year:      2002

Condition: D

Mileage:   28446

Doors:     5



Second Car Characteristics

Year:      1998

Condition: E

Mileage:   68208

Doors:     2

C programmers use another technique of creating classes. It consists of using the typedef keyword, which means you would define a type but set the actual name of the class between the closing curly bracket and the semi-colon. Here is an example of using that technique:

#include <iostream>

using namespace std;



typedef struct MobileEngine

{

	int      Year;

	unsigned NumberOfDoors;

	long     Mileage;

	char     DrivingCondition;

}Car;



int main()

{

	return 0;

}

Optionally, you can type a pseudo-name for the class on the first line. Here is an example: 

#include <iostream>

using namespace std;



typedef struct _car

{

	int      Year;

	unsigned NumberOfDoors;

	long     Mileage;

	char     DrivingCondition;

} Car;



int main()

{



	return 0;

}

After creating the class, the Car name is a class, not a variable. Therefore, when you want to use the object, you must and can declare an instance of the class using either the _car or the Car name. Here are examples:

References

As done for variables of primitive types, you can create a reference to a class using a declared variable. The same rule applies: the object that is used as a reference must have previously been initialized. Here is an example:

#ifdef __BORLANDC__

  #pragma argsused

#endif



#include <iostream>

using namespace std;



class Car

{

public:

    char     Make[40];

    char     Model[40];

    int      Year;

    unsigned NumberOfDoors;

    bool     HasAirCondition;

    long     Mileage;

};



int main( int argc, char * argv[] )

{

    Car vehicle = { "Toyota", "4-Runner", 1998, 5, true, 57922 };

    Car &SUV = vehicle;



    cout << "Car Auctions - Vehicle Characteristics";

    cout << "\nYear:    " << SUV.Year;

    cout << "\nMileage: " << SUV.Mileage;

    cout << "\nMake:    " << SUV.Make;

    cout << "\nModel:   " << SUV.Model;

    cout << "\nDoors:   " << SUV.NumberOfDoors;

    cout << "\nHas A/C: " << SUV.HasAirCondition;



    return 0;

}

Constant Objects

Just as you can create a constant of a built-in data type, you can also create a constant using a composite type. Always remember that the constant refers to a value that doesn't change and the constant value must be initialized with a known or already defined value. Here is an example:

Unions

Introduction

Like a structure, a union is created from combining other variables. To create a union, use the union keyword following the same syntax applied for a class, like this:

union SomeName {};

Like a structure, the members of a union are listed in its body. For example, to create a union that represents a student, you would type:

union Student

{

	char FullName[32];

	int Age;

	float AvgGrade;

};

Once the union is defined, you can declare it and use its members:

#include <iostream> 

using namespace std;



union Student

{

	int Age;

	double AvgGrade;

};



int main()

{

	Student Std;



	Std.Age = 12;

	cout << "Student Age = " << Std.Age;



	return 0;

}

This would produce:

Student Age = 12

Using a Union

When creating a struct or a class, each variable, treated as its own entity, occupies its assigned amount of space in memory. This is different with unions. All of the members of a union share the same memory space. After declaring a union object, instead of allocating memory for each member variable, the compiler assigns an amount of memory equal to the largest variable. Therefore, if you define a union that would represent a Student object as the above, the compiler would assign the same memory space to all members; and the compiler would find out which member needs the largest space, in this case that would be the double variable because a double variable occupies 8 Bytes. Consequently, a union can store only the value of only (excuse the repetition) one of its members at a time: you cannot simultaneously access the values of all members, at the same time (another repetition).

If you initialize all of the members of a union at the same time, the result is unreliable; since all members are using the same memory space, that space cannot accommodate all member values at the same time. The following version of our program produces such an unreliable result: 

#include <iostream> 

using namespace std;



union Student

{

	char Gender;

	int Age;

	float AvgGrade;

	double GradeSum;

};



int main()

{

	Student Std;



	Std.Gender = 'F';

	Std.Age = 14;

	Std.AvgGrade = 14.50;

	Std.GradeSum = 210;



	cout << "Characteristics of this student";

	cout << "\n\tGender = " << Std.Gender;

	cout << "\n\tAge = " << Std.Age;

	cout << "\n\tAverage = " << Std.AvgGrade;

	cout << "\n\tTotal = " << Std.GradeSum;



	return 0;

}

This would produce:

Characteristics of this student

Gender = Age = 0

Average = 0

Total = 210

As you can see, you should not substitute unions and structures. You should use a union when you can/must store any kind of variable in the same location, when variables sharing the same memory location is not an issue (or a danger). Avoid using unions in highly accessed and intensive value exchanges, such as calculations or data records. A union is usually created inside of another object.

Because all members of a union share the same memory location, a union is sometimes used to identify one value to use among many. Consider the following example:

#include <iostream>

using namespace std;



union HighSchool

{

	int        RegistrationStatus;

	double Salary;

};



int main()

{

	return 0;

}

In this case, two different, obviously unrelated variables are declared. The idea here is that only one of them would be used in the program, but which one. Imagine that you are starting a program for a high school. If the person whose information is being entered in the application is a student, then you need to specify his or her registration status, the eventual values would specify Registered, Pending, or Excluded. On the other hand, if the person whose information is being entered is a staff member such as a teacher, then the registration status is irrelevant but you may want to enter his or her salary, a piece of information that is irrelevant for a student. This example shows that, for one particular record being created, only one of these two values would be considered and the other would not apply.

Declaring Member Functions

Method Implementation

Local Implementation

To implement a method in the class where it is declared, use the same techniques we used to define regular functions. Here is an example:

#ifdef __BORLANDC__

  #pragma argsused

#endif



#include <iostream>

using namespace std;



struct Integer

{

    int  Max;

    int  Min;

    int  Size()

    {

        int length;



        length = sizeof(int);

        return length;

    }

    bool IsPositive();

    bool IsNegative();

};



int main( int argc, char * argv[])

{

    Integer number;



    cout << "Size = " << number.Size() << " bytes";

    return 0;

}

When a method is a class' member, it has access to the member variables of the same class. This means that you don't need to pass the variables as arguments: you can just use any of them as if it were supplied. Here is an example:

#ifdef __BORLANDC__

  #pragma argsused

#endif



#include <iostream>

using namespace std;



class Rectangle

{

public:

    double Length;

    double Height;



public:

    double Perimeter()

    {

        double p;



        p = (Length + Height) * 2;

        return p;

    }

    double Area();

};



int main( int argc, char * argv[] )

{

    Rectangle rect = { 48.35, 36.94 };



    cout << "Rectangle Characteristics";

    cout << "\nLength:    " << rect.Length;

    cout << "\nHeight:    " << rect.Height;

    cout << "\nPerimeter: " << rect.Perimeter();



    return 0;

}

This would produce:

Rectangle Characteristics

Length:    48.35

Height:    36.94

Perimeter: 170.58

Global Implementation

An alternative to local implementation of a method consists of defining it outside of the object. To access a method of a class when implementing it, instead of the member access operator “.”, you will use the scope resolution operator " ::".

To implement a method outside of the class, type the return value of the method, followed by the class' name, followed by the scope resolution operator “::”, followed by the method's name, followed by the arguments, if any, between parentheses, and finally define what the function should do, in its body. Here is an example: 

#ifdef __BORLANDC__

  #pragma argsused

#endif



#include <iostream>

using namespace std;



class Rectangle

{

public:

    double Length;

    double Height;



public:

    double Perimeter()

    {

        double p;



        p = (Length + Height) * 2;

        return p;

    }

    double Area();

};



double Rectangle::Area()

{

    double a = Height * Length;

    return a;

}



int main( int argc, char * argv[] )

{

    Rectangle rect = { 48.35, 36.94 };



    cout << "Rectangle Characteristics";

    cout << "\nLength:    " << rect.Length;

    cout << "\nHeight:    " << rect.Height;

    cout << "\nPerimeter: " << rect.Perimeter();

    cout << "\nArea:      " << rect.Area();



    return 0;

}

This would produce:

Rectangle Characteristics

Length:    48.35

Height:    36.94

Perimeter: 170.58

Area:      1786.05

Inline Methods

When studying functions, we learned that an assignment could be carried where it is being called. Such a function was referred to as inline. The same process can apply to a class’ member. 

To declare a class’ method as inline, precede its name with the inline keyword when declaring the method in the class. Here are examples:

#ifdef __BORLANDC__

  #pragma argsused

#endif



#include <iostream>

using namespace std;



class Rectangle

{

public:

    double Length;

    double Height;



public:

    double Perimeter()

    {

        double p;



        p = (Length + Height) * 2;

        return p;

    }

    inline double Area();

};



inline double Rectangle::Area()

{

    double a = Height * Length;

    return a;

}



int main( int argc, char * argv[] )

{

    Rectangle rect = { 48.35, 36.94 };



    cout << "Rectangle Characteristics";

    cout << "\nLength:    " << rect.Length;

    cout << "\nHeight:    " << rect.Height;

    cout << "\nPerimeter: " << rect.Perimeter();

    cout << "\nArea:      " << rect.Area();



    return 0;

}

You can choose which method(s) would be inline and which one(s) would not. When implementing the method, you can precede the method with the inline keyword. You can also omit the inline keyword in the class but use it when defining the method. For example, the following code will work just fine:

class Rectangle

{

public:

    double Length;

    double Height;



public:

    double Perimeter()

    {

        double p;



        p = (Length + Height) * 2;

        return p;

    }

    double Area();

};



inline double Rectangle::Area()

{

    double a = Height * Length;

    return a;

}

If you decide to implement a method locally (in the class), you have the option of implementing it as inline. You can precede it with, or omit, the inline keyword:

class Box

{

public:

	inline double CalcVolume()

	{

		return Length * Width * Height;

	}

	double CalcShoeSize()

	{

		return Length - 0.35;

	}

	void Display();



private:

	double Length;

	double Width;

	double Height;

	string Color;

};

On the other hand, if you omit the inline keyword, the C++ compiler would take care of it. Normally, any function implemented in the body of the class is considered inline.

Regardless of how the member methods of an object are implemented, any method can call another without using an access operator. This allows an object’s methods to exchange information among themselves easily. Furthermore, unlike regular functions where a function must be declared prior to another function calling it, the methods of a class don't follow that rule: one method can call another method before or after the other has been implemented, as long as it is defined somewhere in the program. Consider the following Show() method:

#ifdef __BORLANDC__

  #pragma argsused

#endif



#include <iostream>

using namespace std;



class Rectangle

{

public:

    void Show()

    {

        Height = 36.94;

        Length = 48.35;



        cout << "Rectangle Characteristics";

        cout << "\nLength:    " << Length;

        cout << "\nHeight:    " << Height;

        cout << "\nPerimeter: " << Perimeter();

        cout << "\nArea:      " << Area();

    }

public:

    double Length;

    double Height;



public:

    double Perimeter()

    {

        double p;



        p = (Length + Height) * 2;

        return p;

    }

    double Area();

};



inline double Rectangle::Area()

{

    double a = Height * Length;

    return a;

}



int main( int argc, char * argv[] )

{

    Rectangle rect;



    rect.Show();

    return 0;

}

Static Methods

Besides regular member functions, a class can also have static methods. To create a static method, type the static keyword to its left. Here is an example:

class Car

{

public:

    string   Make;

    string   Model;

    int      Year;

    unsigned NumberOfDoors;

    long     Mileage;

public:

    static int CarsCount;

    static string ApplicationTitle;

    static void Show();

};

As mentioned for static member variables, a static method doesn't belong to a particular instance of the class. This means that you don't need to declare a variable of a class in order to access a static method. A static method stands on its own so much that, if you want to access another member of the class, you must declare an instance of that class inside the static method. In other words, the other members of the same class are not automatically accessible from within the static method. Based on this, the above Show() method could be implemented as follows:

#ifdef __BORLANDC__

  #pragma argsused

#endif



#include <iostream>

using namespace std;



class Car

{

public:

    string   Make;

    string   Model;

    int      Year;

    unsigned NumberOfDoors;

    long     Mileage;

public:

    static int CarsCount;

    static string ApplicationTitle;

    static void Show()

    {

        Car vehicle;



        vehicle.Year  = 2004;

        vehicle.Mileage = 24012;

        vehicle.Make  = "Ford";

        vehicle.Model = "Crown Victoria";

        vehicle.NumberOfDoors = 4;



        cout << "\nYear:    " << vehicle.Year;

        cout << "\nMileage: " << vehicle.Mileage;

        cout << "\nMake:    " << vehicle.Make;

        cout << "\nModel:   " << vehicle.Model;

        cout << "\nDoors:   " << vehicle.NumberOfDoors;

    }

};



int Car::CarsCount = 1;

string Car::ApplicationTitle = "  Four-Corner Car Auctions";



int main( int argc, char * argv[] )

{



    cout << Car::ApplicationTitle;

    cout << "\n - Vehicle Characteristics -";

    Car::Show();

    cout << "\nCount:   " << Car::CarsCount << endl;



    return 0;

}

This would produce:

Four-Corner Car Auctions

 - Vehicle Characteristics -

Year:    2004

Mileage: 24012

Make:    Ford

Model:   Crown Victoria

Doors:   4

Count:   1

Notice that, inside of main(), you don't need a Car object (an instance of the Car class) in order to access the Show() method. Also, as mentioned already, you cannot implicitly access the non-static regular members of the class inside of the static method. For example, the following code will not work:

#ifdef __BORLANDC__

  #pragma argsused

#endif



#include <iostream>

using namespace std;



class Car

{

public:

    string   Make;

    string   Model;

    int      Year;

    unsigned NumberOfDoors;

    long     Mileage;

public:

    static int CarsCount;

    static string ApplicationTitle;

    static void Show()

    {

        cout << "\nYear:    " << Year;

        cout << "\nMileage: " << Mileage;

        cout << "\nMake:    " << Make;

        cout << "\nModel:   " << Model;

        cout << "\nDoors:   " << NumberOfDoors;

    }

};



int Car::CarsCount = 1;

string Car::ApplicationTitle = "  Four-Corner Car Auctions";



int main( int argc, char * argv[] )

{



    cout << Car::ApplicationTitle;

    cout << "\n - Vehicle Characteristics -";

    Car::Show();

    cout << "\nCount:   " << Car::CarsCount << endl;



    return 0;

}

As done with the other methods, you can implement a static method outside of the class. If you decide to do this, you must omit the static keyword. Here is an example:

#ifdef __BORLANDC__

  #pragma argsused

#endif



#include <iostream>

using namespace std;



class Car

{

public:

    string   Make;

    string   Model;

    int      Year;

    unsigned NumberOfDoors;

    long     Mileage;

public:

    static int CarsCount;

    static string ApplicationTitle;

    static void Show();

};



int Car::CarsCount = 1;

string Car::ApplicationTitle = "  Four-Corner Car Auctions";



void Car::Show()

{

    Car vehicle;



    vehicle.Year  = 2004;

    vehicle.Mileage = 24012;

    vehicle.Make  = "Ford";

    vehicle.Model = "Crown Victoria";

    vehicle.NumberOfDoors = 4;



    cout << "\nYear:    " << vehicle.Year;

    cout << "\nMileage: " << vehicle.Mileage;

    cout << "\nMake:    " << vehicle.Make;

    cout << "\nModel:   " << vehicle.Model;

    cout << "\nDoors:   " << vehicle.NumberOfDoors;

}



int main( int argc, char * argv[] )

{



    cout << Car::ApplicationTitle;

    cout << "\n - Vehicle Characteristics -";

    Car::Show();

    cout << "\nCount:   " << Car::CarsCount << endl;



    return 0;

}

To access a static member from a static method, you don't have to qualify it: its name would be enough. Consider the following example:

#ifdef __BORLANDC__

  #pragma argsused

#endif



#include <iostream>

using namespace std;



class Car

{

public:

    string   Make;

    string   Model;

    int      Year;

    unsigned NumberOfDoors;

    long     Mileage;

public:

    static int CarsCount;

    static string ApplicationTitle;

    static void Show();

};



int Car::CarsCount = 1;

string Car::ApplicationTitle = "  Four-Corner Car Auctions";



void Car::Show()

{

    Car vehicle;



    vehicle.Year  = 2004;

    vehicle.Mileage = 24012;

    vehicle.Make  = "Ford";

    vehicle.Model = "Crown Victoria";

    vehicle.NumberOfDoors = 4;



    cout << ApplicationTitle;

    cout << "\n - Vehicle Characteristics -";

    cout << "\nYear:    " << vehicle.Year;

    cout << "\nMileage: " << vehicle.Mileage;

    cout << "\nMake:    " << vehicle.Make;

    cout << "\nModel:   " << vehicle.Model;

    cout << "\nDoors:   " << vehicle.NumberOfDoors;

    cout << "\nCount:   " << CarsCount << endl;

}



int main( int argc, char * argv[] )

{

    Car::Show();



    return 0;

}

Notice that the only members that are accessed in the static method without being qualified are the static member variables of the same class.

Methods and Arguments 

Constant Arguments

In previous lessons, we learned that when a function received an argument that it didn't modify, the argument should be declared as constant. This allows the compiler to make sure that the argument would not be modified. The same technique applies to an argument used by a method of a class.

To declare an argument of an object’s method as constant, type the const keyword on the left of the argument’s data type. Consider a Box object as follows:

We would like to know the area of each side because different things will be displayed on each side and we need to know how much space is available. If we were dealing with a rectangle, we would just declare an area method as follows:

double FaceArea();

On a box (rectangular parallelepiped), we have three rectangle types that represent the six faces. We can declare one method that takes any two sides and calculates their area. Such a method would be declared as follows:

double FaceArea(double side1, double side2);

We can define it as follows:

class Box

{

public:

    double FaceArea(double length, double height)

    {

        double area = length * height;

        return area;

    }

};

Notice that the method doesn't modify the values of the arguments it uses. Therefore, they should be declared as constants. To declare each as constant, you would change the declaration of the method as follows:

double Area(const double side1, const double side2);

Here is an example of a class with methods that take constant arguments:

#ifdef __BORLANDC__

  #pragma argsused

#endif



#include <iostream>

using namespace std;



class Box

{

public:

    double FaceArea(double length, double height)

    {

        double area = length * height;

        return area;

    }

    double TopArea(double length, double width)

    {

        return length * width;

    }



    double RightArea(double height, double width)

    {

        return height * width;

    }

};



int main( int argc, char * argv[] )

{

    Box sampleBox;

    const double L = 35.85;

    const double H = 28.46;

    const double W = 22.08;



    cout << " -=- Box Areas -=-";

    cout << "\nTop:   " << sampleBox.TopArea(L, W);

    cout << "\nFace:  " << sampleBox.FaceArea(L, H);

    cout << "\nRight: " << sampleBox.RightArea(H, W);



    return 0;

}

This would produce:

-=- Box Areas -=-

Top:   791.568

Face:  1020.29

Right: 628.397

Constant Methods

Some of the methods of an object, though using member variables of the same object, don't modify them. Consider the following program:

#ifdef __BORLANDC__

  #pragma argsused

#endif



#include <iostream>

using namespace std;



class Box

{

public:

    double Length;

    double Width;

    double Height;

public:

    double FaceArea()

    {

        return Length * Height;

    }

    double TopArea()

    {

        return Length * Width;

    }



    double RightArea()

    {

        return Height * Width;

    }

};



int main( int argc, char * argv[] )

{

    Box sampleBox;

    sampleBox.Length = 35.85;

    sampleBox.Height = 28.46;

    sampleBox.Width = 22.08;



    cout << " -=- Box Characteristics -=-";

    cout << "\nLength:       " << sampleBox.Length;

    cout << "\nWidth:        " << sampleBox.Width;

    cout << "\nHeight:       " << sampleBox.Height;

    cout << "\nTop Area:   " << sampleBox.TopArea();

    cout << "\nFace Area:  " << sampleBox.FaceArea();

    cout << "\nRight Area: " << sampleBox.RightArea();



    return 0;

}

Notice that the methods that calculate the areas don't modify the values of the member variables they are using. If a method doesn't modify the member variables of its class, the method should be declared and implemented as constant.

To declare a method as a constant, add the const keyword to the right side of the method when declaring and when implementing it. Here are examples:

#ifdef __BORLANDC__

  #pragma argsused

#endif



#include <iostream>

using namespace std;



class Box

{

public:

    double Length;

    double Width;

    double Height;

public:

    double FaceArea() const;

    double TopArea() const

    {

        return Length * Width;

    }



    double RightArea() const

    {

        return Height * Width;

    }

};



double Box::FaceArea() const

{

    return Length * Height;

}



int main( int argc, char * argv[] )

{

    Box sampleBox;

    sampleBox.Length = 35.85;

    sampleBox.Height = 28.46;

    sampleBox.Width = 22.08;



    cout << " -=- Box Characteristics -=-";

    cout << "\nLength:     " << sampleBox.Length;

    cout << "\nWidth:      " << sampleBox.Width;

    cout << "\nHeight:     " << sampleBox.Height;

    cout << "\nTop Area:   " << sampleBox.TopArea();

    cout << "\nFace Area:  " << sampleBox.FaceArea();

    cout << "\nRight Area: " << sampleBox.RightArea();



    return 0;

}

If you decide to define constant methods locally (inline), the only difference is to remove the semi-colon of the end of the declaration and define the method normally.

You can also reinforce the constancy of the methods by starting them with the const keyword. The program would still produce the same result.

Private Methods

At this time, we know that one of the responsibilities of a member method of an object is to carry assignments. Another job performed by methods is to communicate with the clients of an object. As you might have found out, some of the methods of an object are exclusively used to carry assignments. The external functions or other objects don't call such methods and don't communicate with them. If you create a class and know that a particular method is not used to transfer data to the client methods, you can declare such a method as private, just like you would do with a member variable.

To declare a method as private, include it in the private section of the object. To implement it, follow the same rules we have learned about implementing the methods of an object. The biggest difference you must keep in mind (which will also be very important when we learn about inheritance) is that this function method is not available to the outside world. Here is an example:

#ifdef __BORLANDC__

  #pragma argsused

#endif



#include <iostream>

using namespace std;



class Box

{

public:

    double Length;

    double Width;

    double Height;

private:

    const double FaceArea() const;

    const double TopArea() const

    {

        return Length * Width;

    }



    const double RightArea() const

    {

        return Height * Width;

    }



public:

    void Show()

    {

        cout << "\nLength:     " << Length;

        cout << "\nWidth:      " << Width;

        cout << "\nHeight:     " << Height;

        cout << "\nTop Area:   " << TopArea();

        cout << "\nFace Area:  " << FaceArea();

        cout << "\nRight Area: " << RightArea();

    }

};



const double Box::FaceArea() const

{

    return Length * Height;

}



int main( int argc, char * argv[] )

{

    Box sampleBox;

    sampleBox.Length = 35.85;

    sampleBox.Height = 28.46;

    sampleBox.Width = 22.08;



    cout << " -=- Box Characteristics -=-";

    sampleBox.Show();



    return 0;

}

C++ Project Files and Classes 

Introduction

An object is made of the material that composes it and the actual structure of the object, which defines how the object is built and used. This means that a class is made of two parts: its building block and its definition. These two parts of a class can be kept in different files that have access to each other.

Class' Header File

The building block or foundation of an class is made of the class' creation, listing all of its members. This foundation can be created in a file called a header file, similar to the one we learned when studying functions. The name of the file follows the naming rules we have applied so far. The header file has an extension of .h.

You create an object’s header file the same we did when studying functions. To create the header file, you can just define the class as an object. If some of the members are defined in files outsde of the object, include their header file(s).

Here is what our Box header file would look like:

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

// Box.h

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

#if !defined(Box_H)

#define Box_H



class Box

{

public:

    double Length;

    double Width;

    double Height;

private:

    const double FaceArea() const;

    const double TopArea() const;

    const double RightArea() const;



public:

    void Show();

};



#endif // Box_H

Class Source Code

The file used to implement the class is called a source file. It can be used to define the assignments of the class. A source file should at least start with a line that specifies the name of the header file that it is implementing. Since this file is usually created in the same project, it is specified with an include line that encloses the file name with double-quotes. An example would be:

#include "Book.h"

The main area of the file is made of the class' implementation. Here is what the source file of our Box would look like:

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

// Unit1.cpp

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



#include <iostream>

#include "box.h"



using namespace std;



const double Box::FaceArea() const

{

    return Length * Height;

}



const double Box::TopArea() const

{

    return Length * Width;

}



const double Box::RightArea() const

{

    return Height * Width;

}



void Box::Show()

{

    cout << "\nLength:     " << Length;

    cout << "\nWidth:      " << Width;

    cout << "\nHeight:     " << Height;

    cout << "\nTop Area:   " << TopArea();

    cout << "\nFace Area:  " << FaceArea();

    cout << "\nRight Area: " << RightArea();

}

The main() function of our box project is reduced to simply calling the appropriate Box method member:

#ifdef __BORLANDC__

  #pragma argsused

#endif



#include <iostream>

#include "box.h"



using namespace std;



int main( int argc, char * argv[] )

{

    Box sampleBox;

    sampleBox.Length = 35.85;

    sampleBox.Height = 28.46;

    sampleBox.Width = 22.08;



    cout << " -=- Box Characteristics -=-";

    sampleBox.Show();



    return 0;

}

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

#include <iostream> 

using namespace std;

struct TBrick

{

public:

    void Initializer(double l, double h, double w);

    double Volume() const;

    void Properties() const;

private:

    double Length;

    double Height;

    double Width;

};

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

void TBrick::Initializer(double l, double h, double w)

{

    Length = l;

    Height = h;

    Width = w;

}

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

double TBrick::Volume() const

{

    return Length * Height * Width;

}

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

void  TBrick::Properties() const

{

    cout << "Red Brick Properties";

    cout << setiosflags(ios::fixed) << setprecision(2);

    cout << "\nLength = " << Length;

    cout << "\nHeight = " << Height;

    cout << "\nThickness = " << Width;

    cout << "\nVolume = " << Volume() << "\n";

}

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

int main()

{

    TBrick RedBrick;



    RedBrick.Initializer(124.45, 56.25, 32.55);

    RedBrick.Properties();

    

    return 0;

}

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

Red Brick Properties

Length = 124.45

Height = 56.25

Thickness = 32.55

Volume = 227860.17



Press any key to continue...

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

int main()

{

    double length, height, width;

    TBrick GoneSand;



    cout << "Before building this brick, provide its dimensions\n";

    cout << "Length: ";

    cin >> length;

    cout << "Height: ";

    cin >> height;

    cout << "Width:  ";

    cin >> width;

    cout << endl;



    GoneSand.Initializer(length, height, width);

    GoneSand.Properties();



    

    

    return 0;

}

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

Before building this brick, provide its dimensions

Length: 8.95

Height: 6.85

Width:  6.25



Red Brick Properties

Length    = 8.95

Height    = 6.85

Thickness = 6.25

Volume    = 383.17



Press any key to continue...

Initializing an Object

Default Constructor

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

#include <iostream>

using namespace std;

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



struct TBook

{

public:

    TBook();    // Constructor

};

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

TBook::TBook()

{

    cout << "I see a book...\n";

}

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

int main()

{

    TBook B;



    return 0;

}

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

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

#ifndef BricksH

#define BricksH



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

struct TBrick

{

public:

     TBrick(); // Empty Constructor

    void  setDimensions(double l, double h, double t);

    void  Initializer(double l, double h, double w);

    double  CementVolume();

    void  ShowProperties();

private:

    double Length;

    double Height;

    double Thickness;

};

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

#endif

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

#include <iostream>

#include <iomanip>

using namespace std;



#include "Bricks.h"



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





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

 TBrick::TBrick()

{

    //TODO: Add your source code here

}

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

void  TBrick::setDimensions(double l, double h, double t)

{

    Length = l;

    Height = h;

    Thickness = t;

}

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

double  TBrick::CementVolume()

{

    double Enclosure = 0.50; // This includes both walls of the brick itself

    double HoleLength = Length - 0.75; // Including both holes

    double HoleThickness = Thickness - Enclosure;

    double HoleVolume = HoleLength * HoleThickness * Height;

    double TotalVolume = Length * Height * Thickness;

    double ValidVolume = TotalVolume - HoleVolume;



    return ValidVolume;

}

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

void  TBrick::ShowProperties()

{

    cout << "Foundation Brick Properties";

    cout << setiosflags(ios::fixed) << setprecision(2);

    cout << "\nLength    = " << Length; cout

         << "\nHeight    = " << Height;

    cout << "\nThickness = " << Thickness;

    cout << "\nCement Volume = " << CementVolume() << "\n";

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

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

#include <iostream>

using namespace std;

#include "Bricks.h"

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



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

int main()

{

    TBrick Foundation;



    Foundation.setDimensions(4.24, 3.55, 3.45);

    Foundation.ShowProperties();



    

    

    return 0;

}

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

Foundation Brick Properties

Length    = 4.24

Height    = 3.55

Thickness = 3.45

Cement Volume = 15.38



Press any key to continue...

Using the Default Constructor

The Constructor Initializer

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

#ifndef BricksH

#define BricksH



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

struct TBrick

{

public:

     TBrick();    // Default Constructor

     TBrick(double l, double h, double t);

    double  CementVolume();

    void  ShowProperties();

private:

    double Length;

    double Height;

    double Thickness;

};

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

#endif

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

#include <iostream>

#include <iomanip>

using namespace std;



#include "Bricks.h"



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





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

 TBrick::TBrick()

{

    //TODO: Add your source code here

}

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

 TBrick::TBrick(double l, double h, double t)

{

    Length = l;

    Height = h;

    Thickness = t;

}

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

double  TBrick::CementVolume()

{

    double Enclosure = 0.50; // This includes both walls of the brick itself

    double HoleLength = Length - 0.75; // Including both holes

    double HoleThickness = Thickness - Enclosure;

    double HoleVolume = HoleLength * HoleThickness * Height;

    double TotalVolume = Length * Height * Thickness;

    double ValidVolume = TotalVolume - HoleVolume;



    return ValidVolume;

}

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

void  TBrick::ShowProperties()

{

    cout << "Foundation Brick Properties";

    cout << setiosflags(ios::fixed) << setprecision(2);

    cout << "\nLength    = " << Length; cout

         << "\nHeight    = " << Height;

    cout << "\nThickness = " << Thickness;

    cout << "\nCement Volume = " << CementVolume() << "\n";

}

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

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



#include <iostream>

using namespace std;

#include "Bricks.h"

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



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

int main()

{

    TBrick Solid(4.15, 3.35, 3.05);

    Solid.ShowProperties();



    

    

    return 0;

}

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

Foundation Brick Properties

Length    = 4.15

Height    = 3.35

Thickness = 3.05

Cement Volume = 13.36



Press any key to continue...

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

#ifndef BricksH

#define BricksH



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

struct TBrick

{

public:

     TBrick();    // Default Constructor

     TBrick(double l, double h, double t);

    void  setLength(double l);

    void  setHeight(double h);

    void  setThickness(double t);

    double  CementVolume();

    void  ShowProperties();

private:

    double Length;

    double Height;

    double Thickness;

};

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

#endif

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

#include <iostream>

#include <iomanip>

using namespace std;



#include "Bricks.h"



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





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

 TBrick::TBrick()

{

    //TODO: Add your source code here

}

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

 TBrick::TBrick(double l, double h, double t)

{

    setLength(l);

    setHeight(h);

    setThickness(t);

}

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

void  TBrick::setLength(double l)

{

    Length = l;

}

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

void  TBrick::setHeight(double h)

{

   Height = h;

}

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

void  TBrick::setThickness(double t)

{

    Thickness = t;

}

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

double  TBrick::CementVolume()

{

    double Enclosure = 0.50; // This includes both walls of the brick itself

    double HoleLength = Length - 0.75; // Including both holes

    double HoleThickness = Thickness - Enclosure;

    double HoleVolume = HoleLength * HoleThickness * Height;

    double TotalVolume = Length * Height * Thickness;

    double ValidVolume = TotalVolume - HoleVolume;



    return ValidVolume;

}

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

void  TBrick::ShowProperties()

{

    cout << "Foundation Brick Properties";

    cout << setiosflags(ios::fixed) << setprecision(2);

    cout << "\nLength    = " << Length; cout

         << "\nHeight    = " << Height;

    cout << "\nThickness = " << Thickness;

    cout << "\nCement Volume = " << CementVolume() << "\n";

}

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

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



#include <iostream>

using namespace std;

#include "Bricks.h"

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



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

int main()

{

    TBrick Solid(4.15, 3.35, 3.05);

    Solid.ShowProperties();



    

    

    return 0;

}

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

Foundation Brick Properties

Length    = 4.15

Height    = 3.35

Thickness = 3.05

Cement Volume = 13.36



Press any key to continue...

Initializing With the Constructor

Constructor Overloading

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

struct TBrick

{

public:

     TBrick();

    double  CementVolume();

    void  ShowProperties();

private:

    double Length;

    double Height;

    double Thickness;

};

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

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

#include <iostream>

using namespace std;



#include "Bricks.h"

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



 TBrick::TBrick()

{

    //TODO: Add your source code here

}

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

double  TBrick::CementVolume()

{

    double Enclosure = 0.50; // This includes both walls of the brick itself

    double HoleLength = Length - 0.75; // Including both holes double

    double HoleThickness = Thickness - Enclosure;

    double HoleVolume = HoleLength * HoleThickness * Height;

    double TotalVolume = Length * Height * Thickness;

    double ValidVolume = TotalVolume - HoleVolume;



    return ValidVolume;

}

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

void  TBrick::ShowProperties()

{

    cout << "Foundation Brick Properties";

    cout << "\nLength = " << Length;

    cout << "\nHeight = " << Height;

    cout << "\nThickness = " << Thickness;

    cout << "\nCement Volume = " << CementVolume() << "\n";

}

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

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

#include <iostream>

using namespace std;

#include "Bricks.h"

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





int main()

{

    TBrick Mango;



    Mango.ShowProperties();



    

    

    return 0;

}

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

Foundation Brick Properties

Length = nan

Height = 2.53988e-314

Thickness = 2.122e-314

Cement Volume = nan



Press any key to continue...

 TBrick::TBrick()

{

    Length = 4.15;

    Height = 3.55;

    Thickness = 3.75;

}

Foundation Brick Properties

Length = 4.15

Height = 3.55

Thickness = 3.75

Cement Volume = 16.0194



Press any key to continue...

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

#ifndef BricksH

#define BricksH



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

class TBrick

{

public:

     TBrick();

     TBrick(double L);

    double  CementVolume();

    void  ShowProperties();

private:

    double Length;

    double Height;

    double Thickness;

};

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

#endif

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

#include <iostream>

using namespace std;



#include "Bricks.h"

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



 TBrick::TBrick()

{

    Length = 4.15;

    Height = 3.55;

    Thickness = 3.75;

}

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

 TBrick::TBrick(double L)

{

    Length = L;

    Height = 5.25;

    Thickness = 4.55;

}

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

double  TBrick::CementVolume()

{

    ...

}

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

void  TBrick::ShowProperties()

{

    ...

}

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

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

#include <iostream>

using namespace std;

#include "Bricks.h"

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





int main()

{

    // Brick with default dimensions

    TBrick Mather;

    Mather.ShowProperties();

    cout << endl;



    // Brick with a supplied length

    TBrick BedTimer(5.55);

    BedTimer.ShowProperties();



    

    

    return 0;

}

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

Foundation Brick Properties

Length = 4.15

Height = 3.55

Thickness = 3.75

Cement Volume = 16.0194



Foundation Brick Properties

Length = 5.55

Height = 5.25

Thickness = 4.55

Cement Volume = 30.5156



Press any key to continue...

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

#ifndef BricksH

#define BricksH



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

class TBrick

{

public:

     TBrick();

     TBrick(double L);

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

    double  CementVolume();

    void  ShowProperties();

private:

    double Length;

    double Height;

    double Thickness;

};

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

#endif

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

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

{

    Length = L;

    Height = h;

    Thickness = t;

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

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

#include <iostream>

using namespace std;

#include "Bricks.h"

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





int main()

{

    // Brick with default 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();



    

    

    return 0;

}

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

Foundation Brick Properties

Length = 4.15

Height = 3.55

Thickness = 3.75

Cement Volume = 16.0194



Foundation Brick Properties

Length = 5.55

Height = 5.25

Thickness = 4.55

Cement Volume = 30.5156



Foundation Brick Properties

Length = 3.25

Height = 3.05

Thickness = 3.25

Cement Volume = 11.2469



Press any key to continue...

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

#ifndef BricksH

#define BricksH



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

class TBrick

{

public:

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

    double  CementVolume();

    void  ShowProperties();

private:

    double Length;

    double Height;

    double Thickness;

};

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

#endif

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

#include <iostream>

using namespace std;

#include "Bricks.h"

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





int main()

{

    // The following (default) constructor is not available

    TBrick GrayMatte;

    GrayMatte.ShowProperties();

    cout << endl;



    // A Brick with set dimensions

    TBrick Fantasma(3.25, 3.05, 3.25);

    Fantasma.ShowProperties();



    

    

    return 0;

}

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

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

#ifndef BricksH

#define BricksH



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

class TBrick

{

public:

     TBrick();

     TBrick(double L);

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

    double  getLength() const;

    void  setLength(const double l);

    double  getHeight() const;

    void  setHeight(const double h);

    double  getThickness() const;

    void  setThickness(const double t);

    double  CementVolume();

    void  ShowProperties();

private:

    double Length;

    double Height;

    double Thickness;

};

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

#endif

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

#include <iostream>

#include <iomanip>

using namespace std;



#include "Bricks.h"

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



 TBrick::TBrick()

{

    Length = 4.15;

    Height = 3.55;

    Thickness = 3.75;

}

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

 TBrick::TBrick(double L)

{

    Length = L;

    Height = 5.25;

    Thickness = 4.55;

}

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

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

{

    Length = L;

    Height = h;

    Thickness = t;

}

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

double  TBrick::getLength() const

{

    return Length;

}

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

void  TBrick::setLength(const double l)

{

    Length = l;

}

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

double  TBrick::getHeight() const

{

    return Height;

}

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

void  TBrick::setHeight(const double h)

{

    Height = h;

}

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

double  TBrick::getThickness() const

{

    return Thickness;

}

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

void  TBrick::setThickness(const double t)

{

    Thickness = t;

}

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

double  TBrick::CementVolume()

{

    double Enclosure = 0.50; // This includes both walls of the brick itself

    double HoleLength = Length - 0.75; // Including both holes double

    double HoleThickness = Thickness - Enclosure;

    double HoleVolume = HoleLength * HoleThickness * Height;

    double TotalVolume = Length * Height * Thickness;

    double ValidVolume = TotalVolume - HoleVolume;



    return ValidVolume;

}

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

void  TBrick::ShowProperties()

{

    cout << "Foundation Brick Properties";

    cout << setiosflags(ios::fixed) << setprecision(2);

    cout << "\nLength = " << Length;

    cout << "\nHeight = " << Height;

    cout << "\nThickness = " << Thickness;

    cout << "\nCement Volume = " << CementVolume() << "\n";

}

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

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

#include <iostream>

using namespace std;

#include "Bricks.h"

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





int main()

{

    // Brick with default dimensions

    TBrick GrayMatte;

    GrayMatte.ShowProperties();

    cout << endl;



    // Brick with a supplied length

    TBrick OldTimer(5.55);

    OldTimer.ShowProperties();

    cout << endl;



    // A Brick with user supplied dimensions

    double len, hgt, thk;

    cout << "\nEnter the dimensions of the brick\n";

    cout << "Length: ";

    cin >> len;

    cout << "Height: ";

    cin >> hgt;

    cout << "Thickness: ";

    cin >> thk;

    cout << endl;

    TBrick Fantasma(len, hgt, thk);

    Fantasma.ShowProperties();



    

    

    

    return 0;

}

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

Foundation Brick Properties

Length = 4.15

Height = 3.55

Thickness = 3.75

Cement Volume = 16.02



Foundation Brick Properties

Length = 5.55

Height = 5.25

Thickness = 4.55

Cement Volume = 30.52





Enter the dimensions of the brick

Length: 6.25

Height: 5.85

Thickness: 4.55



Foundation Brick Properties

Length = 6.25

Height = 5.85

Thickness = 4.55

Cement Volume = 36.05



Press any key to continue...

Overloading the Constructor

Techniques of Initializing With a Constructor

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

#ifndef BricksH

#define BricksH



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

class TBrick

{

public:

     TBrick(double L, double h, double t) { Length = L; Height = h; Thickness = t; }

    double  getLength() const;

    void  setLength(const double l);

    double  getHeight() const;

    void  setHeight(const double h);

    double  getThickness() const;

    void  setThickness(const double t);

    double  CementVolume();

    void  ShowProperties();

private:

    double Length;

    double Height;

    double Thickness;

};

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

#endif

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

#ifndef BricksH

#define BricksH



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

class TBrick

{

public:

     TBrick() : Length(3.25), Height(2.55), Thickness(3.55) {}

     TBrick(double L, double h, double t) { Length = L; Height = h; Thickness = t; }

    double  getLength() const;

    void  setLength(const double l);

    double  getHeight() const;

    void  setHeight(const double h);

    double  getThickness() const;

    void  setThickness(const double t);

    double  CementVolume();

    void  ShowProperties();

private:

    double Length;

    double Height;

    double Thickness;

};

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

#endif

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

#include <iostream>

#include <iomanip>

using namespace std;



#include "Bricks.h"

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



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

double  TBrick::getLength() const

{

    return Length;

}

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

void  TBrick::setLength(const double l)

{

    Length = l;

}

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

double  TBrick::getHeight() const

{

    return Height;

}

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

void  TBrick::setHeight(const double h)

{

    Height = h;

}

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

double  TBrick::getThickness() const

{

    return Thickness;

}

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

void  TBrick::setThickness(const double t)

{

    Thickness = t;

}

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

double  TBrick::CementVolume()

{

    double Enclosure = 0.50; // This includes both walls of the brick itself

    double HoleLength = Length - 0.75; // Including both holes double

    double HoleThickness = Thickness - Enclosure;

    double HoleVolume = HoleLength * HoleThickness * Height;

    double TotalVolume = Length * Height * Thickness;

    double ValidVolume = TotalVolume - HoleVolume;



    return ValidVolume;

}

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

void  TBrick::ShowProperties()

{

    cout << "Foundation Brick Properties";

    cout << setiosflags(ios::fixed) << setprecision(2);

    cout << "\nLength = " << Length;

    cout << "\nHeight = " << Height;

    cout << "\nThickness = " << Thickness;

    cout << "\nCement Volume = " << CementVolume() << "\n";

}

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

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

#include <iostream>

using namespace std;

#include "Bricks.h"

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





int main()

{

    TBrick Lott;

    Lott.ShowProperties();



    

    

    return 0;

}

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

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

#ifndef BricksH

#define BricksH



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

class TBrick

{

public:

     TBrick() : Length(0), Height(0), Thickness(0) {}

     TBrick(double L) : Length(L), Height(4.35), Thickness(3.05) {}

     TBrick(double L, double h, double t) : Length(L), Height(h), Thickness(t) {}

    double  getLength() const;

    void  setLength(const double l);

    double  getHeight() const;

    void  setHeight(const double h);

    double  getThickness() const;

    void  setThickness(const double t);

    double  CementVolume();

    void  ShowProperties();

private:

    double Length;

    double Height;

    double Thickness;

};

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

#endif

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

#include <iostream>

using namespace std;

#include "Bricks.h"

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





int main()

{

    // Calling the object using the default constructor

    TBrick Lott;

    Lott.ShowProperties();



    // This time, the program will use the constructor that has one argument

    TBrick Motto(6.12);

    Motto.ShowProperties();



    // The following object is supplied with arguments

    TBrick Hott(5.25, 3.55, 3.55);

    Hott.ShowProperties();



    

    

    return 0;

}

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

Foundation Brick Properties

Length = 0.00

Height = 0.00

Thickness = 0.00

Cement Volume = 0.00

Foundation Brick Properties

Length = 6.12

Height = 4.35

Thickness = 3.05

Cement Volume = 21.63

Foundation Brick Properties

Length = 5.25

Height = 3.55

Thickness = 3.55

Cement Volume = 17.44



Press any key to continue...

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

#ifndef BricksH

#define BricksH



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

class TBrick

{

public:

     TBrick();

     TBrick(double L);

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

    double  getLength() const;

    void  setLength(const double l);

    double  getHeight() const;

    void  setHeight(const double h);

    double  getThickness() const;

    void  setThickness(const double t);

    double  CementVolume();

    void  ShowProperties();

private:

    double Length;

    double Height;

    double Thickness;

};

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

#endif

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

#include <iostream>

#include <iomanip>

using namespace std;



#include "Bricks.h"

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



 TBrick::TBrick() : Length(0), Height(0), Thickness(0)

{

}

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

 TBrick::TBrick(double L) : Length(L), Height(4.35), Thickness(3.05)

{

}

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

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

    : Length(L), Height(h), Thickness(t)

{

}

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

. . .

Initializing With Constructors

The Copy Constructor

Copying an Object

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

#include <iostream>

using namespace std;

#include "Bricks.h"

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





int main()

{

    // Declaring one brick

    TBrick Hott(5.25, 3.55, 3.55);

    Hott.ShowProperties();

    cout << endl;



    // Assigning one brick to another

    TBrick Bosco = Hott;

    Bosco.ShowProperties();



    

    

    return 0;

}

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

Foundation Brick Properties

Length = 5.25

Height = 3.55

Thickness = 3.55

Cement Volume = 17.44



Foundation Brick Properties

Length = 5.25

Height = 3.55

Thickness = 3.55

Cement Volume = 17.44



Press any key to continue...

Using a Copy Constructor

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

#include <iostream>

#include <iomanip>

using namespace std;

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



int main()

{

    // Assigning a value to a variable using the = sign

    int CheeseSteak = 2;

    // Assigning a value using the parenthesis

    int TunaSalad(4);

    // Assigning one variable to another

    int TurkeyHam(TunaSalad);

    // Assignment with parenthesis

    double PriceCS(3.12); 

    double PriceTS = 2.95;

    // Assigning the price of one item to another

    double PriceTH(PriceTS);

    

    double TotalCS, TotalTS, TotalTH;

    TotalCS = CheeseSteak * PriceCS;

    TotalTS = TunaSalad * PriceTS;

    TotalTH = TurkeyHam * PriceTH;



    cout << "Total Order\n";

    cout << setiosflags(ios::fixed) << setprecision(2);

    cout << CheeseSteak << " orders of Cheese Steak, Price = $"

         << TotalCS << "\n";

    cout << TunaSalad << " orders of Tuna Salad, Price = $"

         << TotalTS << endl;

    cout << TurkeyHam << " orders of Turkey Ham, Price = $" << TotalTH << endl;



    

    

    return 0;

}

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

Total Order

2 orders of Cheese Steak, Price = $6.24

4 orders of Tuna Salad, Price = $11.80

4 orders of Turkey Ham, Price = $11.80



Press any key to continue...

ObjectName(ObjectName& Name);

ObjectName(const ObjectName& Name);

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

#ifndef BricksH

#define BricksH

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

class TBrick

{

public:

     TBrick();

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

     TBrick(const TBrick &Brk);

    double  getLength() const;

    void  setLength(const double l);

    double  getHeight() const;

    void  setHeight(const double h);

    double  getThickness() const;

    void  setThickness(const double t);

    double  CementVolume();

    void  ShowProperties();

private:

    double Length;

    double Height;

    double Thickness;

};

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

#endif

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

 TBrick::TBrick(const TBrick& B)

{

    Length    = B.Length;

    Height    = B.Height;

    Thickness = B.Thickness;

}

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

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

#include <iostream>

#include <iomanip>

using namespace std;

#include "Bricks.h"

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



int main()

{

    TBrick  Beam(7.25, 4.85, 5.15), Hoyt;

    Beam.ShowProperties();

    cout << endl;



    // Create the other brick similar to the first

    // Assigning using the assignment operator

    Hoyt = Beam;

    Hoyt.ShowProperties();

    cout << endl;



    // Assigning using the parentheses

    TBrick Mollo(Beam);

    Hoyt.ShowProperties();



    

    

    return 0;

}

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

Foundation Brick Properties

Length = 7.25

Height = 4.85

Thickness = 5.15

Cement Volume = 34.50



Foundation Brick Properties

Length = 7.25

Height = 4.85

Thickness = 5.15

Cement Volume = 34.50



Foundation Brick Properties

Length = 7.25

Height = 4.85

Thickness = 5.15

Cement Volume = 34.50



Press any key to continue...

Using the Copy Constructor

Destructors

Introduction 

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

#ifndef BricksH

#define BricksH



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

class TBrick

{

public:

     TBrick();

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

     TBrick(const TBrick &Brk);

     ~TBrick();

    double  getLength() const;

    void  setLength(const double l);

    double  getHeight() const;

    void  setHeight(const double h);

    double  getThickness() const;

    void  setThickness(const double t);

    double  CementVolume();

    void  ShowProperties();

private:

    double Length;

    double Height;

    double Thickness;

};

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

#endif

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

#ifndef BricksH

#define BricksH



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

class TBrick

{

public:

    ...

     ~TBrick() {}

    ...

private:

    ...

};

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

#endif

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

 TBrick::~TBrick()

{

}

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

Using Destructors

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



#ifndef ConeH

#define ConeH

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

struct TCone

{

public:

    TCone();                     // Default constructor

    TCone(double r, double h);   // Constructor to initialize

    TCone(const TCone& c);       // Copy constructor

    ~TCone();                    // Destructor

    void setRadius(const double r) { Radius = r; }

    void setHeight(const double h) { Height = h; }

    double getRadius() const { return Radius; }

    double getHeight() const { return Height; }

    double Base() const;

    double TextureArea() const;

    double Volume() const;

private:

    double Radius;

    double Height;

};

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

#endif

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

#include <math>

using namespace std;



#include "Cone.h"

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



//const double PI = 3.1415926535;

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

TCone::TCone()

    : Radius(0.00), Height(0.00)

{

    //TODO: Add your source code here

}

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

TCone::TCone(double r, double h)

    : Radius(r), Height(h)

{

    //TODO: Add your source code here

}

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

TCone::TCone(const TCone& c)

    : Radius(c.Radius), Height(c.Height)

{

    //TODO: Add your source code here

}

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

TCone::~TCone()

{

    //TODO: Add your source code here

}

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

double TCone::Base() const

{

    // The area of the base of the cone

    return Radius * Radius * M_PI;

}

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

double TCone::TextureArea() const

{

    // The area covered by the tissue that covers the tent

    double Radius2 = Radius * Radius;

    double Height2 = Height * Height;

    double SlantHeight = sqrt(Radius2 + Height2);

    return M_PI * Radius * SlantHeight;

}

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

double TCone::Volume() const

{

    // The interior volume available for inhabiting the tent

    return (M_PI * Radius * Radius * Height) / 3;

}

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

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

#include <iostream>

using namespace std;

#include "Cone.h"

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

int main(int argc, char* argv[])

{

    TCone Conic;



    cout << "A tent with default dimensions";

    cout << "\nRadius: " << Conic.getRadius();

    cout << "\nHeight: " << Conic.getHeight();

    cout << "\nBase Area: " << Conic.Base();

    cout << "\nTexture Area: " << Conic.TextureArea() << "\n";



    return 0;

}

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

A tent with default dimensions

Radius: 0

Height: 0

Base Area: 0

Texture Area: 0

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

#include <iostream>

using namespace std;

#include "Cone.h"

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

int main(int argc, char* argv[])

{

    TCone Tone(25.55, 32.95);

    cout << "A tent with default dimensions";

    cout << "\nRadius:       " << Tone.getRadius();

    cout << "\nHeight:       " << Tone.getHeight();

    cout << "\nBase Area:    " << Tone.Base();

    cout << "\nTexture Area: " << Tone.TextureArea() << "\n";



    return 0;

}

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

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

#include <iostream>

using namespace std;

#include "Cone.h"

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

int main(int argc, char* argv[])

{

    TCone Camper;

    double r, h;



    cout << "Specify the dimensions of the tent\n";

    cout << "Radius: ";

    cin >> r;

    cout << "Radius: ";

    cin >> h;



    Camper.setRadius(r);

    Camper.setHeight(h);

    

    cout << "\nA tent with user-defined dimensions";

    cout << "\nRadius:       " << Camper.getRadius();

    cout << "\nHeight:       " << Camper.getHeight();

    cout << "\nBase Area:    " << Camper.Base();

    cout << "\nTexture Area: " << Camper.TextureArea() << "\n";



    return 0;

}

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

Specify the dimensions of the tent

Radius: 7.24

Radius: 4.88



A tent with user-defined dimensions

Radius:       7.24

Height:       4.88

Base Area:    164.675

Texture Area: 198.59

The Starting Object

An object as an Argument

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

#include <iostream>

using namespace std;

#include "Cone.h"

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

void ShowTent(TCone c)

{

    cout << "Characteristics of this tent";

    cout << "\nRadius: " << c.getRadius();

    cout << "\nHeight: " << c.getHeight();

    cout << "\nBase Area: " << c.Base();

    cout << "\nTexture Area: " << c.TextureArea() << "\n";

}

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

int main(int argc, char* argv[])

{

    TCone Tent;

    ShowTent(Tent);



    return 0;

}

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

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

#include <iostream>

#include <iomanip>

using namespace std;

#include "Cone.h"

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

void ShowTent(TCone c)

{

    cout << "\nCharacteristics of this tent";

    cout << setiosflags(ios::fixed) << setprecision(2);

    cout << "\nRadius:       " << c.getRadius();

    cout << "\nHeight:       " << c.getHeight();

    cout << "\nBase Area:    " << c.Base();

    cout << "\nTexture Area: " << c.TextureArea() << "\n";

}

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

int main(int argc, char* argv[])

{

    TCone Tent;

    double r, h;



    cout << "Specify the dimensions of the tent\n";

    cout << "Radius: ";

    cin >> r;

    cout << "Height: ";

    cin >> h;



    Tent.setRadius(r);

    Tent.setHeight(h);

    ShowTent(Tent);



    return 0;

}

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

Specify the dimensions of the tent

Radius: 10.24

Height: 6.84



Characteristics of this tent

Radius:       10.24

Height:       6.84

Base Area:    329.42

Texture Area: 396.15

Using an Object as an Argument

Objects and their External Interaction

Returning an Object

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

#include <iostream>

#include <iomanip>

using namespace std;

#include "Cone.h"

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





void Exit()

{

    

    

}

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

void ShowTent(TCone c)

{

    cout << "\nCharacteristics of this tent";

    cout << setiosflags(ios::fixed) << setprecision(2);

    cout << "\nRadius:       " << c.getRadius();

    cout << "\nHeight:       " << c.getHeight();

    cout << "\nBase Area:    " << c.Base();

    cout << "\nTexture Area: " << c.TextureArea() << "\n";

}

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

TCone ObtainDimensions()

{

    double r, h;



    cout << "Specify the dimensions of the tent\n";

    cout << "Radius: "; cin >> r;

    cout << "Radius: "; cin >> h;



    return TCone::TCone(r, h); // Returning the constructor

}

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

int main(int argc, char* argv[])

{

    TCone Tent;



    Tent = ObtainDimensions();

    ShowTent(Tent);



    Exit();

    return 0;

}

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

Specify the dimensions of the tent

Radius: 8.44

Radius: 5.26



Characteristics of this tent

Radius:       8.44

Height:       5.26

Base Area:    223.79

Texture Area: 263.69

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

TCone ObtainDimensions()

{

    double r, h;

    TCone Tonic;



    cout << "Specify the dimensions of the tent\n";

    cout << "Radius: "; cin >> r;

    cout << "Height: "; cin >> h;



    Tonic.setRadius(r);

    Tonic.setHeight(h);

    return Tonic;

}

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

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

TCone ObtainDimensions()

{

    double r, h;



    cout << "Specify the dimensions of the tent\n";

    cout << "Radius: "; cin >> r;

    cout << "Height: "; cin >> h;



    TCone Copper(r, h);

    return Copper;

}

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

Specify the dimensions of the tent

Radius: 18.12

Height: 10.26



Characteristics of this tent

Radius:       18.12

Height:       10.26

Base Area:    1031.49

Texture Area: 1185.37

Returning an Object From a Function

 Passing an Object by Reference

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

#include <iostream>

#include <iomanip>

using namespace std;

#include "Cone.h"

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





void Exit()

{

    

    

}

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

void ShowTent(TCone c)

{

    cout << "\nCharacteristics of this tent";

    cout << setiosflags(ios::fixed) << setprecision(2);

    cout << "\nRadius:       " << c.getRadius();

    cout << "\nHeight:       " << c.getHeight();

    cout << "\nBase Area:    " << c.Base();

    cout << "\nTexture Area: " << c.TextureArea() << "\n";

}

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

void ObtainDimensions(TCone& Tone)

{

    double r, h;



    cout << "Specify the dimensions of the tent\n";

    cout << "Radius: "; cin >> r;

    cout << "Radius: "; cin >> h;



    Tone.setRadius(r);

    Tone.setHeight(h);

}

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

int main(int argc, char* argv[])

{

    TCone Tent;



    ObtainDimensions(Tent);

    ShowTent(Tent);



    Exit();

    

    return 0;

}

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

Specify the dimensions of the tent

Radius: 5.12

Radius: 3.84



Characteristics of this tent

Radius:       5.12

Height:       3.84

Base Area:    82.35

Texture Area: 102.94

Passing an Object by Reference

Friend Functions of a Class

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

#include <iostream>

using namespace std;



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





class TForSale

{

    friend double TotalPrice(TForSale i);

public:

    TForSale(int q = 0, double p = 0.00);

private:

    int Qty;

    double UnitPrice;

};

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

TForSale::TForSale(int Quantity, double Price)

    : Qty(Quantity), UnitPrice(Price)

{

}

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

double TotalPrice(TForSale i)

{

    return i.Qty * i.UnitPrice;

}

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

int main(int argc, char* argv[])

{

    TForSale item(12, 0.99);



    cout << "Total Price: $" << TotalPrice(item) << endl;



    

    

    return 0;

}

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

Total Price: $11.88

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



#ifndef TriangleH

#define TriangleH

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

struct TTriangle

{

    friend double Perimeter(TTriangle Tri);

    friend double Area(TTriangle Tri);



public:

    TTriangle(double B = 0.00, double H = 0.00);

    TTriangle(const TTriangle& t);

    ~TTriangle();

    double getBase() const;

    double getHeight() const;

private:

    double Base;

    double Height;

};

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

#endif

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



#ifndef TriangleH

#define TriangleH

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

struct TTriangle

{

    friend double Perimeter(TTriangle Tri);

    friend double Area(TTriangle Tri);



public:

    TTriangle(double B = 0.00, double H = 0.00);

    TTriangle(const TTriangle& t);

    ~TTriangle();

    double getBase() const;

    double getHeight() const;

private:

    double Base;

    double Height;

};

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

double Perimeter(TTriangle Tri)

{

    double RootOfHB = sqrt((Tri.Base * Tri.Base) + (Tri.Height * Tri.Height));



    return Tri.Base + Tri.Height + RootOfHB;

}

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

double Area(TTriangle Tri)

{

    return Tri.Base * Tri.Height / 2;

}

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

#endif

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

#ifndef TriangleH

#define TriangleH

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

struct TTriangle

{

    friend double Perimeter(TTriangle Tri);

    friend double Area(TTriangle Tri);



public:

    TTriangle(double B = 0.00, double H = 0.00);

    TTriangle(const TTriangle& t);

    ~TTriangle();

    double getBase() const;

    double getHeight() const;

private:

    double Base;

    double Height;

};

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

double Perimeter(TTriangle Tri)

{

    double RootOfHB = sqrt((Tri.Base * Tri.Base) + (Tri.Height * Tri.Height));



    return Tri.Base + Tri.Height + RootOfHB;

}

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

double Area(TTriangle Tri)

{

    return Tri.Base * Tri.Height / 2;

}

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

#endif

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

#include <math>

using namespace std;



#include "Triangle.h"

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



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

double Perimeter(TTriangle Tri)

{

    double RootOfHB = sqrt((Tri.Base * Tri.Base) + (Tri.Height * Tri.Height));



    return Tri.Base + Tri.Height + RootOfHB;

}

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

double Area(TTriangle Tri)

{

    return Tri.Base * Tri.Height / 2;

}

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

TTriangle::TTriangle(double B, double H)

    : Base(B), Height(H)

{

}

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

TTriangle::TTriangle(const TTriangle& t)

    : Base(t.Base), Height(t.Height)

{

}

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

TTriangle::~TTriangle()

{

}

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

double TTriangle::getBase() const

{

    return Base;

}

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

double TTriangle::getHeight() const

{

    return Height;

}

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

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

#include <iostream>

#include <iomanip>

using namespace std;

#include "Triangle.h"

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





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

void Characteristics(const TTriangle& T)

{

    cout << "Characteristics of the triangle\n";

    cout << setiosflags(ios::fixed) << setprecision(2);

    cout << "Base:      " << T.getBase() << endl;

    cout << "Height:    " << T.getHeight() << endl;

    cout << "Perimeter: " << Perimeter(T) << endl;

    cout << "Area:      " << Area(T) << endl;

}

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

int main(int argc, char* argv[])

{

    TTriangle Trng(12.55, 10.85);



    Characteristics(Trng);



    

    

    return 0;

}

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

Characteristics of the triangle

Base:      12.55

Height:    10.85

Perimeter: 39.99

Area:      68.08

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

#ifndef TriangleH

#define TriangleH

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

struct TTriangle

{

    friend double Perimeter(const TTriangle Tri);

    friend double Area(const TTriangle Tri);



public:

    TTriangle(double B = 0.00, double H = 0.00);

    TTriangle(const TTriangle& t);

    ~TTriangle();

    double getBase() const;

    double getHeight() const;

private:

    double Base;

    double Height;

};

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

#endif

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

double Perimeter(const TTriangle Tri)

{

    double RootOfHB = sqrt((Tri.Base * Tri.Base) + (Tri.Height * Tri.Height));



    return Tri.Base + Tri.Height + RootOfHB;

}

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

double Area(const TTriangle Tri)

{

    return Tri.Base * Tri.Height / 2;

}

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

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

#ifndef TriangleH

#define TriangleH

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

struct TTriangle

{

    friend double Perimeter(TTriangle& Tri);

    friend double Area(TTriangle& Tri);



public:

    . . .

private:

    double Base;

    double Height;

};

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

#endif

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

#ifndef TriangleH

#define TriangleH

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

struct TTriangle

{

    friend double Perimeter(const TTriangle& Tri);

    friend double Area(const TTriangle& Tri);



public:

    . . .

private:

    double Base;

    double Height;

};

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

#endif

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

#ifndef TriangleH

#define TriangleH

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

struct TTriangle

{

    friend TTriangle GetDimensions();

    friend double Perimeter(const TTriangle& Tri);

    friend double Area(const TTriangle& Tri);



public:

    TTriangle(double B = 0.00, double H = 0.00);

    TTriangle(const TTriangle& t);

    ~TTriangle();

    void setDimensions(const double b, const double h);

    double getBase() const;

    double getHeight() const;

private:

    double Base;

    double Height;

};

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

#endif

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

TTriangle GetDimensions()

{

    double x, y;



    cout << "Enter base: "; cin >> x;

    cout << "Enter height: "; cin >> y;



    return TTriangle(x, y);

}

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

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

#include <iostream>

#include <iomanip>

using namespace std;

#include "Triangle.h"

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





void Characteristics(const TTriangle& T)

{

    cout << "\nCharacteristics of the triangle\n";

    cout << setiosflags(ios::fixed) << setprecision(2);

    cout << "Base:      " << T.getBase() << endl;

    cout << "Height:    " << T.getHeight() << endl;

    cout << "Perimeter: " << Perimeter(T) << endl;

    cout << "Area:      " << Area(T) << endl;

}

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

int main(int argc, char* argv[])

{

    TTriangle Slice;

    double b, h;



    Slice = GetDimensions();

    Characteristics(Slice);



    

    

    return 0;

}

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

Using Friends of a Class

Mixing Different Objects in the Same Program

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

#ifndef RectangleH

#define RectangleH

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

class TRectangle

{

public:

    TRectangle();

    TRectangle(double L, double W);

    TRectangle(const TRectangle& Rect);

    ~TRectangle();

    void setLength(double L) { Length = L; }

    void setHeight(double H) { Height = H; }

    double getLength() { return Length; }

    double getHeight() { return Height; }

    double Perimeter(double Length, double Height);

    double Area(double Length, double Height);

private:

    double Length;

    double Height;

};

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

#endif

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



using namespace std;



#include "Rectangle.h"

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



TRectangle::TRectangle()

    : Length(3.25), Height(2.55)

{

    //TODO: Add your source code here

}

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

TRectangle::TRectangle(double L, double H)

    : Length(L), Height(H)

{

    //TODO: Add your source code here

}

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

TRectangle::TRectangle(const TRectangle& r)

    : Length(r.Length), Height(r.Height)

{

    //TODO: Add your source code here

}

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

TRectangle::~TRectangle()

{

    //TODO: Add your source code here

}

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

double TRectangle::Perimeter(double x, double y)

{

    return 2 * (x + y);

}

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

double TRectangle::Area(double x, double y)

{

    return x * y;

}

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

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

#ifndef LabelTypeH

#define LabelTypeH

#include <string>

using namespace std;

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

class TLabelType

{

public:

    TLabelType();

    TLabelType(long m, string c, string n, string a);

    ~TLabelType();

    void setModelNumber(long m) { ModelNumber = m; }

    void setName(string n) { Name = n; }

    void setColor(string c) { Color = c; }

    void setAdhesive(string a) { Adhesive = a; }

    long getModelNumber() const;

    string getName() const;

    string getColor() const;

    string getAdhesive() const;

private:

    long ModelNumber;

    string Name;

    string Color;

    string Adhesive;

};

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

#endif

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



using namespace std;



#include "LabelType.h"

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



TLabelType::TLabelType()

    : ModelNumber(0), Color("White"),

      Name("None"), Adhesive("Not Specified")

{

    //TODO: Add your source code here

}

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

TLabelType::TLabelType(long m, string c, string n, string a)

    : ModelNumber(m), Color(c), Name(n), Adhesive(a)

{

    //TODO: Add your source code here

}

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

TLabelType::~TLabelType()

{

    //TODO: Add your source code here

}

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

long TLabelType::getModelNumber() const

{

    return ModelNumber;

}

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

string TLabelType::getName() const

{

    return Name;

}

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

string TLabelType::getColor() const

{

    return Color;

}

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

string TLabelType::getAdhesive() const

{

    return Adhesive;

}

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

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

#include <iostream>

#include <iomanip>

using namespace std;

#include "Rectangle.h"

#include "LabelType.h"

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

int main(int argc, char* argv[])

{

    TRectangle Dim;

    TLabelType LabelType;



    cout << "A label with default characteristics";

    cout << "\nDimensions: " << Dim.getLength()

         << " * " << Dim.getHeight();

    cout << "\nArea:       " << Dim.Area(Dim.getLength(), Dim.getHeight());

    cout << "\nModel No.:  " << LabelType.getModelNumber();

    cout << "\nModel Name: " << LabelType.getName();

    cout << "\nColor:      " << LabelType.getColor();

    cout << "\nAdhesive:   " << LabelType.getAdhesive();



    

    

    return 0;

}

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

A label with default characteristics

Dimensions: 3.25 * 2.55

Area:       8.2875

Model No.:  0

Model Name: None

Color:      White

Adhesive:   Not Specified

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

#include <iostream>

#include <iomanip>

using namespace std;

#include "Rectangle.h"

#include "LabelType.h"

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





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

int main(int argc, char* argv[])

{

    TRectangle Dim(4.55, 2.25);

    TLabelType LabelType(25442, "Mandarin", "One Touch", "Non-Removable");



    cout << "An example label";

    cout << "\nDimensions: " << Dim.getLength()

         << " * " << Dim.getHeight();

    cout << "\nArea:       " << Dim.Area(Dim.getLength(), Dim.getHeight());

    cout << "\nModel No.:  " << LabelType.getModelNumber();

    cout << "\nModel Name: " << LabelType.getName();

    cout << "\nColor:      " << LabelType.getColor();

    cout << "\nAdhesive:   " << LabelType.getAdhesive();



    

    

    return 0;

}

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

An example label

Dimensions: 4.55 * 2.25

Area:       10.2375

Model No.:  25442

Model Name: One Touch

Color:      Mandarin

Adhesive:   Non-Removable

Combining Objects

Another technique you can use, which would make the initialization easier to read, consists of including the values of each member of the array in its own set of curly brackets. It would be done as follows:

#include <iostream>

using namespace std;



struct Point

{

    char Letter;

    int x;

    int y;

};



int main()

{

	Point Coordinates[4] = { {'P', -4,  0}, {'Q', -3, -2},

				 {'L',  5,  1}, {'M', 2,  6}};



    cout << "Point Coordinates";

    cout << "\n" << Coordinates[0].Letter << "("

         << Coordinates[0].x << ", " << Coordinates[0].y << ");";

    cout << "\n" << Coordinates[1].Letter << "("

         << Coordinates[1].x << ", " << Coordinates[1].y << ");";

    cout << "\n" << Coordinates[2].Letter << "("

         << Coordinates[2].x << ", " << Coordinates[2].y << ");";

    cout << "\n" << Coordinates[3].Letter << "("

         << Coordinates[3].x << ", " << Coordinates[3].y << ");\n";

	return 0;

}

In our introduction to Classes, we also saw that you could declare an instance of a structure when creating it. This was done by providing a name for the variable between the closing curly bracket and the semi-colon. In the same way, when declaring such a variable, you can initialize it directly. Here is an example:

#include <iostream>

using namespace std;



struct Point

{

    char Letter;

    int x;

    int y;

} Coordinates[4] = {'P', -4,  0, 'Q', -3, -2,'L',  5,  1, 'M', 2,  6};



int main()

{

    cout << "Point Coordinates";

    cout << "\n" << Coordinates[0].Letter << "("

         << Coordinates[0].x << ", " << Coordinates[0].y << ");";

    cout << "\n" << Coordinates[1].Letter << "("

         << Coordinates[1].x << ", " << Coordinates[1].y << ");";

    cout << "\n" << Coordinates[2].Letter << "("

         << Coordinates[2].x << ", " << Coordinates[2].y << ");";

    cout << "\n" << Coordinates[3].Letter << "("

         << Coordinates[3].x << ", " << Coordinates[3].y << ");\n";

	return 0;

}

In the same way, you can initialize the array when creating the variable:

#include <iostream>

using namespace std;



struct Point

{

    char Letter;

    int x;

    int y;

} Coordinates[4] = { {'P', -4,  0}, {'Q', -3, -2},

		     {'L',  5,  1}, {'M', 2,  6}};



int main()

{

    cout << "Point Coordinates";

    cout << "\n" << Coordinates[0].Letter << "("

         << Coordinates[0].x << ", " << Coordinates[0].y << ");";

    cout << "\n" << Coordinates[1].Letter << "("

         << Coordinates[1].x << ", " << Coordinates[1].y << ");";

    cout << "\n" << Coordinates[2].Letter << "("

         << Coordinates[2].x << ", " << Coordinates[2].y << ");";

    cout << "\n" << Coordinates[3].Letter << "("

         << Coordinates[3].x << ", " << Coordinates[3].y << ");\n";

	return 0;

}

The above techniques of initialization are convenient for small objects, traditionally used as C structures. The other technique you can use, also convenient for an array of a more elaborate object, consists of initializing each member of the array. To do this, you assign a value to each member of the object. This can be done as follows:

#include <iostream>

using namespace std;



struct Point

{

    char Letter;

    int x;

    int y;

};



int main()

{

    Point Coordinates[2];



    Coordinates[0].Letter = 'P';

    Coordinates[0].x = -4;

    Coordinates[0].y =  0;

    Coordinates[1].Letter = 'Q';

    Coordinates[1].x = -3;

    Coordinates[1].y = -2;



    cout << "Point Coordinates";

    cout << "\n" << Coordinates[0].Letter << "("

         << Coordinates[0].x << ", " << Coordinates[0].y << ");";

    cout << "\n" << Coordinates[1].Letter << "("

         << Coordinates[1].x << ", " << Coordinates[1].y << ");\n";



	return 0;

}

Here is an example of running the program:

Point Coordinates

P(-4, 0);

Q(-3, -2);

Once you have declared and initialized an array of objects, you can use the values of its member variables as you see fit. For example, from the above Point class, you can request the coordinates of two points, write an equation that calculates their distance or one that gets their slope, and display it to the user. This can be done as follows:

#include <iostream>

using namespace std;



struct Point

{

    char Letter;

    int x;

    int y;

};



int main()

{

    Point Points[2];

    double Slope;



    cout << "Enter the coordinates of the points\n";

    cout << "x1 = "; cin >> Points[0].x;

    cout << "y1 = "; cin >> Points[0].y;

    cout << "x2 = "; cin >> Points[1].x;

    cout << "y2 = "; cin >> Points[1].y;

    

    Points[0].Letter = 'A';

    Points[1].Letter = 'B';

    

    if( Points[0].x != Points[1].x )

        Slope = (Points[1].y - Points[0].y) / (Points[1].x - Points[0].x);

    else

        Slope = 0.00;



    cout << "The slope of " << Points[0].Letter << "("

         << Points[0].x << ", " << Points[0].y << ") and "

         << Points[1].Letter << "(" << Points[1].x << ", "

         << Points[1].y << ") is " << Slope << endl;



	return 0;

}

Here is an example of running the program:

Enter the coordinates of the points

x1 = -2

y1 = 3

x2 = 1

y2 = -3

The slope of A(-2, 3) and B(1, -3) is -2

An Array of Objects as Argument

Like a regular data type, an array of objects can be passed as an argument to a function. To do this, when declaring and when implementing the function, provide the array in the parentheses of the function as you would do with any other regular variable. Here is an example that takes and processes an argument that is an array of objects:

void ProcessCoordinates(Point points[])

{

    cout << "Enter the coordinates of four points\n";

    cout << "x1 = "; cin >> points[0].x;

    cout << "y1 = "; cin >> points[0].y;

    cout << "x2 = "; cin >> points[1].x;

    cout << "y2 = "; cin >> points[1].y;

    cout << "x3 = "; cin >> points[2].x;

    cout << "y3 = "; cin >> points[2].y;

    cout << "x4 = "; cin >> points[3].x;

    cout << "y4 = "; cin >> points[3].y;

}

The above function was using an array whose dimension you know. If you do not know or cannot predict the dimension of an array, you can/should/must pass an additional argument that holds the number of members of the array.

When calling a function that takes a single-dimension array of objects, the name of the argument is sufficient to the compiler. Other than this, you can apply all the other rules we learned for arrays of regular data types:

#include <iostream>

using namespace std;



struct Point

{

    char Letter;

    int x;

    int y;

};



void ProcessCoordinates(Point points[]);

void DisplayCoordinates(Point points[], const int size);



int main()

{

    Point coordinates[4];



    ProcessCoordinates(coordinates);

    cout << endl;

    DisplayCoordinates(coordinates, 4);



    return 0;

}



void ProcessCoordinates(Point points[])

{

    cout << "Enter the coordinates of four points\n";

    cout << "x1 = "; cin >> points[0].x;

    cout << "y1 = "; cin >> points[0].y; points[0].Letter = 'A';

    cout << "x2 = "; cin >> points[1].x;

    cout << "y2 = "; cin >> points[1].y; points[1].Letter = 'B';

    cout << "x3 = "; cin >> points[2].x;

    cout << "y3 = "; cin >> points[2].y; points[2].Letter = 'C';

    cout << "x4 = "; cin >> points[3].x;

    cout << "y4 = "; cin >> points[3].y; points[3].Letter = 'D';

}



void DisplayCoordinates(Point points[], const int size)

{

    cout << "Point Coordinates";

    for(int i = 0; i < size; i++)

        cout << "\n" << points[i].Letter << "("

             << points[i].x << ", " << points[i].y << ");";

}

Classes and Pointers

Declaring a Pointer to an Object

Header File: cone.h

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

#ifndef ConeH

#define ConeH                                                                

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

class Cone

{

private:

    double _rad;

    double _hgt;

public:

    Cone();

    Cone(double radius, double height);

    Cone(const Cone& c);

    ~Cone();

    void setRadius(const double radius) { _rad = radius; }

    void setHeight(const double height) { _hgt = height; }

    double getRadius() const { return _rad; }

    double getHeight() const { return _hgt; }

    double CalculateBaseArea() const;

    double CalculateLateralArea() const;

    double CalculateTotalArea() const;

    double CalculateVolume() const;

};

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

#endif

Source File: cone.cpp

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

#include <math.h>

#include "Cone.h"

//using namespace std;

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

Cone::Cone()

    : _rad(0.00), _hgt(0.00)

{

    

}

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

Cone::Cone(double r, double h)

    : _rad(r), _hgt(h)

{

    

}

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

Cone::Cone(const Cone& c)

    : _rad(c._rad), _hgt(c._hgt)

{

    

}

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

Cone::~Cone()

{

    

}

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

double Cone::CalculateBaseArea() const

{

    // The area of the base of the cone

    return _rad * _rad * 3.14159;

}

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

double Cone::CalculateLateralArea() const

{

    // The area covered by the tissue that covers the tent

    double radius2 = _rad * _rad;

    double height2 = _hgt * _hgt;

    double slantHeight = sqrt(radius2 + height2);

    return 3.14159 * _rad * slantHeight;

}

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

double Cone::CalculateTotalArea() const

{

    return CalculateBaseArea() + CalculateLateralArea();

}

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

double Cone::CalculateVolume() const

{

    // The interior volume available for inhabiting the tent

    return (3.14159 * _rad * _rad * _hgt) / 3;

}

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

Like a regular data type, you can declare a class as a pointer, you can pass it to a function as a reference or as a pointer, and you can dynamically create an instance of a class. To declare a pointer to a class, type its name, followed by an asterisk and followed by a name for the variable. Here is an example:

Cone *pCone;

Like a pointer to a regular data type, after declaring a pointer to a class, you should let the compiler know what variable the pointer is pointing to. This can easily be done by assigning the address of an existing variable as follows:

#include <iostream>

#include "cone.h"

using namespace std;



int main()

{

    Cone iceCone;

    Cone *pCone = &iceCone;

  

    double radius, height;



    cout << "Enter the cone's dimensions\n";

    cout << "Radius: ";

    cin >> radius;

    cout << "Height: ";

    cin >> height;



    pCone->setRadius(radius);

    pCone->setHeight(height);



    cout << "Cone's Characteristics";

    cout << "\nRadius:       " << pCone->getRadius();

    cout << "\nHeight:       " << pCone->getHeight();

    cout << "\nBase Area:    " << pCone->CalculateBaseArea();

    cout << "\nTotal Area:   " << pCone->CalculateTotalArea();

    cout << "\nTexture Area: " << pCone->CalculateLateralArea() << endl;



    return 0;

}

Enter the cone's dimensions

Radius: 38.44

Height: 20.72

Cone's Characteristics

Radius:       38.44

Height:       20.72

Base Area:    4642.12

Total Area:   9915.67

Texture Area: 5273.55

Dynamic Objects

One of the advantages of using pointers is that they give you the ability to use memory only as needed. This is done by using the asterisk * and the new operators. The syntax of declaring a pointer to an object is:

ClassName* VariableName = new ClassName;

The ClassName is the class whose variable you want to declare. It could be in the program or one that shipped with the compiler. Once again, the asterisk lets the compiler know that the class is declared as a pointer. The variable name follows the same rules we have applied to other variables so far.

There are two main ways you can provide values to the member variables of your dynamic object. You can request their values from the user, from another object or function, or you can initialize the variable. Still there are at least two ways you can initialize the variable. When declaring it, since you would be using a constructor to build the object, you can use the constructor that takes the number of values you want to initialize. Consider the above Cone class. This class provides three constructors, one of which takes two arguments to initialize a complete Cone variable. You can use this constructor when using the new operator. In the parentheses, provide a value for each member variable. Here is an example:

#include <iostream>

#include "cone.h"

using namespace std;



int main()

{

    Cone *pCone = new Cone(25.55, 20.15);



    cout << "Cone's Characteristics";

    cout << "\nRadius:       " << pCone->getRadius();

    cout << "\nHeight:       " << pCone->getHeight();

    cout << "\nBase Area:    " << pCone->CalculateBaseArea();

    cout << "\nTotal Area:   " << pCone->CalculateTotalArea();

    cout << "\nTexture Area: " << pCone->CalculateLateralArea() << endl;



	return 0;

}

This would produce:

Cone's Characteristics

Radius:       25.55

Height:       20.15

Base Area:    2050.84

Total Area:   4662.71

Texture Area: 2611.88

If you want to use, or have used, the default constructor to create the object, you can then use one of its methods to initialize the variable. Here is an example:

#include <iostream>

#include "cone.h"

using namespace std;



int main()

{

    Cone *pCone = new Cone();



    pCone->setRadius(25.55);

    pCone->setHeight(20.15);



    cout << "Cone's Characteristics";

    cout << "\nRadius:       " << pCone->getRadius();

    cout << "\nHeight:       " << pCone->getHeight();

    cout << "\nBase Area:    " << pCone->CalculateBaseArea();

    cout << "\nTotal Area:   " << pCone->CalculateTotalArea();

    cout << "\nTexture Area: " << pCone->CalculateLateralArea() << endl;



	return 0;

}

Of course, at any time, you can change the values of the pointer using either one of its constructors or its methods. After using a variable that was declared using the new operator, you can reclaim the memory space it was using. This is done with the delete operator.

Here is an example:

#include <iostream>

#include "cone.h"

using namespace std;



int main()

{

    Cone *pCone = new Cone();



    pCone->setRadius(25.55);

    pCone->setHeight(20.15);



    cout << "Cone's Characteristics";

    cout << "\nRadius:       " << pCone->getRadius();

    cout << "\nHeight:       " << pCone->getHeight();

    cout << "\nBase Area:    " << pCone->CalculateBaseArea();

    cout << "\nTotal Area:   " << pCone->CalculateTotalArea();

    cout << "\nTexture Area: " << pCone->CalculateLateralArea() << endl;



    pCone = new Cone(44.42, 35.72);



    cout << "\nCone's Characteristics";

    cout << "\nRadius:       " << pCone->getRadius();

    cout << "\nHeight:       " << pCone->getHeight();

    cout << "\nBase Area:    " << pCone->CalculateBaseArea();

    cout << "\nTotal Area:   " << pCone->CalculateTotalArea();

    cout << "\nTexture Area: " << pCone->CalculateLateralArea() << endl;



	return 0;

}

This would produce:

Pointers to Arrays of Objects

Instead of using one pointer to an object, you can declare an array of pointers to object. The syntax used is:

ClassName *VariableName[Dimension];

The ClassName must be an existing object. You can use your own object or one that shipped with the compiler. After the asterisk operator, type a valid name for a C++ variable. The dimension, which is (an estimate of) the number of elements of the array, is included in square brackets.

After declaring the variable, you can initialize each member of the array using the new operator. This operator allocates enough memory space for the member of the array. This means that the initialization with the new operator can be followed by an actual initialization of the member variables of the array.

To initialize a member of the array, you have various options. You must first call the new operator for each member of the array. Once again, you can use one of the constructors. Consider the above Cone object. We saw that one of its constructors took two arguments to create an object. You can use such a constructor to initialize a member of the array. Here are examples:

#include <iostream>

#include "cone.h"

using namespace std;



int main()

{

    Cone *pCone[3];



    pCone[0] = new Cone(25.55, 20.15);

    pCone[1] = new Cone(12.44, 18.62);

    pCone[2] = new Cone(48.12, 38.84);



    cout << "Cone's Characteristics\n";

    for(int i = 0; i < 3; i++)

    {

        cout << "\n - Cone No. " << i + 1 << " -";

        cout << "\nRadius:       " << pCone[i]->getRadius();

        cout << "\nHeight:       " << pCone[i]->getHeight();

        cout << "\nBase Area:    " << pCone[i]->CalculateBaseArea();

        cout << "\nTotal Area:   " << pCone[i]->CalculateTotalArea();

        cout << "\nTexture Area: " << pCone[i]->CalculateLateralArea() << endl;

    }



	return 0;

}

This would produce:

Cone's Characteristics



 - Cone No. 1 -

Radius:       25.55

Height:       20.15

Base Area:    2050.84

Total Area:   4662.71

Texture Area: 2611.88



 - Cone No. 2 -

Radius:       12.44

Height:       18.62

Base Area:    486.172

Total Area:   1361.33

Texture Area: 875.159



 - Cone No. 3 -

Radius:       48.12

Height:       38.84

Base Area:    7274.46

Total Area:   16622.9

Texture Area: 9348.43

If you had already created some objects and want to use their values, you can assign the desired variable to the member of the array of your choice. Here are examples:

#include <iostream>

#include "cone.h"

using namespace std;



int main()

{

    Cone *pCone[3];

    Cone conic(66.14, 50.82);

    Cone *iceCreamCone = new Cone(8.74, 6.82);



    pCone[0] = &conic;

    pCone[1] = iceCreamCone;

    pCone[2] = new Cone(48.12, 38.84);



    cout << "Cone's Characteristics\n";

    for(int i = 0; i < 3; i++)

    {

        cout << "\n - Cone No. " << i + 1 << " -";

        cout << "\nRadius:       " << pCone[i]->getRadius();

        cout << "\nHeight:       " << pCone[i]->getHeight();

        cout << "\nBase Area:    " << pCone[i]->CalculateBaseArea();

        cout << "\nTotal Area:   " << pCone[i]->CalculateTotalArea();

        cout << "\nTexture Area: " << pCone[i]->CalculateLateralArea() << endl;

    }



    return 0;

}

This would produce:

Cone's Characteristics



 - Cone No. 1 -

Radius:       66.14

Height:       50.82

Base Area:    13742.9

Total Area:   31074.1

Texture Area: 17331.3



 - Cone No. 2 -

Radius:       8.74

Height:       6.82

Base Area:    239.979

Total Area:   544.373

Texture Area: 304.395



 - Cone No. 3 -

Radius:       48.12

Height:       38.84

Base Area:    7274.46

Total Area:   16622.9

Texture Area: 9348.43

Another technique you can use is to first allocate memory space for a member of the array, then use one of the methods of the object to initialize that particular member of the array. This can be taken care of with set methods.

After using the array, you can delete each of its members using the delete operator. Here is an example:

#include <iostream>

#include "cone.h"

using namespace std;



int main()

{

    Cone *pCone[3];



    pCone[0] = new Cone;

    pCone[0]->setRadius(25.55);

    pCone[0]->setHeight(20.15);

                               

    pCone[1] = new Cone;

    pCone[1]->setRadius(12.44);

    pCone[1]->setHeight(18.62);

    

    pCone[2] = new Cone;

    pCone[2]->setRadius(48.12);

    pCone[2]->setHeight(38.84);



    cout << "Cone's Characteristics\n";

    for(int i = 0; i < 3; i++)

    {

        cout << "\n - Cone No. " << i + 1 << " -";

        cout << "\nRadius:       " << pCone[i]->getRadius();

        cout << "\nHeight:       " << pCone[i]->getHeight();

        cout << "\nBase Area:    " << pCone[i]->CalculateBaseArea();

        cout << "\nTotal Area:   " << pCone[i]->CalculateTotalArea();

        cout << "\nTexture Area: " << pCone[i]->CalculateLateralArea() << endl;

    }



    delete pCone[0];

    delete pCone[1];

    delete pCone[2];



    return 0;

}

An Object Passed as Pointer

To pass an object as pointer, when declaring and when implementing the object, use the asterisk operator between the class name and the variable name. Consequently, when defining the function, access the members of the object using the arrow operator:

void RequestDimensions(Cone* cn)

{

    double Radius, Height;



    cout << "Enter the cone's dimensions\n";

    cout << "Radius: ";

    cin >> Radius;

    cout << "Height: ";

    cin >> Height;



    cn->setRadius(Radius);

    cn->setHeight(Height);

}

When calling such a function, if the variable was declared as a regular item, in the parentheses of the function, call the variable using the reference operator:

#include <iostream>

#include "cone.h"

using namespace std;



void RequestDimensions(Cone* cn)

{

    double Radius, Height;



    cout << "Enter the cone's dimensions\n";

    cout << "Radius: ";

    cin >> Radius;

    cout << "Height: ";

    cin >> Height;



    cn->setRadius(Radius);

    cn->setHeight(Height);

}



int main()

{

    Cone typeCone;



    RequestDimensions(&typeCone);



    cout << "\nCone's Characteristics";

    cout << "\nRadius:       " << typeCone.getRadius();

    cout << "\nHeight:       " << typeCone.getHeight();

    cout << "\nBase Area:    " << typeCone.CalculateBaseArea();

    cout << "\nTotal Area:   " << typeCone.CalculateTotalArea();

    cout << "\nTexture Area: " << typeCone.CalculateLateralArea();



    return 0;

}

Here is an example of running the program:

Enter the cone's dimensions

Radius: 24.58

Height: 20.64



Cone's Characteristics

Radius:       24.58

Height:       20.64

Base Area:    1898.07

Total Area:   4376.58

Texture Area: 2478.5

As you may have realized, when an argument is passed as pointer, if the function modifies its value, the object would be altered. This has the same effect as passing an object by reference because, once more, the function has access to the memory location of the argument. Consequently, there is an advantage of speed when passing an argument as pointer. If, on the other hand, you do not want the function to modify the value of the argument, you can pass it as a constant pointer. Here is an example:

#include <iostream>

#include "cone.h"

using namespace std;



void RequestDimensions(Cone*);

void ShowCharacteristics(const Cone *pCone);



int main()

{

    Cone typeCone;



    RequestDimensions(&typeCone);



    ShowCharacteristics(&typeCone);



    return 0;

}



void RequestDimensions(Cone* cn)

{

    double Radius, Height;



    cout << "Enter the cone's dimensions\n";

    cout << "Radius: ";

    cin >> Radius;

    cout << "Height: ";

    cin >> Height;



    cn->setRadius(Radius);

    cn->setHeight(Height);

}



void ShowCharacteristics(const Cone *pCone)

{

    cout << "\nCone's Characteristics";

    cout << "\nRadius:       " << pCone->getRadius();

    cout << "\nHeight:       " << pCone->getHeight();

    cout << "\nBase Area:    " << pCone->CalculateBaseArea();

    cout << "\nTotal Area:   " << pCone->CalculateTotalArea();

    cout << "\nTexture Area: " << pCone->CalculateLateralArea();

}

Classes and Pointers to Functions

A Pointer to Function as a Member Variable

When studying pointers to functions, we learned to use a programmer's type-defined declaration to create an alias to a pointer to function. We used an example such as the following:

typedef double (*Multiply)(const double a);

With this declaration, the word Multiply can be used in place of a function that takes a double-precision value as argument and the function returns a double. We learned that such a Multiply name could be used to declare a variable that in fact would be used as a function. Based on this feature of the C++ language, the Multiply name can also be used to declare a member variable of an object. Such a member variable would be interpreted as a function. The declaration can be done as follows:

typedef double (*Multiply)(const double a);



struct TSquare

{

    Multiply Perimeter;

};

As done with the regular pointer to function, you do not implement the Perimeter method. In fact, so far, the compiler does not know what to do with the Perimeter member. Therefore, you must formally define a function that can implement the behavior that the Perimeter member is supposed to use. Such a function can be defined as follows:

double Perimetre(const double x)

{

    return x * 4;

}

Even with this definition of the Perimetre() function, there is no relationship between the Perimeter member of the TSquare class and the Perimetre() independent function, and the compiler does not see any relationship between them. This means that, until you join these two functions, the compiler would not know what to do with the member of the object. To use the Perimeter member of the TSquare object, you should first assign it an appropriate function that has the same signature as its alias. Then you can use the member of the class as if it were a regular method of the object. Here is an example of how this would be done:

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

#include <iostream>

using namespace std;



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

                                                      

typedef double (*Multiply)(const double a);

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

struct TSquare

{

    Multiply Perimeter;

};

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

double Perimetre(const double x)

{

    return x * 4;

}

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

int main(int argc, char* argv[])

{

    TSquare Sqr;



    double Side = 25.55;

    Sqr.Perimeter = Perimetre;



    cout << "Square Characteristics";

    cout << "\nSide:      " << Side;

    cout << "\nPerimeter: " << Sqr.Perimeter(Side);



    

    

    return 0;

}

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

Using this same approach, you can declare different types of pointers to function as you see fit and using the function signature of your choice. Keep in mind that, when an alias is used to declare a variable, because it is declaring a variable type and not a function, you cannot create various aliases with the same name. This causes a name conflict, even if you try using different function signatures. Here is an example:

Pointers to Method

Many of the functions and classes you will be using when creating applications are from already existing libraries. The idea is to reduce your efforts and be a little faster and productive. You also will be creating a lot of functions and classes. Once you have created such functionalities, there will be no reason to always write the same code over and over again. For example, if you had previously created a class that can process a rectangle object, it would not be good to create a new rectangle class when you need one, you can just refer to one of your classes that can do the job. Code reuse is a tremendous feature of object oriented programming and you should take advantage of it.

We have just learned that you can use a pointer to function to declare a member or members of an object. We learned that, to do this, you must have a function that would implement the desired functionality of the member variable. What about the reverse? Can you create a pointer to a method and use it as a declarable type?

The C++ language allows you to use a member function of an object as pointer to function. To do this, the C++ language require that the name of the method be fully qualified because the compiler would need to know which object possesses that method. The syntax you would use to create such an alias is:

typedef ReturnType (ClassName::*VariableName)(Arguments, if any);

The typedef keyword lets the compiler know that you are creating an alias. The return type must be either a regular data type (int, char, double and their variants) or an object (class a struct). Between the first parentheses, provide the name of the object (class or structure) that "owns" the method whose alias you want to create. The VariableName is a valid C++ name of a variable (and not the function member). If the method takes argument(s), you can provide the type(s) of argument(s) in the second parentheses. If the method does not take any argument, leave the (second) parentheses empty.

Imagine you create a special class that would regularly help you perform arithmetic operations. Such a class can be structured as follows:

class TArithmetic

{

public:

    double Addition(double Value1, double Value2);

    double Subtraction(double Value1, double Value2);

    double Multiplication(double Value1, double Value2);

    double Division(double Numerator, double Denominator);

};

Imagine that, in your program, you want to perform an addition of two values and produce a result. You can create an alias to the Addition method as follows:

typedef double (TArithmetic::*Add)(double x, double y);

With this definition, the word Add can be used in place of a function that takes two double-precision values as arguments and returns a real value. To use this alias, you must point it to the desired method of the object. This can be done as follows:

Add Plus = &TArithmetic::Addition;

Now, the name Plus can be used to call the Addition() method of the TArithmetic class. Of course, because using a class, you must first declare a variable from it. Because Plus is in fact a pointer, you must call it as such. Here is an example of how Plus can be used as a function:

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

#include <iostream>



using namespace std;





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



class TArithmetic

{

public:

    double Addition(double Value1, double Value2);

    double Subtraction(double Value1, double Value2);

    double Multiplication(double Value1, double Value2);

    double Division(double Numerator, double Denominator);

};

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

double TArithmetic::Addition(double Val1, double Val2)

{

    return Val1 + Val2;

}

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

double TArithmetic::Subtraction(double Val1, double Val2)

{

    return Val1 - Val2;

}

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

double TArithmetic::Multiplication(double Val1, double Val2)

{

    return Val1 * Val2;

}

double TArithmetic::Division(double Num, double Den)

{

    if( Den == 0 )

        return 0;

    // else is implied

    return Num / Den;

}

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

int main(int argc, char* argv[])

{

    typedef double (TArithmetic::*Add)(double x, double y);

    

    TArithmetic Oper;

    Add Plus = &TArithmetic::Addition;



    double APlusB = (Oper.*Plus)(244, 125);



    cout << "244 + 125 = " << APlusB;



    

    

    return 0;

}

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

When we studied pointers to functions, we learned to declare them as follows:

double (*Add)(double x, double y);

It would be a good idea to use this alias as a pointer to methods of a class. This could be done as follows:

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

int main(int argc, char* argv[])

{

    double (*Add)(double x, double y);

    

    TArithmetic Oper;

    Add = Oper.Addition;



    double APlusB = Add(244, 125);



    cout << "244 + 125 = " << APlusB;



    

    

    return 0;

}

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

Objects and Pointers to Function

As mentioned already when studying pointers to functions, callback functions are heavily used in Microsoft Windows programming. Besides the regular variables, these functions, called procedures, can take objects as argument. These functions are a little more restrictive.

A pointer to function is a type of function whose name can be assigned to a variable as if it were a regular variable. This eases their use in Win32 procedures and VCL's events. The syntax of declaring a pointer to function is:

DataType (*FunctionName)(ObjectName);

The DataType is the kind of value the function will return.

The FunctionName must be a valid name for a function. Because you are creating a pointer to function, the name of the function must be followed by an asterisk.

This time, unlike pointer to functions of void or other regular data types, a pointer to function that involves an object type must necessarily have at least one argument of class or structure type.

To illustrate this use of pointers to function, we will take an example:

On a Cartesian coordinate system, a line is known as a junction of two points. One of the operations you can perform on such a line is to calculate its length. The equation used is:

To calculate this distance, you can declare a function that would take two points as arguments. This function can be implemented and tested as follows:

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

#include <iostream>

#include <math.h>



using namespace std;





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





namespace Geometry

{

struct TPoint

{

    double x;

    double y;

    TPoint(double X=0, double Y=0) : x(X), y(Y) {}

};

}

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

double Distance(Geometry::Point Pt1, Geometry::Point Pt2)

{

    double L1 = pow(Pt2.x - Pt1.x, 2);

    double L2 = pow(Pt2.y - Pt1.y, 2);

    return sqrt(L1 + L2);

}

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

int main(int argc, char* argv[])

{

    Geometry::Point P(-3, 2);

    Geometry::Point Q(4, -1);

    double Length = Distance(P, Q);



    cout << "The distance between P(-3, 2) and Q(4, -1) is " << Length;



    

    

    return 0;

}

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

On a Cartesian coordinate system, a triangle is represented by three points:

Because this definition does not distinguish a particular type of triangle, it allows calculating the perimeter of a triangle, which is simply done by adding the lengths of the three sides. To perform this calculation, you can create a function that takes three points as arguments. Because a function that performs the distance calculation is already available, you can pass three of its pointers to the new function. Each argument is passed as a pointer to a function that takes two Point objects. After specifying the arguments, pass the necessary arguments that will actually be passed to the function that performs the distance calculations. Such a function can be declared as follows:

double Perimeter(double (*Length1)(Point A, Point B),

                 		 double (*Length2)(Point B, Point C),

                      	 double (*Length3)(Point A, Point C),

                      	 Point First, Point Second, Point Third);

To implement this function, you must call the Distance function for each argument passed as pointer to function. Other than than, you would follow the same rules for implementing functions. Our Perimeter() function can be implemented as follows:

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

double Perimeter(

                      double (*Length1)(Point A, Point B),

                      double (*Length2)(Point B, Point C),

                      double (*Length3)(Point A, Point C),

                      Point First, Point Second, Point Third )

{

    double AB = (*Length1)(First, Second);

    double BC = (*Length2)(Second, Third);

    double AC = (*Length3)(First, Third);

    return AB + BC + AC;

}

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

So far, the compiler does not know how the calculations are performed for the calls in the Perimeter() function. You let the compiler know this when calling the Perimeter() function. In this case, you provide the name of each function that performs the needed calculation. For our example, the name of the function is Distance. Therefore, you would pass it three times. In the function call, the name of the function is used because the actual argument is a pointer to function. The Perimeter() function can be tested as follows:

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

#include <iostream>

#include <math.h>



using namespace std;





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





namespace Geometry

{

struct TPoint

{

    double x;

    double y;

    TPoint(double X=0, double Y=0) : x(X), y(Y) {}

};

}

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

double Distance(Geometry::Point Pt1, Geometry::Point Pt2)

{

    double L1 = pow(Pt2.x - Pt1.x, 2);

    double L2 = pow(Pt2.y - Pt1.y, 2);

    return sqrt(L1 + L2);

}

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

using namespace Geometry;

double Perimeter(

                      double (*Length1)(Point A, Point B),

                      double (*Length2)(Point B, Point C),

                      double (*Length3)(Point A, Point C),

                      Point First, Point Second, Point Third )

{

    double AB = (*Length1)(First, Second);

    double BC = (*Length2)(Second, Third);

    double AC = (*Length3)(First, Third);

    return AB + BC + AC;

}

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

int main(int argc, char* argv[])

{

    Geometry::Point Pt1(-3, -2);

    Geometry::Point Pt2(2, -2);

    Geometry::Point Pt3(4, 2);



    double Perim = Perimeter(Distance, Distance, Distance, Pt1, Pt2, Pt3);



    cout << "Perimeter: " << Perim << endl;



    

    

    return 0;

}

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

This would produce:

Perimeter: 17.5344



Press any key to continue...

To simplify the declaration of the function that takes an argument as pointer to function, you can type define the argument using the typedef keyword. This can be done as follows:

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

#include <iostream>

#include <math.h>



using namespace std;





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





namespace Geometry

{

struct TPoint

{

    double x;

    double y;

    TPoint(double X=0, double Y=0) : x(X), y(Y) {}

};

}

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

double Distance(Geometry::Point Pt1, Geometry::Point Pt2)

{

    double L1 = pow(Pt2.x - Pt1.x, 2);

    double L2 = pow(Pt2.y - Pt1.y, 2);

    return sqrt(L1 + L2);

}

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

typedef double (*SideLength)(Geometry::Point First,

                                        Geometry::Point Second);

double Perimeter(SideLength, SideLength, SideLength,

                            Geometry::Point First, Geometry::Point Second,

                            Geometry::Point Third );

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

using namespace Geometry;



int main(int argc, char* argv[])

{

    Point Pt1(-3, -2);

    Point Pt2( 2, -2);

    Point Pt3( 4,  2);



    double Perim = Perimeter(Distance, Distance, Distance, Pt1, Pt2, Pt3);



    cout << "Perimeter: " << Perim << endl;



    

    

    return 0;

}

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

double Perimeter(

                      double (*Length1)(Point A, Point B),

                      double (*Length2)(Point B, Point C),

                      double (*Length3)(Point A, Point C),

                      Point First, Point Second, Point Third )

{

    double AB = (*Length1)(First, Second);

    double BC = (*Length2)(Second, Third);

    double AC = (*Length3)(First, Third);

    return AB + BC + AC;

}

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

In this program, SideLength is another name for a pointer to function that takes two Point as arguments.

Based on this approach, you can also calculate the Perimeter of a rectangle or any quadratic or other geometric figure whose corners can be identified on a Cartesian coordinate system:

Classes and Self-Return

Self Returning an Object

The constructors are not the only member functions that can be declared with the name of the class. C++ allows you to manipulate the members of a class without using an external function. This technique uses a member function that can return the parent class. To have a function that can refer to the object itself, in the body of the class, declare a method that holds the same name as the class, followed by a valid name of a function and the parentheses. Here is an example:

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

#ifndef FlatShapesH

#define FlatShapesH

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

namespace FlatShapes

{

struct TTriangle

{

private:

    double TriBase;

    double TriHeight;

    double getBase() const;

    void   setBase(const double B);

    double getHeight() const;

    void   setHeight(const double H);

public:

    void   setDimensions(const double B, const double H);

    TTriangle();

    TTriangle(double B, double H);

    TTriangle(const TTriangle &Tri);

    ~TTriangle();

    double Area() const { return TriBase * TriHeight / 2; }



    TTriangle Additional();



    __property double Base = { read = getBase, write = setBase };

    __property double Height = { read = getHeight, write = setHeight };

};

}

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

#endif

An example of using such a function would consist of changing the value of each member of the class. Since the function is declared as returning the value of the same variable, you can implement it as follows:

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







#include "FlatShapes.h"

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



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

namespace FlatShapes

{

TTriangle::TTriangle()

    : TriBase(0.00), TriHeight(0.00)

{

}

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

TTriangle::TTriangle(double B, double H)

    : TriBase(B), TriHeight(H)

{

}

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

TTriangle::TTriangle(const TTriangle &Tri)

    : TriBase(Tri.TriBase), TriHeight(Tri.TriHeight)

{

}

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

TTriangle::~TTriangle()

{

}

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

double TTriangle::getBase() const

{

    return (TriBase < 0 ) ? 0 : TriBase;

}

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

void   TTriangle::setBase(double B)

{

    TriBase = ( B < 0 ) ? 0 : B;

}

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

double TTriangle::getHeight() const

{

    return (TriHeight < 0) ? 0 : TriHeight;

}

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

void   TTriangle::setHeight(double H)

{

    TriHeight = (H < 0 ) ? 0 : H;

}

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

void   TTriangle::setDimensions(const double B, const double H)

{

    setBase(B);

    setHeight(H);

}

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

TTriangle TTriangle::Additional()

{

    TTriangle Tri;



    // The constant double values used here were randomly chosen

    Tri.TriBase   = TriBase + 12.52;

    Tri.TriHeight = TriHeight + 8.95;



    return Tri;

}

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

}

Calling this self-returning function is equivalent to changing the values of the member variables, as illustrated when called in the main() function:

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

#include <iostream>



 

#include "FlatShapes.h"



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

using namespace std;

using namespace FlatShapes;



void ShowCharacteristics(const TTriangle*);

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

int main(int argc, char* argv[])

{

    TTriangle Angular;



    Angular.setDimensions(22.44, 26.38);

    ShowCharacteristics(&Angular);



    cout << endl << endl;

    TTriangle Plane = Angular.Additional();

    ShowCharacteristics(&Plane);



    

    

    return 0;

}

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

void ShowCharacteristics(const TTriangle* Tri)

{

    cout << " - Triangle Characteristics -";

    cout << "\nBase:   " << Tri->Base;

    cout << "\nHeight: " << Tri->Height;

    cout << "\nArea:   " << Tri->Area();

}

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

You can use this ability to declare almost any type of function that returns the same class. One particular method can be used to modify the default values of the member variables. Another method can be used to convert the values of another class into those needed by the class.

The this Pointer

C++ proposes an alternative to returning an object from one of its member functions. Instead of explicitly declaring a variable when implementing a function that returns the same object, the compiler simply needs to know what object you want to return: the object that called the method or a newly declared one. If you want to return the same object, you can use a special pointer called this.

As its name implies, the this pointer is a self referencing object, which means it allows you to designate the object that is making the call as the same object you are referring to. Using the this pointer is a technique that allows you to perform any necessary operation on an object without the help of an external function and returning the same object.

Suppose you want to transform the Additional() method of the TTriangle object above so it would return the same variable that calls it. Because the method will return the same object, you do not need to declare a local variable to hold the changed variable. Since the member variables of the object will be modified, the member function cannot be declared as a constant.

When implementing this method, the values of the variables will certainly be modified to implement whatever behavior you want. To return the same object, the this object must be called as a pointer, with *this. Here is the new implementation of the function:

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

TTriangle TTriangle::Additional()

{

    // The constant double values used here were randomly chosen

    Tri.TriBase   = TriBase + 12.52;

    Tri.TriHeight = TriHeight + 8.95;



    return *this;

}

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

Using the same approach, you can define and use other methods that return the same object:

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

#ifndef FlatShapesH

#define FlatShapesH

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

namespace FlatShapes

{

struct TTriangle

{

private:

    double TriBase;

    double TriHeight;

    double getBase() const;

    void   setBase(const double B);

    double getHeight() const;

    void   setHeight(const double H);

public:

    void   setDimensions(const double B, const double H);

    TTriangle();

    TTriangle(double B, double H);

    TTriangle(const TTriangle &Tri);

    ~TTriangle();

    double Area() const { return TriBase * TriHeight / 2; }



    TTriangle Additional();

    TTriangle AddAConstant(const double d);

    TTriangle AddAnotherObject(const TTriangle& E);



    __property double Base = { read = getBase, write = setBase };

    __property double Height = { read = getHeight, write = setHeight };

};

}

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

#endif

Such methods can be implemented to return the this pointer and the same object that made the call:

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







#include "FlatShapes.h"

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



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

namespace FlatShapes

{

. . . No Change

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

TTriangle TTriangle::Additional()

{

    // The constant double values used here were randomly chosen

    TriBase   = TriBase + 12.52;

    TriHeight = TriHeight + 8.95;



    return *this;

}



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

TTriangle TTriangle::AddAConstant(const double d)

{

    TriBase   = TriBase + d;

    TriHeight = TriHeight + d;



    return *this;

}

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

TTriangle TTriangle::AddAnotherObject(const TTriangle& E)

{

    TriBase   += E.TriBase;

    TriHeight += E.TriHeight;



    return *this;

}

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

}

Since the function that returns the this pointer returns it as a pointer, you can reinforce the fact that the variable that is being returned is modified. Therefore, instead of returning the object as a regular variable, you should make the returned value a reference:

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

#ifndef FlatShapesH

#define FlatShapesH

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

namespace FlatShapes

{

struct TTriangle

{

private:

    double TriBase;

    double TriHeight;

    double getBase() const;

    void   setBase(const double B);

    double getHeight() const;

    void   setHeight(const double H);

public:

    void   setDimensions(const double B, const double H);

    TTriangle();

    TTriangle(double B, double H);

    TTriangle(const TTriangle &Tri);

    ~TTriangle();

    double Area() const { return TriBase * TriHeight / 2; }

    TTriangle& Additional();
    TTriangle& AddAConstant(const double d);
    TTriangle& AddAnotherObject(const TTriangle& E);

    __property double Base = { read = getBase, write = setBase };
    __property double Height = { read = getHeight, write = setHeight };

    };
}
//---------------------------------------------------------------------------
#endif

In this case, remember to use the reference operator, the ampersand:

//---------------------------------------------------------------------------
TTriangle& TTriangle::Additional()
{
    // The constant double values used here were randomly chosen
    TriBase   = TriBase + 12.52;
    TriHeight = TriHeight + 8.95;

    return *this;
}
//---------------------------------------------------------------------------
TTriangle& TTriangle::AddAConstant(const double d)

{
	TriBase   = TriBase + d;
	TriHeight = TriHeight + d;

	return *this;
}
//---------------------------------------------------------------------------
TTriangle& TTriangle::AddAnotherObject(const TTriangle& E)
{
	TriBase   += E.TriBase;
	TriHeight += E.TriHeight;

	return *this;
}
//---------------------------------------------------------------------------

Practical Learning: Ending the Lesson

• Close your programming environment