例如：

 
class ObjectB{};

 

 
class ObjectA{

 
public:

 
    ObjectB array[5];//对象数组作为类的成员

 
}

 

 
那样的话对象数组的初始化会变得很麻烦，

 
因为数组名不能作为左值，所以不可以指针传递的方式赋值。

 
而且不能通过参数列表（构造函数后面加一个冒号）的方式初始化，

 
所以只能让类ObjectA自动调用类ObjectB的无参构造函数.

 
---------------

 
 
 
 #include 
 <
 iostream.h
 >
 
 #include 
 "
 stdlib.h
 "
 
 
 class
    ObjectB
 {
 public:
     int a;
 public:
     ObjectB(int m=0)
     {
         a=m;
     }
 }
 ;
 
 class
    ObjectA
 { 
 public:
         ObjectB   Array[5]; 
 public: 
         ObjectA(int   *p)
         {
             Array[0]=ObjectB(p[0]);
             Array[1]=ObjectB(p[1]);
             Array[2]=ObjectB(p[2]);
         } 
 }
 ;
 
 
 int
  main()
 
 {
     int p[5]={0,2,2,3,4};
     ObjectA am=ObjectA(p);
     cout<<am.Array[1].a<<endl;
     return 0;
 }
 

 
---------------

 

 
我们可以使用替代方式：

 
class A{};

 

 
classB{

 
public:

 
    A*a;//A类型的指针作为类的成员

 
}

 
同样带来很大的问题，

 
（1）浅拷贝，深拷贝的问题，除非重载拷贝构造函数，类B才能实现深拷贝，因为成员中有指针，所以无法简单的用拷贝构造函数生成一个新对象，而用无参构造函数生成的新对象也会有问题，因为里面的指针一般都默认为NULL了。

 

 
重载拷贝构造函数的时候需要申请一定长度的内存，将拷贝对象的指针所指向的空间拷贝到新申请的空间，再进行操作。注意申请后要释放。
 一个拷贝构造函数的例子
 
 
 
 
 SparseMatrix::SparseMatrix(
 const
  SparseMatrix
 &
 s)
     
 {
       Rows=s.Rows;
    Cols=s.Cols;
    Count=s.Count;
    smArray=new Trituple[6];
 //此处还需要复制对象
     }
 

 

 
----------------------

 
补充知识：

 
------------------http://www.ksarea.com/articles/20070829_memory-partition-stack-heap-difference.html

 
 C/C++应该是大学里最先接触的编程语言，它们的重要性不言而喻。但是我始终抱着“数组名就是指针”的错误信条到现在，可能是因为大学老师错误的讲解使我一直保留着这种误解。指针是C/C++语言的特色，而数组名与指针有太多的相似，甚至很多时候，数组名可以作为指针使用，所以也难免在学习中将两者混淆。这里介绍下指针和数组名的区别:
 
 1.指针和数组名占据的内存空间大小不一样，如下程序1：
 
 char str[10];
 char *pstr=str;
 cout<<
 cout<<sizeof
 
 第一行输出结果是：10，第二行输出结果是：4
 
 从这里我们可以看出：数组名对应着（而不是指向）一块内存（数组所占的内存区域）或者说是指代数组这种数据结构，其地址与容量在生命期内保持不变，只有数组的内容可以改变。指针对应着一个占据4个字节（Win32）的内存区域，而指向这4个字节所存储的地址所对应的内存单元，它可以指向任意类型的内存块。因此，sizeof(str)值为数组占据的内存空间大小即10个字节，而sizeof(pstr)值为指针的值占据的内存空间大小即4个字节。
 
 2.数组名不是指针，但是在一定的情况下转换为指代数组的首地址的指针，而这个数组名转为的指针只能是指针常量。
 在以下两种情况下才能进行这种转换：
 a.在程序1第二行代码中，将数组名直接赋值给指针，此时数组名转换为指向数组的首单元的常量指针。
 b.直接将数组名作为指针形参的时候，数组名则转换为指向数组的首单元的常量指针进行传递，如下程序2：
 
 void fun(char str[])
 {
 cout<<
 str++;
 }
 void main()
 {
 …
 char str1[5];
 fun(str1);
 …
 }
 
 注意：数组名作为函数形参进行传递时，在子函数体内，它已经不再是一个指针常量，而是变成一个真正的指针，可以进行增减等操作，可以被修改。所以程序2中子程序第一条语句输出的sizeof(str)的值为4.
 
 既然数组名可以被看作指针常量，而常量是不能修改的，那么如下代码是不允许的：
 
 char str[10];
 str++;
 
 但如下代码则合法的：
 
 char str[10];
 char *pstr=str;
 pstr++;
 
 3.使用指针访问数组和使用数组名访问数组本质不同。
 例如：
 
 char str[7]=”ksarea”;
 char *pstr=str;
 cout<<<
 


 
