Class Construction

Imagine you are writing a program for a business that sells flowers:

Flower
Type	Daisies	Lilies	Roses	Live Plants	Tulips
Color	Mixed	Yellow	Red	Green	Mixed
Arrangement	Bouquet	Planter Box	Bouquet	Basket	Any
Price	35.25	115.95	85.95	60.95	58.95

Consider the following program:

using namespace System;

public value class CFlower
{
public:
      int       Type;
      int       Color;
      __wchar_t Arrangement;
      double    UnitPrice;
};

int main()
{
	CFlower ^ flr = gcnew CFlower;
	
	Console::WriteLine(L"Flower Type:  {0}", flr->Type);
	Console::WriteLine(L"Flower Color: {0}", flr->Color);
	Console::WriteLine(L"Arrangement:  {0}", flr->Arrangement);
	Console::WriteLine(L"Price:        {0:C}", flr->UnitPrice);
	Console::WriteLine(L"");
	return 0;
}

This would produce:

Flower Type:  0
Flower Color: 0
Arrangement:
Price:        $0.00

Press any key to continue . . .

If you declare a variable of a class in your program, when the program comes up, the compiler reserves enough memory space for each member of the class. The memory space reserved for each member variable is filled with an initial value based on its type. For a String object, the space would be left empty. For an integer type, the space would be filled with 0. A better way to take care of this type is to provide a value whose role would be to initialize the member variables with the values of your choice. A method that initializes an object can return any value but it is preferable to be of type void because its primary purpose is to reset the values. Since this method would give a starting value to all member variables that need to be initialized, it should have an equivalent argument for each of the member variables that it would initialize. Here is an example:

public value class CFlower
{
public:
      int         Type;
      int         Color;
      __wchar_t   Arrangement;
      double      UnitPrice;

      void Initializer(int type, int color, __wchar_t arrange, double price);
};

The method initializer doesn't have to initialize all members of the class. For example, the previous execution of the program shows that the member variables that are of type String are initialized with empty strings. In such a case, you may not have to initialize such variables. To implement a method initializer, simply assign its argument to the corresponding member variable of the class. Here are examples:

void CFlower::Initializer(int tp, int clr,
			 __wchar_t arrange, double price)
{
	Type  = tp;
	Color = clr;
	Arrangement = arrange;
	UnitPrice   = price;
}

You can call a method initializer after declaring the instance of the class to give it initial values. Here is an example:

using namespace System; public value class CFlower { public: int Type; int Color; __wchar_t Arrangement; double UnitPrice; void Initializer(int type, int color, __wchar_t arrange, double price); }; void CFlower::Initializer(int tp, int clr, __wchar_t arrange, double price) { Type = tp; Color = clr; Arrangement = arrange; UnitPrice = price; } int main() { CFlower ^ flr = gcnew CFlower; flr->Initializer(3, 7, L'U', 35.85); Console::WriteLine(L"Flower Type: {0}", flr->Type); Console::WriteLine(L"Flower Color: {0}", flr->Color); Console::WriteLine(L"Arrangement: {0}", flr->Arrangement); Console::WriteLine(L"Price: {0:C}", flr->UnitPrice); Console::WriteLine(L""); return 0; }

This would produce:

Flower Type:  3
Flower Color: 7
Arrangement:  U
Price:        $35.85

Press any key to continue . . .

Using a method initializer, after initializing the object, you can use the values it holds as you see fit.

1. Start Microsoft Visual C++ 2005
2. On the main menu, click File -> New -> Project...
3. On the left side, make sure that Visual C++ is selected. In the Templates list, click CLR Empty Project
4. In the Name box, replace the string with ElectroStore3 and click OK
5. On the main menu, click Project -> Add New Item...
6. To create a header file, in the Templates list, click Header File (.h)
7. Set the Name to StoreItem and click Add
8. Complete the file as follows:
    

   #pragma once using namespace System; namespace ElectronicsStore { public ref class CStoreItem { private: long nbr; __wchar_t ^ cat; String ^ mk; String ^ mdl; double discount; double price; public: inline long GetItemNumber(); inline void SetItemNumber(const long number); inline __wchar_t ^ GetCategory(); inline void SetCategory(__wchar_t ^ category); inline String ^ GetMake(); inline void SetMake(String ^ make); inline String ^ GetModel(); inline void SetModel(String ^ model); inline double GetDiscountRate(); inline void SetDiscountRate(const double discountRate); inline double GetUnitPrice(); inline void SetUnitPrice(const double unitPrice); }; }

