C++:对象数组

对象数组 

对象数组：每一个数组元素都是对象的数组，也就是说，若一个类有若干个对象，我们把这
一系列的对象用一个数组来存放。对应数组元素是对象，不仅具有的数据成员，而且还有函数
成员。

 @定义一个一维数组的格式如： 类名 数组名[下标表达式];

 @使用对象数组时只能访问单个数组元素，其一般格式如： 数组名[下标].成员名 

 举例:Complex com[2]={11，22};//定义类Complex的实参数1个的对象数组com,含有n个对象数组元素
 举例:Complex com[2]={
                        Complex(11,22)，
                        Complex(33,44)，
                     };  //定义的实参个数为2个的对象数组com，含有n个对象数组元素  

/*

//例3.14 用只有一个参数的构造函数给对象数组赋值
#include<iostream>
using namespace std;
class exam{
 public:
       exam(int n)  //只有一个参数的构造函数
       {
         x = n;
       }
       int getx()
       {
         return x;
       }
 private:
       int x;
};
int main()
{
exam obj[3]={11,22,33};    //用只有一个参数的构造函数给对象数组进行赋值，三个对象
for(int i=0;i<=2;i++)
 cout<<"第"<<i+1<<"个对象是: "<<"obj["<<i<<"]"<<" = "<<obj[i].getx()<<endl;
return 0;
}
         运行结果:  第1个对象是: obj[0] = 11
                   第2个对象是: obj[1] = 22
                   第3个对象是: obj[2] = 33 

// 例3.15 用不带参数和带一个参数的构造函数给对象数组赋值
#include<iostream>
using namespace std;
class exam{
 public:
       exam()       //不带参数的构造函数
       {
         x = 88;
       }
       exam(int n)  //只有一个参数的构造函数
       {
         x = n;
       }
       int getx()
       {
         return x;
       }
 private:
       int x;
};
int main()
{
exam obj1[3]={11,22,33}; //三个对象均用只有一个参数的构造函数给对象数组进行赋值
exam obj2[3]={44}; //第一对象调用有一个参数的构造函数赋值,后两个对象调用无参的构造函数赋默认值
for(int i=0;i<=2;i++)
 cout<<"第"<<i+1<<"个对象是: "<<"obj1["<<i<<"]"<<" = "<<obj1[i].getx()<<endl;
 cout<<endl;
for(int i=0;i<=2;i++)
 cout<<"第"<<i+1<<"个对象是: "<<"obj2["<<i<<"]"<<" = "<<obj2[i].getx()<<endl;
return 0;
}
                       运行结果：  第1个对象是: obj1[0] = 11
                                 第2个对象是: obj1[1] = 22
                                 第3个对象是: obj1[2] = 33

                                 第1个对象是: obj2[0] = 44
                                 第2个对象是: obj2[1] = 88
                                 第3个对象是: obj2[2] = 88
*/

//例3.16  用带有多个参数的构造函数给对象数组赋值。

#include<iostream>
#include<cmath>
using namespace std;
class Complex{
 public:
       Complex(double r=0.0,double i=0.0):real(r),imag(i)
       {}//定义带有默认参数的构造函数，用成员初始化列表对数据成员进行初始化
       ~Complex()
       {
         cout<<"Destructor called."<<endl;
       }
       double abscomplex()
       {
         double t;
         t = real*real+imag*imag;
         return sqrt(t);
       }
 private:
        double real;
        double imag;
};
int main()
{
 Complex A[]={
                 Complex(1.1,2.2),
                 Complex(3.3,4.4),
                 Complex(5.5,6.6),
              };
 for(int i=; i<=; i++)
  cout<<"复数对象A["<<i<<"]的绝对值是: "<<A[i].abscomplex()<<endl;
 return ;
}
        运行结果：复数对象A[]的绝对值是: 2.45967
                  复数对象A[]的绝对值是: 5.5
                  复数对象A[]的绝对值是: 8.59127
                  Destructor called.
                  Destructor called.
                  Destructor called.