c++ 基础： 类模版\函数模版\命名空间\组合与继承

类模版

类似于java中的泛型

1. 定义：

temlpate<typename T>
class complex{
public:
	complex(T r=0,T i=0):re(r),im(i){}
	complex& operator += (const complex& );	
	T real() const {return re;}
	T imag() const {return im;}
private:
	T re,im;
	friend complex& __doapl(complex*,const complex&);
}

2. 使用

complex<double> c1(2.0,1.3);
complex<int> c2(2,7);

函数模版

1. 定义：

//比较大小
template<class T>
const T& min(const T&a,const T& b){
	return b<a?b:a;
}

2. 使用

class stone{
public:
	stone(int w,int h,int we);__w(w),__h(h),__weight(we){}
	bool operator < (const stone& rhs) const {
		return __weight < rhs.__weight;
	}
private:
	int __w,__h,__weight;	
}


stone r1(2,3),r2(3,5),r3;
r3 = min(r1,r2);

命名空间

1. 定义： 将定义的代码包含在指定名称的namespace中，构成。

namespace 命名{

	//自定义代码
}

2. 使用

using namespace 命名; //使用整个命名空间
using 命名:函数或者其他名字 //只使用要使用的函数或者其他

继承、组合：类之间的关系

组合

1. 组合，复合 has a ；有一个、有N个指定类型的成员数据

适配器： A 有一个成员数据B，使用B带有的成员数据和方法实现A中所有的成员函数和方法。即A是B的适配器。例如下例中queue适配了c

//queue中有一个dueque<int> 类型的成员数据c；
class queue{

private:
	dueque<int> c; 
	stone* p;
	
public:
	bool empty() const {return c.empty();}	
	size_type size() const {return c.size();}
}

2. 组合占用内存大小：
   分别计算每一个成员占用内存的大小并求和即得到组合占用的内存大小。如上例中c占用16个字节，那么queue占用内存大小为： 16 + 4 = 20 字节；

3. 组合构造和析构函数的调用顺序：

   1. 构造： 由内向外构造，即先构造成员（默认使用默认的构造函数，如果要使用指定的构造函数，需要自己实现），后构造本身。先构造c，后构造queue
   2. 析构： 由外向内析构，即先析构本身，后析构成员。先析构queue，后析构c

4. 组合和委托：

   1. 组合使用has a 即，成员和本身处于同一个生命周期，成员类似于by value 值
   2. 委托使用指针，即成员和本身个字拥有自己的生命周期，成员类似于by reference 引用，如果将上例中stone* p 属于委托，c则属于组合。

继承

1. 定义： 子类：父类{实现}

struct List_node{
	int a;
	int b;
}


struct List_children： List_node{
	int c;
}

2. 继承构造和析构顺序：
   1. 构造： 由内向外进行构造。即先调用基类构造
   2. 析构： 由外向内进行析构。即先调用子类析构。