一个类的对象作为另一个类的数据成员。
  
  
  
      一个类中的数据成员除了可以是int, char, float等这些基本的数据类型外，还可以是某一个类的一个对象。用子对象创建新类。
  
  
  
      在C++中，当把一个类的对象作为新类的数据员时，则新类的定义格式可表示为：
  
  
  
 class X
  
  
  
 { 类名1  成员名1;
  
  
  
   类名2  成员名2;
  
  
  
   ……
  
  
  
   类名n  成员名n;
  
  
  
   ……//其它成员
  
  
  
 };
  
  
  
 （3）如果一个类A的对象作为另一个类B的数据成员，则在类B的对象创建过程中，调用其构造函数的过程中，数据成员（类A的对象）会自动调用类A的构造函数。
  
  
  
 但应注意：如果类A的构造函数为有参函数时，则在程序中必须在类B的构造函数的括号后面加一“：”和被调用的类A的构造函数，且调用类A的构造函数时的实参值必须来自类B的形参表中的形参。这种方法称为初始化表的方式调用构造函数。如：以上面定义的类X为例，在对类X的对象进行初始化时，必须首先初始化其中的子对象，即必须首先调用这些子对象的构造函数。因此，类X的构造函数的定义格式应为：
  
  
  
 X：：X（参数表0）：成员1（参数表1），成员2（参数表2），…，成员n(参数表n)
  
  
  
 { ……}
  
  
  
 其中，参数表1提供初始化成员1所需的参数，参数表2提供初始化成员2所需的参数，依此类推。并且这几个参数表的中的参数均来自参数表0，另外，初始化X的非对象成员所需的参数，也由参数表0提供。
  
  
  
 在构造新类的对象过程中，系统首先调用其子对象的构造函数，初始化子对象；然后才执行类X自己的构造函数，初始化类中的非对象成员。对于同一类中的不同子对象，系统按照它们在类中的说明顺序调用相应的构造函数进行初始化，而不是按照初始化表的顺序。
  

  

  

  

  

  

  

  

  

  

  

  

  
 以下定义了三个Student、Teacher和Tourpair，其中Student类的对象和Teacher类的对象作为了Tourpair的数据成员，观察对象的构造过程和构造函数被执行的顺序。
  
  
  
 
 
 
include <iostream.h>
 
 
 class Student
  
 { public: 


    Student()
  
     { cout<<”construct student.\n”;
  
        semeshours=100;
  
        gpa=3.5;   }   


 protected:
  
      int semeshours;
  
      float gpa;
  
 };
  
 class Teacher
  
 { public:
  
      Teacher()
  
    { cout<<”construct Teacher.\n”; 


     }
  
  };
  
 class Tourpair
  
 {public:
  
      Tourpair()
  
      {cout<<”construct tourpair.\n”;
  
       nomeeting=0;  }
  
   protected:
  
       Student student;
  
       Teacher teacher;
  
       int nomeeting;
  
  };
  
 void main()
  
 {Tourpair tp;
  
 cout<<”back in main.\n”; }
  
 其执行结果是：
  
    construct student.
  
    construct teacher.
  
    construct tourpair.
  
    back in main.
  
       由此可见：主函数main()运行开始时，遇到要创建Tourpair类的对象，于是调用其构造函数Tourpair（），该构造启动时，首先分配对象空间（包含一个Student对
  
 象、一个Teacher对象和一个int型数据）,然后根据其在类中声明的对象成员的次序依次调用其构造函数。即先调用Student()构造函数，后调用Teacher()构造函数，最后才执行它自己的构造函数的函数体。
  
      由于上例中Tourpair类的数据成员student和teacher的构造函数都是无参函数，所以系统在构造student和teacher对象时会自动调用各自的构造函数Student()和Teacher()，而不需要用初始化表的方式去调用。
  
 【例3-7】试分析以下程序的执行结果:
  
 
include <iostream.h>
 
 
 