9. To create a source file, on the main menu, click Project -> Add New Item...
10. In the Templates list, click C++ File (.h)
11. Set the Name to StoreItem and press Enter
12. Complete the file as follows:
     

    #include "StoreItem.h" using namespace System; namespace ElectronicsStore { inline long CStoreItem::GetItemNumber() { return nbr; } inline void CStoreItem::SetItemNumber(const long number) { this->nbr = number; } inline __wchar_t ^ CStoreItem::GetCategory() { return cat; } inline void CStoreItem::SetCategory(__wchar_t ^ category) { this->cat = category; } inline String ^ CStoreItem::GetMake() { return mk; } inline void CStoreItem::SetMake(String ^ make) { this->mk = make; } inline String ^ CStoreItem::GetModel() { return mdl; } inline void CStoreItem::SetModel(String ^ model) { this->mdl = model; } inline double CStoreItem::GetDiscountRate() { return discount / 100; } inline void CStoreItem::SetDiscountRate(const double discountRate) { this->discount = discountRate; } inline double CStoreItem::GetUnitPrice() { return price; } inline void CStoreItem::SetUnitPrice(const double unitPrice) { this->price = unitPrice; } }

13. To create one more source file, on the main menu, click Project -> Add New Item...
14. In the Templates list, make sure C++ File (.cpp) is selected.
    Set the Name to Exercise and click Add
15. Complete the file as follows:
     

    #include "StoreItem.h" using namespace System; using namespace ElectronicsStore; static void DescribeStoreItem(CStoreItem ^ %); int main() { String ^ strTitle = L"=-= Nearson Electonics =-=\n" L"******* Store Items ******"; Console::WriteLine(); return 0; } void DescribeStoreItem(CStoreItem ^ %item) { Console::WriteLine(L"Store Item Description"); Console::WriteLine(L"Item Number: {0}", item->GetItemNumber()); Console::WriteLine(L"Category: {0}", item->GetCategory()); Console::WriteLine(L"Make {0}", item->GetMake()); Console::WriteLine(L"Model: {0}", item->GetModel()); Console::WriteLine(L"Discount Rate: {0:P}", item->GetDiscountRate()); Console::WriteLine(L"Unit Price: {0:C}", item->GetUnitPrice()); }

16. Execute the application to make sure it can compile
17. Close the DOS window

A constructor is a special method that is created when the object comes to life. This particular method holds the same name as that of the class and it initializes the object whenever that object is created. Unlike some of the other methods, the constructor does not return a value, not even void. When you create a class, if you don't declare a constructor, the compiler would create one for you; this is useful because it lets all other objects and functions of the program know that the object exists. This compiler-created constructor is called the default constructor. If you want, you can create your own constructor. To create a constructor, declare a method that holds the same name as the class. Remember that the method must not return any value. Besides that, the second rule is that the class must be created with the ref instead of the value keywords.

Here is an example:

public ref class CFlower
{
public:
    int         Type;
    int         Color;
    __wchar_t   Arrangement;
    double      UnitPrice;
	
    CFlower();
};

When you declare an instance of the class, whether you use that object or not, a constructor for the object is created and signals itself. When an instance of a class has been declared, the default constructor is called, whether the object is used or not. This is illustrated in the following program:

using namespace System;

public ref class CFlower
{
public:
    int       Type;
    int       Color;
    __wchar_t Arrangement;
    double    UnitPrice;
    CFlower();
};

CFlower::CFlower()
{
    Console::WriteLine("An order has been placed!!!");
}

int main()
{
    CFlower ^ flr = gcnew CFlower;

    Console::WriteLine(L"");
    return 0;
}

This would produce:

An order has been placed!!!

Press any key to continue...

As you can see, even though the flr variable was not used, just its declaration was enough to signal it. You might find it sometimes convenient to create your own constructor because, whether you create an empty constructor or not, this does not negatively impact your program.

When declaring an instance of a class using the default constructor, you can use or omit the parentheses. The effect is the same. Therefore, you can declare a CFlower variable as follows:

int main()
{
    CFlower ^ flr = gcnew CFlower();

    Console::WriteLine(L"");
    return 0;
}

Also, remember that, in C++, if a method doesn't take an argument, when declaring and defining the method, you can type void in its parentheses:

public ref class CFlower
{
public:
    int         Type;
    int         Color;
    __wchar_t   Arrangement;
    double      UnitPrice;
    Flower(void);
};