其中
str[3]和pstr[3]返回的都是字符’r'，但是编译器产生的执行代码却不一样。对于str[3]，执行代码是从str开始，向后移动两个字节，然后取出其中的字符；而对于pstr[3]，执行代码是从pstr中取出地址，然后在其上加3，然后取出对应内存中的字符。
当然，如果pstr是指向int型的指针，那么pstr[3]的处理过程是从pstr中取出地址，然后在其上加上3*sizeof(int)，最后取出对应内存中的字符，其他的数据类型一次类推。

一、对象数组
 
对象数组就是一个数组，里面的每一个元素都是一个对象
 定义方法：类名 数组名称[number];
 类名 指针 = new 类名[number];
 
例如：
 Teacher teachers[10];
 Teacher *p = new Teacher[10];
 
二、对象成员
 
对象成员就是一个对象的数据成员是另一个对象
 
例如Line类的数据成员可以是一个Coordinate类
 
class Coordinate
{
public:
	Coordinate();
private:
	int m_iX;
	int m_iY;
};

class Line
{
public:
	Line();
private:
	Coordinate m_coorA;//对象成员
	Coordinate m_coorB;
}
 
ps：
 实例化过程中，会先实例化对象成员Coordinate,再实例化Line，
 销毁的时候，先销毁Line，再销毁Coordinate

》对象数组
 
 
       对象数组是指数组元素为对象的数组，该数组中的每一个元素都是同一个类的对象。
 
       定义格式：
 
                          <类名><数组名>[<大小>]....   例：date dates[5];
 
 
       使用对象数组成员的格式：
 
                          <数组名>[<下标>].<成员名>   例：dates[0].year
 
  
 
 
       注：数组元素的更新有两种方式：
 
                    #用一个已知的对象进行更新
 
                    #直接生成一个新的对象进行更新
 
       
 
 
       示 例：
 
             dates[3]=date(5,25,2002);  
 
 
             等价于
 
             date temp(5,25,2002);   //建立一个匿名对象temp
 
             dates[3]=temp;
 
              释放temp;
 
              这里隐含了三步操作：首先，以更新后的值作为参数生成一个匿名对象；其次，将匿名对象赋值给数组元素对象；最后，在赋值操作完成后，匿名对象的生存期结束，调用析构函数释放该匿名对象。
 
              注：析构函数的执行顺序与构造函数的执行顺序相反。
 

 
 
》成员对象
 
        类的数据成员可以是简单类型或自定义类型的变量，也可以是类类型的对象。因此，可以利用已定义的类来构成新的类，使得一些复杂的类可以由一些简单类组合而成。类的聚集描述的就是一个类使用其他类的对象作为成员的情况。
 
        当一个类的成员是另外一个类的对象时，该对象就称为成员对象。当类中出现了成员对象时，该类的构造函数要包含对成员对象的初始化，成员对象的初始化工作也是在成员初始化列表中完成的。
 
         初始化的一般格式：
 
               <类名>::<类名>(<总形参表>):<成员对象1>(<形参表1>),<成员对象2>(<形参表2>),...
 
               {
 
                            ......
 
 
               }
 
 
         建立一个类的对象时，要调用它的构造函数对类对象初始化，此时应先执行初始化列表对各个成员进行初始化，再执行当前类的构造函数体。如果类中包含有成员对象，注意要根据初始化的参数调用成员对象的构造函数对其进行初始化。析构函数的执行顺序与构造函数的执行顺序相反。
 
         在对成员对象初始化时，根据初始化列表的特点可知：类中有多个成员对象时，要按照定义成员对象的顺序建立各个子对象，即成员对象构造函数的执行顺序仅与成员对象在类中声明的顺序有关，而与成员初始化列表中给出的成员对象的顺序无关。如果在构造函数的成员初始化列表中没有给出对成员对象的初始化，则表示使用成员对象的默认构造函数。如果成员对象所在的类没有默认构造函数，将产生错误。 
 
 
         示  例：
 

#include<iostream>
using namespace std;
class counter
{
public:
	counter():val(0){cout<<"Default constructor of counter"<<endl; }
	counter(int x):val(x){cout<<"Constructor of counter:"<<val<<endl; }
	~counter(){cout<<"Destructor of counter:"<<val<<endl; }
private:
	int val;
};
class example
{
public:
	example():val(0){cout<<"Default constructor of example"<<endl; }
	example(int x):c2(x),val(x){cout<<"Constructor of example:"<<val<<endl; }
	~example(){cout<<"Destructor of example:"<<val<<endl; }
	void print()const{cout<<"value="<<val<<endl; }
private:
	counter c1,c2;
	int val;
};
int main(){
	example e1,e2(4);
	e2.print();

	system("pause");
	return 0;        
}
         程序运行结果：

 

 