include <string.h>
 
 
 class Student
  
 { public:
  
    Student(char *pName=”No name”)
  
       { cout<<”构造新同学：”<<pName<<endl;
  
          strncpy(name,pName,sizeof(name)); char * strncpy(char *dest, char *src, size_t n); 将字符串src中最多n个字符复制到字符数组dest中(它并不像strcpy一样遇到NULL才停止复制，而是等凑够n个字符才开始复制），返回指向dest的指针。　             C语言中判断数据类型长度符
  
          name[sizeof(name)-1]=’\0’;  


         }
  
  Student(Student &s)
  
       { cout<<”构造copy of “<<s.name<<endl;
  
          strcpy(name, ” copy of “);  extern char *strcpy(char *dest,char *src);    把src所指由NULL结束的字符串复制到dest所指的数组中
  
          strcat(name,s.name);    extern char *strcat(char *dest,char *src);          把src所指字符串添加到dest结尾处(覆盖dest结尾处的’\0’)并添加’\0’。
  
          }
  
 ~Student()
  
  { cout<<”析构 “<<name<<endl; }
  
     protected:
  
     char name[40];  };
  
 class Tutor
  
 { public: 


        Tutor(Student &s):student(s)//此为初始化表，调用
  
                                                      //Student的拷贝构造函数
  
        { cout<<”构造指导教师 \n”;  }
  
    protected:
  
         Student student;
  
  };
  
 void main()
  
 {  Student st1;   //此处调用Student的构造函数Student(char  


            *pName=”No name”)
  
    Student st2(“zhang”); //同上
  
    Tutor tutor(st2); //此处调用Tutor的构造函数Tutor(Student &s)
  
    //在构造tutor对象的过程中，用初始化表调用
  
    //Student类的拷贝构造函数Student(Student &s)
  
 }
  
 执行结果如下：
  
 构造新同学：No name
  
 构造新同学：zhang
  
 构造copy of zhang
  
 构造指导教师
  
 析构  copy of zhang
  
 析构 zhang
  
 析构 No name
  
 3.2.7 利用初始化表对常量数据成员或引用成员提供初值
  
      如前所述，构造函数可对对象的数据成员进行初始化，但若数据成员为常量成员或引用成员时，就有所不同，如：
  
 class Sillyclass
  
 { public :
  
 Sillyclass()   // 此构造函数对成员ten和refi的初始化错误。
  
     { ten=10;
  
        refi=i; }
  
 protected:
  
     const int ten;   //常量数据成员ten
  
     int &refi;         //引用refi
  
 };
  
 说明：
  
 1. 造成以上错误的原因是在Sillyclass类的构造函数进入之后（开始执行其函数体时），对象结构已经建立，数据成员ten和refi已存在，而其数据成员ten为const，而refi为引用，所以在构造函数体内不能再对其指派新的值。
  
 2. 解决以上问题的方法是利用初始化表：在构造函数的括号后面加一“：”和初始化表，初始化表的格式是：
  
 数据成员名（值），如果有多个时，需要用逗号隔开。
  
 【例3-8】 类employee中包括私有数据成员x, 和2个公有函数成员example、show。程序中使用初始化表是x(215)。
  
 
include <windows.h>
 
 
 
include <iostream.h>
 
 
 // 定义类 employee
  
 class  employee
  
 {private:
  
      const int x;
  
   public:
  
      employee ();
  
      void show(); 


  };
  
 // employee的类外定义
  
 employee :: employee () : x (215)   // 初始化表
  
 {                   }
  
 // show()的定义。
  
 void employee :: show()
  
 {  cout << “\n    x的值是：”<< x << endl; }
  
 // 主函数
  
 void main()
  
 {   //生成对象并为x赋予初始值
  
    employee obj;
  
      //调用show显示x的值
  
    obj.show();
  
 } 
 
 

理解数据结构与算法时，觉得大多数的书上讲的定义特别抽象，

数据、数据元素、数据项、数据对象这四个概念特别难懂
本人理解如下：
假设有两张表，A表为人员表，B表为课程表，这两张表就是数据


、

而单独的一张表就称为数据对象，即人员表是一个数据对象，课程表也是一个数据对象
而每张表中的每一行就称为数据元素
而姓名，性别，身高，课程代号，课程名就称为数据项

在慕课网学习类的封装 
 看着视频跟着老师敲代码感觉很简单 
 关掉视频自己敲 
 敲到一半发现敲不动； 
 然后又反复的看了几遍视频 
 最后知道了自己不会的原因 
  
 这是要求 
 其实老师是 
 实例化了两个坐标类的对象 
 然后放到Line类里作为 private 成员变量了
 
———————————————————————— 
 下面是我自己敲的代码 
 总共有5个文件 
 首先是包含main函数的cpp文件
 
#include "stdafx.h"
#include<iostream>
#include<cstdlib>
#include"Line.h"
using namespace std;


int main()
{
     Line *p = new Line;
     delete p;

    return 0;
}
 
其次是Line.h文件
 
#pragma once
#include"stdafx.h"
#include"dian.h"

class Line
{
public:
    Line();
    ~Line();

    void setA(int x, int y);
    void setB(int x, int y);

    void printInfo();


private:
    dian A;      //类A的对象可以成为类B的数据成员
    dian B;
};
 
然后是line.cpp文件
 
#include"stdafx.h"
#include<iostream>
#include"Line.h"
using namespace std;