Flower::Flower(void)
{
}

1. Access the StoreItem.h header file
2. Create a default constructor as follows:
    

   #pragma once using namespace System; namespace ElectronicsStore { public ref class CStoreItem { public: CStoreItem(void); private: long nbr; __wchar_t ^ cat; String ^ mk; String ^ mdl; double discount; double price; public: . . . No Change }; }

3. Save the file

A constructor can be used to initialize the member variables of a class. As such, a constructor provides a valuable alternative to a method initializer, the type of method we saw earlier. To use a constructor to initialize the member variables of a class, provide as arguments the necessary variables that you intend to initialize. You don't have to initialize all member variables in the constructor, only those that need to be initialized. In fact, you should initialize only those members that you think the other objects or functions would need when using this object. This means that your object may have member variables that, either the external objects or functions don't need to modify (or access) or the member variable(s) will be initialized later when called from the needed object(s) or function(s).

To implement a default constructor, you can just initialize the desired members of the class. For a member variable of a numeric type, you can just assign the desired constant to each. Here is an example:

CFlower::CFlower(void)
{
    Type = 1;
}

If the variable is a character, assign a single-quoted symbol to it. If the variable is a string, then assign a double-quoted value to the variable. Here are examples:

using namespace System; public ref class CFlower { public: String ^ Type; String ^ Color; String ^ Arrangement; double UnitPrice; CFlower(); }; CFlower::CFlower() { Type = L"Roses"; Color = L"Red"; Arrangement = L"Basket"; UnitPrice = 45.95; }

int main()
{
    CFlower ^ flr = gcnew CFlower;

    Console::WriteLine(L"Flower Type:  {0}", flr->Type);
    Console::WriteLine(L"Flower Color: {0}", flr->Color);
    Console::WriteLine(L"Arrangement:  {0}", flr->Arrangement);
    Console::WriteLine(L"Price:        {0:C}", flr->UnitPrice);

    Console::WriteLine(L"");
    return 0;
}

This would produce:

Flower Type:  Roses
Flower Color: Red
Arrangement:  Basket
Price:        $45.95

Press any key to continue . . .

If the member is a handle to a class, make sure you initialize it prior to using it. 

1. Access the StoreItem.cpp source file
2. To specify the default values of the member variables of the class, implement the default constructor as follows:
    

   #include "StoreItem.h" using namespace System; namespace ElectronicsStore { CStoreItem::CStoreItem(void) { nbr = 0; cat = L'U'; mk = L"Unknown"; mdl = L"Unspecified"; discount = 0.00; price = 0.00; } . . . No Change }

3. Access the Exercise.cpp source file
4. To use the default constructor, change the file as follows:
    

   #include "StoreItem.h" using namespace System; using namespace ElectronicsStore; static void DescribeStoreItem(CStoreItem ^ %); int main() { String ^ strTitle = L"=-= Nearson Electonics =-=\n" L"******* Store Items ******"; CStoreItem ^ saleItem = gcnew CStoreItem(); DescribeStoreItem(saleItem); Console::WriteLine(); return 0; } void DescribeStoreItem(CStoreItem ^ %item) { Console::WriteLine(L"Store Item Description"); Console::WriteLine(L"Item Number: {0}", item->GetItemNumber()); Console::WriteLine(L"Category: {0}", item->GetCategory()); Console::WriteLine(L"Make {0}", item->GetMake()); Console::WriteLine(L"Model: {0}", item->GetModel()); Console::WriteLine(L"Discount Rate: {0:P}", item->GetDiscountRate()); Console::WriteLine(L"Unit Price: {0:C}", item->GetUnitPrice()); }

5. Execute the application to see the result:
    

   Store Item Description Item Number: 0 Category: U Make Unknown Model: Unspecified Discount Rate: 0.00 % Unit Price: $0.00 Press any key to continue . . .

6. Close the DOS window

The default constructor is the favorite place to provide default values to the members of a class. Besides the default constructor, you can add as many constructors as you judge necessary. This feature of C++ allows you to create various constructors for different reasons. This also means that, like ordinary functions, the methods or constructors of a class can be overloaded.

One of the rules of function overloading consists of having functions with different types of arguments. The most basic constructor you would create can use a single argument. When implementing a constructor that takes one argument, you should initialize the member that corresponds to the unique argument and initialize the other members with default values. Here is an example:

public ref class CFlower
{
public:
    String ^ Type;
    String ^ Color;
    String ^ Arrangement;
    double   UnitPrice;
	
    CFlower(String ^ type);
};

