multiple inheritance 一个简单的例子

multiple inheritance 多重继承，是个很高级的技术。就是一个子类有多个父类。

但是这个技术的使用会有些问题：

1。 父类中有相同名字的成员函数或者成员数据。

 

下面这个例子说了如何解决这个问题

1. 使用命名空间来指明是使用哪个成员

 

 

/*
 * =====================================================================================
 *
 *       Filename:  multi_inherit1.cpp
 *
 *    Description: 
 *
 *        Version:  1.0
 *        Created:  09/17/2010 02:00:45 PM
 *       Revision:  none
 *       Compiler:  gcc
 *
 *         Author:  YOUR NAME (),
 *        Company: 
 *
 * =====================================================================================
 */
// class Base1 definition
#include <iostream>
using namespace std;


class Base1
{
public:
   Base1( int parameterValue )
   {
      value = parameterValue;
   } // end Base1 constructor

   int getData() const
   {
      return value;
   } // end function getData
protected: // accessible to derived classes
   int value; // inherited by derived class
}; // end class Base1

// class Base2 definition
class Base2
{
public:
   Base2( char characterData )
   {
      letter = characterData;
   } // end Base2 constructor

   char getData() const
   {
      return letter;
   } // end function getData
protected: // accessible to derived classes
   char letter; // inherited by derived class
}; // end class Base2

// class Derived definition
class Derived : public Base1, public Base2
{
   friend ostream &operator<<( ostream &, const Derived & );
public:
   Derived( int, char, double );
   double getReal() const;
private:
   double real; // derived class's private data
}; // end class Derived

// constructor for Derived calls constructors for
// class Base1 and class Base2.
// use member initializers to call base-class constructors
Derived::Derived( int integer, char character, double double1 )
   : Base1( integer ), Base2( character ), real( double1 ) { }

// return real
double Derived::getReal() const
{
   return real;
} // end function getReal

// display all data members of Derived
ostream &operator<<( ostream &output, const Derived &derived )
{
   output << "    Integer: " << derived.value << "/n  Character: "
        << derived.letter << "/nReal number: " << derived.real;
   return output; // enables cascaded calls
} // end operator<<

int main()
{
   Base1 base1( 10 ), *base1Ptr = 0; // create Base1 object
   Base2 base2( 'Z' ), *base2Ptr = 0; // create Base2 object
   Derived derived( 7, 'A', 3.5 ); // create Derived object

   // print data members of base-class objects
   cout << "Object base1 contains integer " << base1.getData()
      << "/nObject base2 contains character " << base2.getData()
      << "/nObject derived contains:/n" << derived << "/n/n";

   // print data members of derived-class object
   // scope resolution operator resolves getData ambiguity
   cout << "Data members of Derived can be accessed individually:"
      << "/n    Integer: " << derived.Base1::getData()
      << "/n  Character: " << derived.Base2::getData()
      << "/nReal number: " << derived.getReal() << "/n/n";

   cout << "Derived can be treated as an object of either base class:/n";

   // treat Derived as a Base1 object
   base1Ptr = &derived;
   cout << "base1Ptr->getData() yields " << base1Ptr->getData() << '/n';

   // treat Derived as a Base2 object
   base2Ptr = &derived;
   cout << "base2Ptr->getData() yields " << base2Ptr->getData() << endl;
   return 0;
} // end main