Line::Line()
{
    cout << "Line的构造函数被执行了" << endl;
}
Line::~Line()
{
    cout << "Line的析构函数被执行了" << endl;
}

void Line::setA(int x, int y)
{
    A.setX(x);
    A.setY(y);
}
void Line::setB(int x, int y)
{
    B.setX(x);
    B.setY(y);

}

void Line::printInfo()
{
    cout << "点A的坐标是：" << "(" <<A.getX() << "," << A.getY() << ")" << endl;
    cout << "点B的坐标是：" << "(" << B.getX() << "," << B.getY() << ")" << endl;
}
 
dian.h文件
 
#pragma once
#include"stdafx.h"

class dian
{
public:
    dian();
    ~dian();

    void setX( int x);
    void setY( int y);

    int getX();
    int getY();


private:
    int m_X;      //表示任意一个点的X坐标
    int m_Y;
};

 
dian.cpp文件
 
#include"stdafx.h"
#include<iostream>
#include"dian.h"
using namespace std;

dian::dian() 
{
    cout << "点的构造函数被执行了" << endl; 
}
dian::~dian()
{
    cout << "点的析构函数被执行了" << endl;
}
    void dian :: setX(int x)
    {
        m_X = x;
    }
    void dian::setY(int y)
    {
        m_Y = y;
    }

    int dian::getX()
    {
        return m_X;
    }
    int dian::getY()
    {
        return m_Y;
    }


 
**
 
实例化对象A时 ，如果对象A有对象成员B，那么先执行对象B的构造函数，在执行A的构造函数
 
**

在很多领域中，一个对象可以由多hen个属性来描述，而其中某些属性本身又是另一个对象，也有自身的内部结构。例如，计算机辅助设计（CAD）的图形数据，多媒体的应用的图形、声音和文档等。
所谓面向对象数据模型指属性和操作属性的方法封装在称为对象类的结构中的模型。可以通过将一个对象类嵌套或封装在另一个类里来表示类间的关联，新的对象类可以从更一般化的对象类中导出，如：


以下是描述面向对象数据模型的几个概念。
1对象 对象是对一组信息及其操作的描述。现实世界中实体的模型化，和记录的概念相似，但更加复杂。
一个对象对应着E-R模型中的一个实体，面向对象类型的基础将一个对象的相关数据和代码封装为一个单元，其内容对外界是不可见的。
深圳IT外包
2 类（对象类）
类是类似对象的集合（相似的对象组成一个类）。面向对象的数据模型中类的概念对应于E-R模型中实体集概念。
3类层次
一个面向对象数据库模型通常需要很多的类，然而，有些类是相似的。为了表示类之间的相似性，我们把类放入一个特殊化层次（ISA）中。
一个系统中，所有的类和子类组成一个树形的类层次。类层次的概念实际上类似于E-R模型中特殊化层次的概念。在类层次中，一个类继承其直接或间接祖先的所有属性和方法。所谓继承性是指允许不同类的对象共享它们公共部分的结构和特征。继承性可以用超类或子类的层次联系实现。
可用ISA指出一个类是另一个类的特殊化，类的特殊化称为子类（Subclass）.例如，银行系统中，employee是person的一个子类，是teller的超类（Superclass）,person是employee的超类。
4对象标识
创建对象时，系统为每一个对象赋予一个唯一的标识。这个标识称为对象标识。标识的形式包含以下几种。
（1）值（value）:用于标识的一个数据值。这种形式的标识常在关系数据库系统中使用。例如，一个元组的主码标识了这个元组。
（2）名称（name）:用于标识一个用户提供的名称。这种形式的标识常用于文件系统中的文件。不管文件的内容是什么，用户会给每个文件赋予一个名称来唯一标识这个文件。
（3）内置（Built-in）:数据模型或程序设计语言中的一种标识方法，它不需要用户提供的标识符。这种形式标识常在面向对象系统中使用，对象创建时系统自动赋予每个对象标识符。
5对象包含
对象之间的引用可以用于对现实世界中的不同概念进行模拟，对象包含是其中之一。下图是自行车设计数据库的包含层次，每辆自行车的设计包括车轮、车架、车闸和齿轮。车轮又包括轮框、一套辐条和l轮胎。该设计的每个构建可以建模为一个对象，同时构建间的包含可以建模为对象间的包含。




深圳蓝快IDC
包含其他对象的对象称为复杂对象（复合对象），这种情况下出现对象间包含层次。
在面向对象系统中，包含是一个重要概念，因为它允许不同的用户用不同的粒度来观察数据。一个自行车设计师只专注于自行车的实例，而对于一个市场职员来说，所关心的只是自行车价格。