C++中类的组合

 C++中类的组合

※组合的概念
×类中的成员是另一个类的对象。
×可以在已有的抽象的基础上实现更加复杂的抽象。
  
    通过对复杂对象进行分解、抽象，使我们能够将一个复杂对象
理解为简单对象的组合。
    分解得到复杂对象的部件对象，这些部件对象比它高层的复杂
对象更容易理解和实现。然后由这些部件对象来“装配”复杂对象。
(即：搭积木)

例子：
class Point
{
private:
    folat x,y;//点的坐标
public:
    Point(float h,float v);//构造函数
    float GetX(void);//取X坐标
    float GetY(void);//取Y坐标

};
//...函数的实现

class Distance//类声明
{
private:
    point p1,p2;
    double dist;
public:
    Distance(Point a,Point b);//包含Point类
    double GetDis(void){return dist;}

   
};
//...函数的实现

※类组合的构造函数设计

原则：不仅要对本类中的基本类型成员数据赋初值，也要对对象成
员初始化。
声明形式：
  类名::类名（对象成员所需的形参，本类成员的形参）：
对象1（参数），对象2（参数），……
{本类初始化}

Point(int xx=0,int yy=0){x=xx,y=yy;}

Distance::Distance(Point a,Point b,double p):p1(a),p2(b)
{ //有了对象成员Point a传给p1(a), Point b传给p2(b)，
  //double p传给p,price=p;
   double x=double(p1.GetX()-p2.GetX());
   double y=double(p1.GetY()-p2.GetY());
   dist=sqrt(x*x+y*y);
   price=p;
}

※类组合的构造函数调用
×构造函数调用的顺序：先调用内嵌对象的构造函数（按内嵌时
类的声明顺序，先声明者先构造）。然后调用本类的构造函数。
（析构函数的调用顺序相反）
×若调用缺省构造函数（即无形参），则内嵌对象的初始化也将调
用相应的缺省构造函数。

例子：
#include<iostream.h>
#include<math.h>
class Point
{
private:
   float x,y;
public:
   Point(float xx,float yy)
   {
       cout<<"point构造函数"<<endl;
   }
   Point(Point &p)
   {
       x=p.x;y=p.y;
       cout<<"pont 拷贝构造函数"<<endl;

   }
   float GetX(void){return x;}
   float GetY(void){return y;}
};

class Distance
{
private:
   Point p1,p2;
   double dist;
public:
   Distance(Point a,Point b);//构造函数
   double GetDis(void){return dist;}
};

Distance::Distance(Point a,Point b):p1(a),p2(b)
{ //有了对象成员Point a传给p1(a), Point b传给p2(b)，
  //double p传给p,price=p;
   double x=double(p1.GetX()-p2.GetX());
   double y=double(p1.GetY()-p2.GetY());
   dist=sqrt(x*x+y*y);
  
}

void main()
{
    Point myp(1,1),myp(4,5);
    Distance myd(myp1,myp2);
    cout<<"the distance is: ";
    cout<<myd.GetDis()<<endl;
}

 

执行顺序：
Point构造函数
Point构造函数
Point拷贝构造函数
Point拷贝构造函数
Point拷贝构造函数
Point拷贝构造函数
Distance构造函数

结果：
the distance is: 5