C++ 对象数组与对象指针

技术专帖

对象数组与对象指针

对象数组

       所谓对象数组是指每一数组元素都是对象的数组，也就是说，若一个类有若干个对象，则把这一系列的对象用一个数组来存放。
       对象数组的元素是对象，不仅具有数据成员，而且还有函数成员
       定义一个一维数组的格式如下：
       类名 数组名[下标表达式];

1
exam ob[4]; //定义了类exam的对象数组ob。

       与基本数据类型的数组一样，在使用对象数组时也只能访问单个数组元素，也就是一个对象，通过这个对象，也可以访问到它的公有成员
       使用的一般形式是：
       数组名[下标].成员名

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include<iostream.h>
class exam
{
public:
    void set_x(int n){ x=n; }
    int get_x(){ return x; }
    
private:
    int x;
};
int main()
{
    exam ob[4];
    int i;
    for(i=0;i<4;i++)
    {
        ob[i].set_x(i);
    }
    
    for(i=0;i<4;i++)
    {
        cout<<ob[i].get_x()<<′ ′;
    }
    cout<<endl;
    return 0;
}

1
0 1 2 3

       如果需要建立某个类的对象数组，在设计类的构造函数时就要充分考虑到数组元素初始化的需要
       ● 当各个元素的初值要求为相同的值时，应该在类中定义出不带参数的构造函数或带缺省参数值的构造函数
       ● 当各元素对象的初值要求为不同的值时需要定义带形参（无缺省值）的构造函数
       ● 定义对象数组时，可通过初始化表进行赋值。定义对象数组时，可通过初始化表进行赋值
       通过初始化表给对象数组赋值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
#include<iostream.h>
class exam
{
public:
    exam() { x=123;}
    exam(int n) { x=n;}
    
    int get_x() { return x; }
    
private:
    int x;
};
int main()
{
    exam ob1[4]={11,22,33,44};
    exam ob2[4]={55,66};
    exam ob3[4]={exam(11),exam(22),exam(33),exam(44)};
    exam ob4[4]={exam(55),exam(66)};
    ob4[2]=exam(77);
    ob4[3]=exam(88);
    int i;
    for(i=0;i<4;i++)
    {
        cout<<ob1[i].get_x()<<' ';
    }
    
    cout<<endl;
    for(i=0;i<4;i++)
    {
        cout<<ob2[i].get_x()<<' ';
    }
    
    cout<<endl;
    for(i=0;i<4;i++)
    {
        cout<<ob3[i].get_x()<<' ';
    }
    
    cout<<endl;
    for(i=0;i<4;i++)
    {
        cout<<ob4[i].get_x()<<' ';
    }
    
    cout<<endl;
    return 0;
}

1
2
3
4
11 22 33 44
55 66 123 123
11 22 33 44
55 66 77 88

       本例说明当构造函数具有一个以上的参数时，如何对二维数组对象进行初始化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include <iostream.h>
class example
{
public:
    example(int n, int m)
    {
        x = n;
        y = m;
    }
    ~example() { cout<<"Destructor called.\n"; }
    
    int get_x() { return x;}
    int get_y() { return y;}
    
private:
    int x,y;
};
int main()
{
    example op[3][2]={
        example(1,2),example(3,4),
        example(5,6),example(7,8),
        example(9,10),example(11,12)
    };
	
    int i;
    for(i=0;i<3;i++)
    {
        cout<<op[i][0].get_x()<<' ';
        cout<<op[i][0].get_y()<<"\n";
        cout<<op[i][1].get_x()<<' ';
        cout<<op[i][1].get_y()<<"\n";
    }
    cout<<"\n";
    return 0;
}

对象指针

       每一个对象在初始化后都会在内存中占有一定的空间。因此，即可以通过对象名访问一个对象，也可以通过对象地址来访问一个对象。
       对象指针就是用于存放对象地址的变量。声明对象指针的一般语法形式为：类名* 对象指针名
       用指针访问单个对象成员
       ● 定义指针变量：Date ✱p,date1;
       ● 初始化：指向一个已创建的对象 p=&date1;
       ● 访问：用“->”操作符，只能访问该对象的公有成员。

1
p->setdate(2007,10,18);

       对象指针的使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include<iostream.h>