由于软件原因析构函数无法截图：
 

Destructor of example:4
Destructor of counter:4
Destructor of counter:0
Destructor of example:0
Destructor of counter:0
Destructor of counter:0
 
         类example中存在counter类的成员对象从c1,c2.建立example类的对象时，要先对成员对象c1,c2以及成员val进行初始化。这些成员对象的初始化在类example的构造函数的初始化列表中进行，成员初始化工作完成后，在执行example的构造函数体。
 
         在建立example类的对象e1时,由于没有提供参数，因此应调用example类的默认构造函数。example类的默认构造函数的初始化列表为空，表示对全部三个数据成员进行默认初始化，其中调用了成员对象c1,c2的默认构造函数，因此输出Default constructor of counter；Default constructor of counter；Default constructor of example。在建立e2对象时，对成员对象c1的初始化也使用了默认构造函数。
 
         由于类example中同时存在两个成员对象，因此应该按照声明成员对象的顺序对这两个成员对象进行初始化，即应先对成员对象c1进行初始化，在对成员对象c2进行初始化。
 
         在主程序结束时，要调用两个对象e1,e2的析构函数。析构函数的执行顺序与构造函数的执行顺序相反，即先析构e2对象，在析构e1对象。e2对象中包含有成员对象，它必须负责成员对象c1,c2的析构，析构顺序也与建立e2对象时的顺序相反，即先析构e2对象，在析构成员对象c2，最后析构成员对象c1。e1的析构过程与此相同。
 

