help with virtual print function

[cmt9000]

Hi, for my assignment I needed to create a virtual print function in my base class.

Eveything seems to work except the printing part.

When it loops through the array and prints, it's outputting like this:

Manufacturer: Winchester
Caliber: .38
Grips: side
Sigts: iron
Laser: true
Single Action: Single Action
Number of Rounds: 500
Semi auto: true


Press any key to continue . . .

It seems to be combining all 3 guns into 1 gun.

Is there a way to keep the guns separate?

Thanks!

#pragma warning(disable: 4996)
#include <cstdlib>
#include <iostream>
#include <string>
#include <cctype>
#include <stack>
#include <conio.h>

using namespace std;

// *** Class definitions ***

//base class
class Gun {

protected:
	string g_manufacturer;
	string g_caliber;
	//string gunCabinet[2];
public:
	Gun();
	Gun(const string manufacturer, const string caliber) {
		g_manufacturer = manufacturer;
		g_caliber = caliber;
	}
	
	string getManufactuer() {
		return g_manufacturer;
	}

	string getCaliber() {
		return g_caliber;
	}

	void setManufactuer(string m);
	void setCaliber(string c);
	virtual void print();
};

class Handgun : public Gun {
protected:
	string h_grips;
	string h_sights;
	bool h_laser;

public:
	Handgun();
	Handgun(const string manufacturer, const string caliber, const string grips, const string sights, const bool laser)
	: Gun(manufacturer, caliber) {
		h_grips = grips;
		h_sights = sights;
		h_laser = laser;
	};

	string getGrips() {
		return h_grips;
	}

	string getSights() {
		return h_sights;
	}

	bool getLaser() {
		return h_laser;
	}

	void print();
	void setGrips(string g);
	void setSights(string s);
	void setLaser(bool l);
};

class Revolver : public Handgun {
private:
	bool r_singleAction;
	int r_numberOfRounds;

	/*Handgun(const string manufacturer, const string caliber, const string g, const string s, const bool l)
		: Gun(manufacturer, caliber) {
		grips = g;
		sights = s;
		laser = l;
	};*/

public:
	Revolver();
	Revolver(const string manufacturer, const string caliber, const string grips, const string sights, const bool laser, bool singleAction, int numberOfRounds)
		: Handgun(manufacturer, caliber, grips, sights, laser) {
		r_singleAction = singleAction;
		r_numberOfRounds = numberOfRounds;
	}

	string getSingleAction();

	int getNumberOfRounds() {
		return r_numberOfRounds;
	}

	void print();
	void setSingleAction(bool singleAction);
	void setNumberOfRounds(int numberOfRounds);
};

class Pistol : public Handgun {
private: 
	bool p_semiAuto;

public:
	Pistol();
	Pistol(const string manufacturer, const string caliber, const string grips, const string sights, const bool laser, bool semiAuto)
		: Handgun(manufacturer, caliber, grips, sights, laser) {
		p_semiAuto = semiAuto;
	}

	bool getSemiAuto() {
		return p_semiAuto;
	}

	void print();
	void setSemiAuto(bool semiAuto);
};

//main
int main()
{
	Handgun myHandgun("Winchester", ".38","side","iron",true);

	Revolver myRevolver("HK", ".45", "top", "iron", true, true, 500);
	
	Pistol myPistol("Smith & Wesson", ".50", "top", "scope", true, true);

	Gun *myGunCabinet[3];

	myGunCabinet[0] = &myHandgun;
	myGunCabinet[1] = &myRevolver;
	myGunCabinet[2] = &myPistol;


	for (int i = 0; i < 3; i++)
		myGunCabinet[i] -> print();

	//need this so the DOS window doesn't close
	cout << "\n\n";
	system("pause");
	return 0;
}

//Class Implementations

void Gun::print() {
	cout << "";
}

void Handgun::print() {
	cout << "\nManufacturer: " << getManufactuer() << "\n";
	cout << "Caliber: " << getCaliber() << "\n";
	cout << "Grips: " << getGrips() << "\n";
	cout << "Sigts: " << getSights() << "\n";
	cout << "Laser: " << boolalpha << getLaser() << "\n";
}

void Revolver::print() {
	cout << "Single Action: " << getSingleAction() << "\n";
	cout << "Number of Rounds: " << getNumberOfRounds() << "\n";
}

void Pistol::print() {
	cout << "Semi auto: " << boolalpha << getSemiAuto() << "\n";
}

string Revolver::getSingleAction() {
	if (r_singleAction) {
		return "Single Action";
	}
	else {
		return "Not Single Action";
	}
}

[wh1t3crayon]

A virtual declared function should remian virtual throughout inheritance. In your derived classes, try declaring print() as virtual just as you did in your base class.

[andywestken]

Once declared virtual in a base class, the function is automatically virtual in all derived classes. There is no need to redeclare the function as virtual in the derived class.

(But it doesn't hurt to do so. I tend to do so as it makes it clearer to me that the function is virtual. And sometimes I even comment it in the derived classes, so I know it was declared virtual in a parent class, e.g. /*virtual*/ void print(); )

Your output looks fine to me. As your array contains one of each gun, what else do you expect? What you could do with is a blank line between the print calls...

    for (int i = 0; i < 3; i++)
    {
        myGunCabinet[i] -> print();
        cout << "\n"; // blank line!
    }

... so your output looks like this?

Manufacturer: Winchester
Caliber: .38
Grips: side
Sigts: iron
Laser: true

Single Action: Single Action
Number of Rounds: 500

Semi auto: true

Andy

PS If you want to be careful with your virtual functions, and you're using a C++11 compliant compiler, you could mark the derived versions of the virtual functions with the "override" (or even "final") specifier.