class exe
{
public:
    void set_a(int a){ x=a; }
    void show_a(){ cout<<x<<endl; }
    
private:
    int x;
};
int main()
{
    exe ob,*p; // 声明类exe的对象ob和类exe的对象指针p
    ob.set_a(2);
    ob.show_a(); // 利用对象名访问对象的成员
    p=&ob; // 将对象ob的地址赋给对象指针p
    p->show_a(); // 利用对象指针访问对象的成员
    return 0;
}

       用对象指针访问对象数组
       对象指针不仅能访问单个对象，也能访问对象数组。

1
2
3
exe *p; //声明对象指针p
exe ob[2]; //声明对象数组ob[2]
p=ob; //将对象数组的首地址赋给对象指针

1
2
3
4
5
6
7
8
9
10
11
int main()
{
    exe ob[2],*p;
    ob[0].set_a(10);
    ob[1].set_a(20);
    p=ob;
    p->show_a();
    p++;
    p->show_a();
    return 0;
}

       结果：

1
10 20

       一般而言，当指针加1或减1时，它总是指向其基本类型中相邻的一个元素，对象指针也是如此。本例中指针对象p加1时，指向下一个数组对象元素。
       本例说明如何通过对象指针来访问对象数组，使程序以相反的顺序显示对象数组的内容

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#include <iostream.h>
class example
{
public:
    example(int n, int m)
    {
        x=n;
        y=m;
    }
    
    int get_x() { return x;}
    int get_y() { return y;}
    
private:
    int x,y;
};
int main()
{
    example op[4]=
    {
        example(1,2),
        example(3,4),
        example(5,6),
        example(7,8)
    };
    
    int i;
    example *p;
    p=&op[3]; // 取出最后一个数组元素的地址
    for(i=0;i<4;i++)
    {
        cout<<p->get_x()<<‘ ‘;
        cout<<p->get_y()<<"\n";
        p--; // 指向前一个数组元素
    }
    cout<<"\n";
    return 0;
}

       指向类的成员的指针
       类的成员自身也是一些变量、函数或者对象等。因此，也可以直接将它们的地址存放到一个指针变量中，这样就可以使指针直接指向对象的成员，进而可以通过指针访问对象的成员。
       可在类外定义指向类的成员的指针来控制对象的成员。
       注意：
       ● 指向成员的指针只能访问公有数据成员和成员函数。
       ● 使用要先声明，再赋值，然后访问。
       指向数据成员的指针
       ● 声明： 类型说明符 类名:: ✱数据成员指针名
       ● 赋值： 数据成员指针名＝&类名:: 数据成员名
       ● 使用 对象名. ✱数据成员指针名 对象指针名->✱数据成员指针名
       访问对象的公有数据成员的几种方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include<iostream.h>
class A{
public:
    A(int i) { z=i; }
    int z;
};
int main()
{
    A ob(5);
    A *pc1; // 声明一个对象指针pc1
    pc1=&ob; // 给对象指针pc1赋值
    int A∷*pc2; // 声明一个数据成员指针pc2
    pc2=&A∷z; // 给数据成员指针pc2赋值
    cout<<ob.*pc2<<endl; // 用成员指针pc2访问数据成员z
    cout<<pc1->*pc2<<endl; // 用成员指针pc2访问数据成员z
    cout<<ob.z<<endl; // 使用对象名访问数据成员z
    return 0;
}

       指向成员函数的指针
       ● 声明： 类型说明符 (类名∷ ✱指针名)(参数表)
       ● 赋值： 成员函数指针名 = 类名∷成员函数名
       ● 使用 (对象名.成员函数指针名)(参数表) (对象指针名 -> ✱成员函数指针名) (参数表)
       *访问对象的公有成员函数的几种方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include<iostream.h>
class Coord
{
public:
    Coord(int a=0,int b=0) { x=a; y=b; }
    int getx() { return x; }
    int gety() { return y; }
    
private:
    int x,y;
};
int main()
{
    Coord op(5,6);
    Coord *pc1=&op;
    int (Coord∷*pc_getx)();
    pc_getx=Coord∷getx;
    cout<<pc1->getx()<<endl;
    cout<<op.getx()<<endl;
    cout<<(op.*pc_getx)()<<endl;
    cout<<(pc1->*pc_getx)()<<endl;
    return 0;
}

本文标题:C++ 对象数组与对象指针

文章作者:Greedysky

发布时间:2018年01月22日 - 19时16分

最后更新:2022年12月04日 - 21时19分

原始链接:https://greedysky.github.io/2018/01/22/C++对象数组与对象指针/

许可协议: "署名-非商用-相同方式共享 3.0" 转载请保留原文链接及作者。

文章目录
  1. 1. 对象数组与对象指针
    1. 1.1. 对象数组
    2. 1.2. 对象指针