au milieu des tests d'heritance de classe

d03/ex01/ClapTrap.cpp

@@ -6,12 +6,24 @@
 
 int	ClapTrap::_totalNumber = 0;
 
+/*
+ * assign values for default or secondary constructors
+ */
+
+void	ClapTrap::assignValues( ClapTrap & src ) {
+	src._class = "ClapTrap";
+	src._hit = 10;
+	src._energy = 10;
+	src._attack = 1;
+	src._number = getNumber();
+}
+
 /*
  * default/parametric constructor
  */
 
 ClapTrap::ClapTrap( void ) {
-
+	assignValues(*this);
 	std::cout << "claptrap default creation without name\n";
 	return;
 }
@@ -43,12 +55,13 @@ ClapTrap &	ClapTrap::operator=( ClapTrap const & rhs ) {
 
 	if ( this != &rhs )
 	{
-		this->_hit = rhs.getHit();
-		this->_energy = rhs.getEnergy();
-		this->_attack = rhs.getAttack();
-		this->_class = rhs.getClass();
-		this->_name = rhs.getName();
-		this->_number = rhs.getNumber();
+		ClapTrap::_increaseNumber();
+		_number = getNumber();
+		_class = "ClapTrap";
+		_hit = rhs.getHit();
+		_energy = rhs.getEnergy();
+		_attack = rhs.getAttack();
+		_name = rhs.getName();
 	}
 
 	std::cout << _class << " " << _name << " assigned\n";
@@ -57,19 +70,12 @@ ClapTrap &	ClapTrap::operator=( ClapTrap const & rhs ) {
 }
 
 /*
- * constructor
+ * parameters constructor
  */
 
 ClapTrap::ClapTrap( std::string name ) : _name(name) {
-
 	ClapTrap::_increaseNumber();
-
-	_class = "ClapTrap";
-	_hit = 10;
-	_energy = 10;
-	_attack = 1;
-	_number = getNumber();
-
+	assignValues(*this);
 	std::cout << _class << " " << _name << " named creation with number " << _number << "\n";
 	return;
 }

d03/ex01/ClapTrap.hpp

@@ -10,7 +10,7 @@ class ClapTrap {
 
 public:
 
-	ClapTrap( std::string name );					// default/parametric constructor
+	ClapTrap( std::string name );
 	ClapTrap( ClapTrap const & src );				// copy constructor
 	~ClapTrap( void );								// destructor
 
@@ -42,6 +42,7 @@ protected:
 
 private:
 
+	void		assignValues(ClapTrap & src);
 	static int	_totalNumber;
 
 };

d03/ex01/ScavTrap.cpp

@@ -11,6 +11,16 @@ void	ScavTrap::assignValues( ScavTrap & src ) {
 	src._attack = 20;
 }
 
+/*
+ * default constructor
+ */
+
+ScavTrap::ScavTrap() {
+	assignValues(*this);
+	std::cout << _class << " " << " default construction with number " << _number << "\n";
+	return;
+}
+
 /*
  * parameters constructor
  */
@@ -37,3 +47,34 @@ ScavTrap::~ScavTrap( void ) {
 void	ScavTrap::guardGate() {
 	std::cout << _class << " " << _name << " entered special mode Gate Keeper\n";
 }
+
+/*
+ * copy constructor
+ */
+
+ScavTrap::ScavTrap( ScavTrap const & src ) {
+	*this = src;
+	std::cout << _class << " " << _name << " copied\n";
+	return;
+}
+
+/*
+ * assignement operator
+ */
+
+ScavTrap &	ScavTrap::operator=( ScavTrap const & rhs ) {
+
+	if ( this != &rhs )
+	{
+		this->_hit = rhs.getHit();
+		this->_energy = rhs.getEnergy();
+		this->_attack = rhs.getAttack();
+		this->_class = rhs.getClass();
+		this->_name = rhs.getName();
+		this->_number = rhs.getNumber();
+	}
+
+	std::cout << _class << " " << _name << " assigned\n";
+	return *this;
+
+}

d03/ex01/ScavTrap.hpp

@@ -9,9 +9,13 @@ class ScavTrap : public ClapTrap {
 
 public:
 
-	~ScavTrap();
+	ScavTrap();										// default/parametric constructor
+	ScavTrap( ScavTrap const & src );				// copy constructor
+	~ScavTrap();									// destructor
 	ScavTrap(std::string name);
 
+	ScavTrap &	operator=( ScavTrap const & rhs );	// assignement operator
+
 	void	guardGate();
 
 private:

d03/ex01/main.cpp

@@ -49,17 +49,28 @@ int	main() {
 	ClapTrap robot1("robot1");
 	ScavTrap robot2("robot2");
 	ScavTrap robot3("robot3");
+	ClapTrap robot4("robot4");
 
-	ScavTrap robotmp1("robot4");
-	ClapTrap robot4(robotmp1);  // PBM : it says it's a ScavTrap but it has no guardGate()...
-	//robot4.guardGate();
+std::cout << "assignement 1:\n";
+	ScavTrap robotmp1("robot5");
+	robotmp1.guardGate();
+	ClapTrap robot6(robotmp1);  // PBM : it says it's a ScavTrap but it has no guardGate()...
+//	robot6.guardGate();
 
-	ScavTrap robotmp2("robot5");
-	ScavTrap robot5(robotmp2);
-	robot5.guardGate();
+std::cout << "assignement 2:\n";
+	ScavTrap robotmp2("robot7");
+	ScavTrap robot8(robotmp2);
+	robot8.guardGate();
 
-//	ClapTrap robotmp3("robot6"); // PBM : assignation doesn't work...
-//	ScavTrap robot6(robotmp3);
+std::cout << "assignement 3:\n";
+	ClapTrap robotmp3("robot9"); // PBM : assignation doesn't work...
+//	ScavTrap robot10(robotmp3);
+//	robot10.guardGate();
+
+std::cout << "assignement 4:\n";
+	ClapTrap robotmp4("robot11");
+	ClapTrap robot12(robotmp4);
+//	robot12.guardGate();
 
 	goAttack(robot1, robot2);
 	goAttack(robot2, robot1);

d03/test_inheritance/Base.cpp

@@ -0,0 +1,41 @@
+#include "Base.hpp"
+
+/*
+ * default/parametric constructor
+ */
+
+Base::Base( void ) {
+	std::cout << "base default constructor\n";
+	return;
+}
+
+/*
+ * destructor
+ */
+
+Base::~Base( void ) {
+	return;
+}
+
+/*
+ * copy constructor
+ */
+
+Base::Base( Base const & src ) {
+	std::cout << "base copy constructor\n";
+	*this = src;
+	return;
+}
+
+/*
+ * assignement operator
+ */
+
+Base &	Base::operator=( Base const & rhs ) {
+	std::cout << "base assignations operator\n";
+	return *this;
+}
+
+Base::Base(int i) {
+	std::cout << "base parameters constructor\n";
+}

d03/test_inheritance/Base.hpp

@@ -0,0 +1,19 @@
+#ifndef BASE_HPP
+# define BASE_HPP
+
+#include <iostream>
+
+class Base {
+
+public:
+
+	Base( void );							// default/parametric constructor
+	Base( Base const & src );				// copy constructor
+	~Base( void );							// destructor
+
+	Base &	operator=( Base const & rhs );	// assignement operator
+
+	Base(int i);
+};
+
+#endif

d03/test_inheritance/main.cpp

@@ -0,0 +1,39 @@
+#include <iostream>
+
+class Base {
+public:
+	Base() {
+		std::cout << "base default constructor\n";}
+	Base(int i) {
+		std::cout << "base parameters constructor\n";}
+	Base(Base const & src) {
+		std::cout << "base copy constructor\n"; *this = src;}
+	Base & operator=(Base const & rhs) {
+		std::cout << "base assignation operator\n"; return *this;}
+	~Base() {
+		std::cout << "base default destructor\n";}
+};
+
+class Derived : public Base {
+public:
+	Derived() {
+		std::cout << "derived default constructor\n";}
+	Derived(int i) {
+		std::cout << "derived parameters constructor\n";}
+	Derived(Derived const & src) {
+		std::cout << "derived copy constructor\n"; *this = src;}
+	Derived & operator=(Derived const & rhs) {
+		std::cout << "derived assignation operator\n"; return *this;}
+	~Derived() {
+		std::cout << "derived default destructor\n";}
+};
+
+int	main () {
+
+	Base	base1(1); std::cout << "\n";
+	Derived	derived1(1); std::cout << "\n";
+	Base	base2(derived1); std::cout << "\n";
+	Derived derived2(base1);
+
+	return 0;
+}