CFlower::CFlower(String ^ type)
{
    Type        = type;
    Color       = L"Red";
    Arrangement = L"Basket";
    UnitPrice   = 35.95;
}

If you create a class with only one constructor as in the current example, when declaring an instance of the class, you must use that constructor: you cannot use the default constructor that doesn't take an argument. When declaring the variable, initialize it with a constructor with parentheses and provide the value(s) in the parentheses of the constructor. Here is an example:

using namespace System;

public ref class CFlower
{
public:
    String ^ Type;
    String ^ Color;
    String ^ Arrangement;
    double   UnitPrice;
	
    CFlower(String ^ type);
};

CFlower::CFlower(String ^ type)
{
    Type        = type;
    Color       = L"Red";
    Arrangement = L"Basket";
    UnitPrice   = 35.95;
}

int main()
{
    CFlower ^ flr = gcnew CFlower(L"Tulip");

    Console::WriteLine(L"Flower Type:  {0}", flr->Type);
    Console::WriteLine(L"Flower Color: {0}", flr->Color);
    Console::WriteLine(L"Arrangement:  {0}", flr->Arrangement);
    Console::WriteLine(L"Price:        {0:C}", flr->UnitPrice);

    Console::WriteLine(L"");
    return 0;
}

This would produce:

Flower Type:  Tulip
Flower Color: Red
Arrangement:  Basket
Price:        $35.95

Press any key to continue . . .

In the same way, you can create different constructors for different initializations, although it would not be realistic to create a different constructor for each variable. If you create different constructors with different arguments to initialize (remember the rules of function overloading), when declaring the classes, make sure you initialize each instance with the right number of arguments; otherwise, the compiler may complain.

If you create a class with only one constructor and that constructor has at least one argument, the default constructor would not be available anymore. If you want to access a default constructor of an object, you have two alternatives:

• If you don't create any constructor at all on a class, the default constructor would always be available whenever you invoke that class
• If you create at least one constructor on a class and supply at least one argument to that constructor, you must explicitly create a default constructor for your class.

1. Access the StoreItem.h file
2. To overload the constructor, change the file as follows:
    

   #pragma once using namespace System; namespace ElectronicsStore { public ref class CStoreItem { public: // An item whose characteristics are not (yet) known CStoreItem(void); // An item that is known by its make, model, and unit price CStoreItem(long itmNbr, String ^ make, String ^ model, double unitPrice); // An item that is known by its name and unit price CStoreItem(long itmNbr, String ^ name, double unitPrice); private: long nbr; __wchar_t ^ cat; String ^ mk; String ^ mdl; String ^ nm; double discount; double price; public: inline long GetItemNumber(); inline void SetItemNumber(const long number); inline __wchar_t ^ GetCategory(); inline void SetCategory(__wchar_t ^ category); inline String ^ GetMake(); inline void SetMake(String ^ make); inline String ^ GetModel(); inline void SetModel(String ^ model); inline String ^ GetName(); inline void SetName(String ^ name); inline double GetDiscountRate(); inline void SetDiscountRate(const double discountRate); inline double GetUnitPrice(); inline void SetUnitPrice(const double unitPrice); }; }

3. Access the StoreItem.cpp file
4. To implement the constructors, change the file as follows:
    

   #include "StoreItem.h" using namespace System; namespace ElectronicsStore { CStoreItem::CStoreItem(void) { nbr = 0; cat = L'U'; mk = L"Unknown"; mdl = L"Unspecified"; nm = L"N/A"; discount = 0.00; price = 0.00; } CStoreItem::CStoreItem(long itmNbr, String ^ make, String ^ model, double unitPrice) { nbr = itmNbr; cat = L'U'; mk = make; mdl = model; nm = L"N/A"; discount = 0.00; price = unitPrice; } CStoreItem::CStoreItem(long itmNbr, String ^ name, double unitPrice) { nbr = itmNbr; cat = L'U'; mk = L"Unknown"; mdl = L"Unspecified"; nm = name; discount = 0.00; price = unitPrice; } inline long CStoreItem::GetItemNumber() { return nbr; } inline void CStoreItem::SetItemNumber(const long number) { this->nbr = number; } inline __wchar_t ^ CStoreItem::GetCategory() { return cat; } inline void CStoreItem::SetCategory(__wchar_t ^ category) { this->cat = category; } inline String ^ CStoreItem::GetMake() { return mk; } inline void CStoreItem::SetMake(String ^ make) { this->mk = make; } inline String ^ CStoreItem::GetModel() { return mdl; } inline void CStoreItem::SetModel(String ^ model) { this->mdl = model; } inline String ^ CStoreItem::GetName() { return nm; } inline void CStoreItem::SetName(String ^ name) { name = nm; } inline double CStoreItem::GetDiscountRate() { return discount / 100; } inline void CStoreItem::SetDiscountRate(const double discountRate) { this->discount = discountRate; } inline double CStoreItem::GetUnitPrice() { return price; } inline void CStoreItem::SetUnitPrice(const double unitPrice) { this->price = unitPrice; } }