一、类对象数组

 
类的对象和C++其他数据类型一样，也可以为其建立数组，数组的表示方法和结构一样。

 

 
#include iostream.h

 

 
class Date

 
{

 
int mo,da,yr;

 
public:

 
Date(int m=0,int d=0, int y=0) { mo=m; da=d; yr=y;}

 
void display() const { cout<<mo<<' '<<da<<'="" '<<yr<<endl;="" }

  };

 

 int main()

 {

 Date dates[2];

 Date today(12,31,2003);

 dates[0]=today;

 dates[0].display();

 dates[1].display();

 

 return 0;

 }

 

 1.类对象数组和默认构造函数

 在前面已经说过，不带参数或者所有参数都有默认值的构造函数叫做默认构造函数。如果类中没有构造函数，编译器会自动提供一个什么都不做的公共默认构造函数 。如果类当中至少有一个构造函数，编译器就不会提供默认构造函数。

 如果类当中不含默认构造函数，则无法实例化其对象数组。因为实例花类对象数组的格式不允许用初始化值来匹配某个构造函数的参数表。

 上面的程序中，main()函数声明了一个长度为2的Date对象数组，还有一个包含初始化值的单个Date对象。接着把这个初始化的Date对象赋值给数组中第一个对象，然后显示两个数组元素中包含的日期。从输出中可以看到，第一个日期是有效日期，而第二个显示的都是0。

 当声明了某个类的对象数组时，编译器会为每个元素都调用默认构造函数。

 下面的程序去掉了构造函数的默认参数值，并且增加了一个默认构造函数。

 

 #include 

 

 class Date

 {

 int mo, da, yr;

 public:

 Date();

 Date(int m,int d,int y) { mo=m; da=d; yr=y;}

 void display() const { cout <<mo<<' '<<da<<'="" '<<yr<<endl;="" }

  };

 

 Date::Date()

 {

 cout <<date constructor="" running<<endl;

  mo=0; da=0; yr=0;

 }

 

 int main()

 {

 Date dates[2];

 Date today(12,31,2003);

 dates[0]=today;

 dates[0].display();

 dates[1].display();

 

 return 0;

 }

 运行程序，输出为：

 Date constructor running

 Date constructor running

 12/31/2003

 0/0/0

 

 从输出中可以看出，Date()这个默认构造函数被调用了两次。

 2.类对象数组和析构函数

 当类对象离开作用域时，编译器会为每个对象数组元素调用析构函数。

 

 #include iostream.h

 

 class Date

 {

 int mo,da,yr;

 public:

 Date(int m=0,int d=0,int y=0) { mo=m; da=d; yr=y;}

 ~Date() {cout<<date destructor="" running<<endl;}

  void display() const {cout<<mo<<' '<<da<<'="" '<<yr<<endl;="" }

  };

 

 int main()

 {

 Date dates[2];

 Date today(12,31,2003);

 dates[0]=today;

 dates[0].display();

 dates[1].display();

 

 return 0;

 }

 运行程序，输出为：

 12/31/2003

 0/0/0

 Date destructor running

 Date destructor running

 Date destructor running

 

 表明析构函数被调用了三次，也就是dates[0],dates[1],today这三个对象离开作用域时调用的。

 

 二、静态成员

 可以把类的成员声明为静态的。静态成员只能存在唯一的实例。所有的成员函数都可以访问这个静态成员。即使没有声明类的任何实例，静态成员也已经是存在的。不过类当中声明静态成员时并不能自动定义这个变量，必须在类定义之外来定义该成员。

 1.静态数据成员

 静态数据成员相当于一个全局变量，类的所有实例都可以使用它。成员函数能访问并且修改这个值。如果这个静态成员是公有的，那么类的作用域之内的所有代码(不论是在类的内部还是外部)都可以访问这个成员。下面的程序通过静态数据成员来记录链表首项和末项的地址。

 

 #include iostream.h

 #include string.h

 

 class ListEntry

 {

 public:

 static ListEntry* firstentry;

 private:

 static ListEntry* lastentry;

 char* listvalue;

 ListEntry* nextentry;

 public:

 ListEntry(char*);

 ~ListEntry() { delete [] listvalue;}

 ListEntry* NextEntry() const { return nextentry; };

 void display() const { cout<<listvalue<<endl; }

  };

 

 ListEntry* ListEntry::firstentry;

 ListEntry* ListEntry::lastentry;

 

 ListEntry::ListEntry(char* s)

 {

 if(firstentry==0) firstentry=this;

 if(lastentry!=0) lastentry->nextentry=this;

 lastentry=this;

 listvalue=new char[strlen(s)+1];

 strcpy(listvalue,s);

 nextentry=0;

 }

 

 int main()

 {

 while (1)

 {

 cout<<\nEnter a name ('end' when done): ;

 char name[25];

 cin>>name;

 if(strncmp(name,end,3)==0) break;

 new ListEntry(name);

 }

 ListEntry* next = ListEntry::firstentry;

 while (next != 0)

 {

 next->display();

 ListEntry* hold = next;

 next=next->NextEntry();

 delete hold;

 }

 return 0;

 }

 

 程序首先显示提示信息，输入一串姓名，以end作为结束标志。然后按照输入顺序来显示姓名。构造函数将表项加入链表，用new运算符来声明一个表项，但并没有把new运算符返回的地址赋值给某个指针，这是因为构造函数会把该表项的地址赋值给前一个表项的nextentry指针。

 这个程序和前面将的逆序输出的程序都不是最佳方法，最好的方法是使用类模板，这在后面再介绍。

 main()函数取得ListEntry::firstentry的值，开始遍历链表，因此必需把ListEntry::firstentry设置成公有数据成员，这不符合面向对象程序的约定，因为这里数据成员是公有的。

 2.静态成员函数

 成员函数也可以是静态的。如果一个静态成员函数不需要访问类的任何实例的成员，可以使用类名或者对象名来调用它。静态成员通常用在只需要访问静态数据成员的情况下。

 静态成员函数没有this指针，因为它不能访问非静态成员，所以它们不能把this指针指向任何东西。

 下面的程序中，ListEntry类中加入了一个静态成员函数FirstEntry()，它从数据成员firstentry获得链表第一项的地址，在这儿，firstentry已经声明为私有数据成员了。

 

 #include iostream.h

 #include string.h

 

 class ListEntry

 {

 static ListEntry* firstentry;

 static ListEntry* lastentry;

 char* listvalue;

 ListEntry* nextentry;

 public:

 ListEntry(char*);

 ~ListEntry() { delete [] listvalue;}

 static ListEntry* FirstEntry() { return firstentry; }

 ListEntry* NextEntry() const { return nextentry; };

 void display() const { cout<<listvalue<<endl; }

  };

 

 ListEntry* ListEntry::firstentry;

 ListEntry* ListEntry::lastentry;

 

 ListEntry::ListEntry(char* s)

 {

 if(firstentry==0) firstentry=this;

 if(lastentry!=0) lastentry->nextentry=this;

 lastentry=this;

 listvalue=new char[strlen(s)+1];

 strcpy(listvalue, s);

 nextentry = 0;

 }

 

 int main()

 {

 while (1)

 {

 cout<<\nEnter a name ('end' when done):;

 char name[25];

 cin >> name;

 if(strncmp(name,end,3)==0) break;

 new ListEntry(name);

 }

 ListEntry* next = ListEntry::FirstEntry();

 while (next != 0)

 {

 next->display();

 ListEntry* hold = next;

 next = next->NextEntry();

 delete hold;

 }

 return 0;

 }

 函数ListEntry::FirstEntry()是静态的，返回静态数据成员firstentry的值。

 3.公有静态成员

 如果一个静态成员象上面程序一样是公有的，那么在整个程序中都可以访问它。可以在任何地方调用公有景泰成员函数，而且不需要有类的实例存在。但公有静态成员函数不完全是全局的，它不仅仅存在于定义类的作用域内。在这个作用域里面，只要在函数名前加上类名和域解析运算符::就可以调用该函数。