C++编程思想--继承与组合

继承与组合
1、组合：新类中创建已存在类的对象，由此类中会包含已存在类对象，此种方式为组合。

在构造函数的调用的过程中要注意的是首先会调用基类的构造函数，然后调用子对象的构造函数，子对象构造函数的调用顺序是根据其定义的顺序而定的。为什么在构造函数中初始化子对象以及基类对象的对象你哦？这是C++的一个强化机制，确保在构造当前对象的时候就已经调用了基类的构造函数。

2、名字隐藏：任何时候重新定义了基类中的一个重载函数，在新类之中所有其他的版本则被自动地隐藏。这种方式与普通的重载不一样，只要返回类型的不同也会隐藏基类的函数。

/2013-8-1
#include "stdafx.h"
#include <iostream>
#include <string>
using namespace std;

class Base1
{
public:
int f (int a)const
{
return 1;
}
};

class Base
{
public:
virtual int f(int a) const
{
cout<<"Base::f()"<<endl;
return 1;
}
Base(){}

Base(const Base&base){}
};

class Drived1:public Base
{
public:
Drived1(){}
int f(int a,int b=2)const//用户自定义创建函数之后与基类的虚函数只是一个重载的函数，
{
return 2;
}
Drived1(const Drived1& d1){}

//void f(int a)const{}//定义的为非重载的形式，在为非虚基类中会发生重写，
};

void f(Base &base)//不是用引用会直接调用Base的拷贝构造函数。于是调用的还是基类的f。
{
cout<<&base<<endl;
base.f(2);//当用户对基类函数进行重载调用的依旧是基类的函数
}

int main()
{
string s("hello");
Base base;
cout<<"虚基类的大小为："<<sizeof(base)<<endl;

Base1 base1;
cout<<"基类的大小为:"<<sizeof(base1)<<endl;

Drived1 d1;
int x=d1.f(5);
cout<<&d1<<endl;
f(d1);//作为基类并不知道在派生类中已经修改了的

x=d1.f(6);//在传递参数与f之后尽管Base接受Derived1的引用，但并不会改变原来的类型。
}

3、非自动继承的函数：operator=类似于构造函数的功能，因此是不能够被继承的。但是在继承过程中，若没有显示的创建，编译器会创建默认的构造函数和拷贝构造函数。

//modify by tj 2013-7-30
#include "stdafx.h"
#include <iostream>
using namespace std;

class GameBoard
{

void f(int){}
void f(char);

/*int main()
{
f();
}*/
int a;
public:
GameBoard()
{
cout<<"GameBoard()"<<endl;
}
GameBoard(const GameBoard& gameBoard)
{
a=gameBoard.a;
cout<<"GameBoard(const GameBoar&)"<<endl;
}
GameBoard& operator = (const GameBoard&)
{
cout<<"GameBoard::operator = ()"<<endl;
return *this;
}
~GameBoard()
{
cout<<"~GameBoard()"<<endl;
}
};

class Game
{
GameBoard mGb;
public:
Game()
{
cout<<"Game()"<<endl;
}
//Game(const Game& game)/*:mGb(game.mGb)*///会调用非拷贝的构造函数
//{
//	cout<<"Game(const Game&)"<<endl;
//}
Game& operator = (const Game& g)
{
mGb=g.mGb;
cout<<"Game::operator=()"<<endl;
return *this;
}
Game(int)
{
cout<<"Game(int)"<<endl;
}
class Other {};
operator Other() const
{
cout<<"Game::operator Other()"<<endl;
return Other();
}
~Game()
{
cout<<"~Game()"<<endl;
}
};

class Chess:public Game{};

void f(Game::Other){};

class Checkers : public Game
{
public:
Checkers()
{
cout<<"Checkers()"<<endl;
}
//Checkers(const Checkers& c)/*:Game(c)*///若没有显示的定义拷贝构造函数将会调用的是构造函数
//{
//	cout<<"Checkers(const Checkers& c)"<<endl;
//}
Checkers& operator = (const Checkers& c)
{
Game::operator =(c);
cout<<"Checkers::operator = ()"<<endl;
return* this;
}
};

int test3()
{
Chess d1;
Chess d2(d1);
d1=d2;
f(d1);
//Game::Other go;
//d1=go;
Checkers c1,c2(c1);//若没有显示的调用还会调用默认的构造函数
c1=c2;
return 1;
}

小结:1、若没有给派生类显示的定义拷贝构造函数调用的将会是构造函数。若构造函数没有显示的定义则会调用默认的构造函数。因为这两个函数都不会自动的继承。

4、如何选择组合与继承

利用组合的时候，新类不希望已存在的类作为其接口。新类应该作为嵌入类的私有对象。仅提供一些函数。若希望已存在的类中的每一个变量与成员都囊括，则应该使用的是继承。

5、向上类型转换

由继承类向基类进行类型转换。但是这个类接口可能会失去一些成员函数。

派生类中拷贝构造函数的调用顺序：基类的拷贝构造函数、各对象的拷贝构造函数。派生类是由基类派生的，在调用构造函数的时候会首先调用的是基类的构造函数，所以当使用向上类型转换的时候，派生类的引用就相当于基类的引用。但是随之的是会丢失一部分的函数，因为在基类中并不存在。