5. Access the Exercise.cpp file
6. To use the constructors, change the file as follows:
    

   #include "StoreItem.h" using namespace System; using namespace ElectronicsStore; static void DescribeStoreItem(CStoreItem ^ %); int main() { String ^ strTitle = L"=-= Nearson Electonics =-=\n" L"******* Store Items ******"; CStoreItem ^ saleItem = gcnew CStoreItem(); Console::WriteLine(L"==/==A store item with default values==/=="); DescribeStoreItem(saleItem); Console::WriteLine(); saleItem = gcnew CStoreItem(606302, L"Altec Lansing", L"AHP-712I", 85.95); saleItem->SetCategory(L'H'); saleItem->SetDiscountRate(25); Console::WriteLine(L"==/==A store item known for its make, " L"model, and unit price==/=="); DescribeStoreItem(saleItem); Console::WriteLine(); Console::WriteLine(L"==/==A store item with default values==/=="); saleItem = gcnew CStoreItem(162864, L"External Sound Card", 85.95); DescribeStoreItem(saleItem); Console::WriteLine(); Console::WriteLine(L"==/==A store item completely defined==/=="); saleItem = gcnew CStoreItem(513497, L'T', L"Uniden", L"8x8 Packet8 Broadband Internet Phone System", 10, 145.95); DescribeStoreItem(saleItem); Console::WriteLine(); Console::WriteLine(L"==/==A store item with each " L"characteristic defined==/=="); saleItem = gcnew CStoreItem(); saleItem->SetItemNumber(913846); saleItem->SetCategory(L'S'); saleItem->SetMake(L"APC"); saleItem->SetModel(L"Personal SurgeArrest"); saleItem->SetDiscountRate(25.00); saleItem->SetUnitPrice(14.95); DescribeStoreItem(saleItem); Console::WriteLine(); return 0; } void DescribeStoreItem(CStoreItem ^ %item) { Console::WriteLine(L"Store Item Description"); Console::WriteLine(L"Item Number: {0}", item->GetItemNumber()); Console::WriteLine(L"Category: {0}", item->GetCategory()); Console::WriteLine(L"Make {0}", item->GetMake()); Console::WriteLine(L"Model: {0}", item->GetModel()); Console::WriteLine(L"Name: {0}", item->GetName()); Console::WriteLine(L"Discount Rate: {0:P}", item->GetDiscountRate()); Console::WriteLine(L"Unit Price: {0:C}", item->GetUnitPrice()); }

7. Execute the application to see the result:
    

   ==/==A store item with default values==/== Store Item Description Item Number: 0 Category: U Make Unknown Model: Unspecified Name: N/A Discount Rate: 0.00 % Unit Price: $0.00
   ==/==A store item known for its make, model, and unit price==/== Store Item Description Item Number: 606302 Category: H Make Altec Lansing Model: AHP-712I Name: N/A Discount Rate: 25.00 % Unit Price: $85.95
   ==/==A store item with default values==/== Store Item Description Item Number: 162864 Category: U Make Unknown Model: Unspecified Name: External Sound Card Discount Rate: 0.00 % Unit Price: $85.95
   ==/==A store item completely defined==/== Store Item Description Item Number: 513497 Category: T Make Uniden Model: 8x8 Packet8 Broadband Internet Phone System Name: Discount Rate: 10.00 % Unit Price: $145.95
   ==/==A store item with each characteristic defined==/== Store Item Description Item Number: 913846 Category: S Make APC Model: Personal SurgeArrest Name: N/A Discount Rate: 25.00 % Unit Price: $14.95

8. Close the DOS window

By now, we saw that methods can be implemented inline, that is, in the body of a class. This also applies to constructors:

