//Listing 10.2 Default values in member functions

#include <iostream.h>

// Rectangle class declaration

class Rectangle
{
public:
	// constructors

	Rectangle(int width, int height);
	~Rectangle(){}
	void DrawShape(int aWidth, int aHeight, bool UseCurrentVals =
												false) const;

private:
	int itsWidth;
	int itsHeight;
};

//Constructor implementation

Rectangle::Rectangle(int width, int height):
itsWidth(width),       
itsHeight(height)
// what does this do?  My stupid book doesn't explain it, unless

// I accidentally missed the

// explanation.



{}                     


// default values used for third parameter

void Rectangle::DrawShape(
int width,
int height,
bool UseCurrentValue
) const
{
	int printWidth;
	int printHeight;

	if (UseCurrentValue == true)
	{
		printWidth = itsWidth;       // use current class values

		printHeight = itsHeight;
	}
	else
	{
		printWidth = width;         // use parameter values

		printHeight = height;
	}


	for (int i = 0; i<printHeight; i++)
	{
		for (int j = 0; j< printWidth; j++)
		{
			cout << "*";
		}
		cout << "\n";
	}
}

// Driver program to demonstrate overloaded functions

int main()
{
	// initialize a rectangle to 30,5

	Rectangle theRect(30,5);
	cout << "DrawShape(0,0,true)...\n";
	theRect.DrawShape(0,0,true);
	cout <<"DrawShape(40,2)...\n";
	theRect.DrawShape(40,2);
	return 0;
}

    

      class FirstClass{public:   FirstClass(int i);   ~FirstClass();private:   FirstClass();};class SecondClass{public:   SecondClass();   ~SecondClass();private:   FirstClass m_variable;};  In this case, you'll see that the only public constructor that has been defined for FirstClass requires you to pass in an integer.  By the body of SecondClass's constructor (between the {} ) all the member variables must be completely constructed.  So you would write the constructor for SecondClass something like this:      SecondClass::SecondClass():m_variable(123){}      

  class foo {  int a, b;  foo(int aa, int bb);};  

  foo::foo(int aa, int bb)  : a(aa), b(bb){}// andfoo::foo(int aa, int bb){  a = aa;  b == bb;}  

  class bar {  // default constructor  bar() { ... }  // copy constructor  bar(const bar& other_bar) { ... }  // assignment operator  bar& operator =(const bar& other_bar) { ... }  // more stuff};class foo {  // now we have a user-defined type as a member  bar x;  foo(const bar& xx);};  

  foo::foo(const bar& xx)// this line initializes x. bar''s copy constructor is called  : x(xx){}// orfoo::foo(const bar& xx){  // at this point, x must be constructed. bar''s default constructor has already been called  // the following line invokes bar''s assignment operator  x = xx;}