public ref class CFlower
{
public:
    String ^ Type;
    String ^ Color;
    String ^ Arrangement;
    double   UnitPrice;

    CFlower()
    {
        Type        = L"Roses";
        Color       = L"Red";
        Arrangement = L"Basket";
        UnitPrice   = 45.95;
    }

    CFlower(String ^ type);
};

C++ provides another technique you can use to initialize the member variables in a constructor. To initialize the list of members, after defining the constructor, which is after the parentheses, type a colon, followed by the name of an argument and include its initial value in parentheses. The initializations are separated by a comma. Since the constructor is a method, make sure you provide its body. Here are examples:

public ref class CFlower
{
public:
    String ^ Type;
    String ^ Color;
    String ^ Arrangement;
    double   UnitPrice;

    CFlower() : Type(L"Roses"), Color(L"Red"),
	        Arrangement(L"Basket"), UnitPrice(35.95)
    {
    }

    CFlower(String ^ type);
};

CFlower::CFlower(String ^ type)
	: Type(type),
	  Color(L"Red"),
	  Arrangement(L"Basket"),
	  UnitPrice(45.95)
{
}

You can still use the initialization that consists of assigning a value to the desired member variable. Still, observe the rules when declaring a variable of the class:

#include <iostream>

using namespace std;
using namespace System;

public ref class CFlower
{
public:
    String ^ Type;
    String ^ Color;
    String ^ Arrangement;
    double   UnitPrice;

    CFlower() : Type(L"Roses"), Color(L"Red"),
	        Arrangement(L"Basket"), UnitPrice(45.95)
    {
    }

    CFlower(String ^ type);
    CFlower(String ^ type, String ^ color,
	    String ^ argn, double price);
};

CFlower::CFlower(String ^ type)
	: Type(type),
	  Color(L"Red"),
	  Arrangement(L"Basket"),
	  UnitPrice(35.95)
{
}

CFlower::CFlower(String ^ type, String ^ color,
		 String ^ argn, double price)
{
    Type = type;
    Color = color;
    Arrangement = argn;
    UnitPrice = price;
}

void Show(const CFlower ^ flower)
{
    Console::WriteLine(L"Flower Type:  {0}", flower->Type);
    Console::WriteLine(L"Flower Color: {0}", flower->Color);
    Console::WriteLine(L"Arrangement:  {0}", flower->Arrangement);
    Console::WriteLine(L"Price:        {0:C}", flower->UnitPrice);
}

int main()
{
    // Using the default constructor
    CFlower ^ flower = gcnew CFlower;
    Show(flower);
    Console::Write(L"\nPress any key to continue...");
    Console::ReadLine();
    system("cls");

    // Using the constructor with one argument
    flower = gcnew CFlower(L"Tulip");
    Show(flower);
    Console::Write(L"\nPress any key to continue...");
    Console::ReadLine();
    system("cls");

    // Using a full constructor
    flower = gcnew CFlower(L"Lilies", L"Pink", L"Bouquet", 45.65);

    Console::WriteLine(L"");
    return 0;
}

This would produce:

Flower Type:  Roses
Flower Color: Red
Arrangement:  Basket
Price:        $35.95

Press any key to continue...

Flower Type:  Tulip
Flower Color: Red
Arrangement:  Basket
Price:        $35.95

Press any key to continue...

Flower Type:  Lilies
Flower Color: Pink
Arrangement:  Bouquet
Price:        $45.65

Press any key to continue . . .

1. Access the StoreItem.cpp file and change it as follows:
    

   #include "StoreItem.h" using namespace System; namespace ElectronicsStore { CStoreItem::CStoreItem(void) : nbr(0), cat(L'U'), mk(L"Unknown"), mdl(L"Unspecified"), nm(L"N/A"), discount(0.00), price(0.00) { } CStoreItem::CStoreItem(long itmNbr, String ^ make, String ^ model, double unitPrice) : nbr(itmNbr), cat(L'U'), mk(make), mdl(model), nm(L"N/A"), discount(0.00), price(unitPrice) { } CStoreItem::CStoreItem(long itmNbr, String ^ name, double unitPrice) : nbr(itmNbr), cat(L'U'), mk(L"Unknown"), mdl(L"Unspecified"), nm(name), discount(0.00), price(unitPrice) { } CStoreItem::CStoreItem(long itmNbr, __wchar_t category, String ^ make, String ^ model, double discountRate, double unitPrice) : nbr(itmNbr), cat(category), mk(make), mdl(model), discount(discountRate), price(unitPrice) { } . . . No Change }

2. Execute the application to test it