C++_對象數組與對象指針

對象數組與對象指針

1. 對象數組

所謂對象數組是指每一數組元素都是對象數組, 也就是說,若一個類有若干個對象,則把這一系列的對象用一個數組來存放。ios

對象數組的元素是對象, 不只具備數據成員,並且還有函數成員數組

定義一個一維數組的格式以下: 類名 數組名[下標表達式];函數

exam ob[4]; //定義了類exam的對象數組ob.

與基本數據類型的數組同樣,在使用對象數組時也只能訪問單個數組元素,也就是一個對象,經過這個對象,也能夠訪問到它的公有成員spa

使用的通常形式是: 數組名[下標].成員名設計

例3.4 對象數組的應用
#include<iostream.h>
class exam{
public:
    void set_x(int n){ x=n; }
    int get_x(){ return x; }
private:
    int x;
};
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;
}
0 1 2 3

若是須要創建某個類的對象數組,在設計類的構造函數時就要充分考慮到數組元素初始化的須要;指針

  • 當各個元素的初值要求爲相同的值時,應該在類中定義出不帶參數的構造函數或帶缺省參數值的構造函數;
  • 當各元素對象的初值要求爲不一樣的值時須要定義帶形參(完好省值)的構造函數。
  • 定義對象數組時,可經過初始化表進行賦值。定義對象數組時,可經過初始化表進行賦值
【例3.5】 經過初始化表給對象數組賦值
#include<iostream.h>
class exam{
public:
    exam()
    { x=123;}
    exam(int n)
    { x=n;}
    int get_x()
    { return x; }
private:
    int x;
};
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;
}
11 22 33 44
55 66 123 123
11 22 33 44
55 66 77 88
【例3.6】 本例說明當構造函數具備一個以上的參數時,如何對二維數組對象進行初始化
#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;
};
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;
}
1 2
3 4
5 6
7 8
9 10
11 l2
Destructor called.
Destructor called.
Destructor called.
Destructor called.
Destructor called.
Destructor called.

2. 對象指針

每個對象在初始化後都會在內存中佔有必定的空間。所以,便可以經過對象名訪問一個對象,也能夠經過對象地址來訪問一個對象。code

對象指針就是用於存放對象地址的變量。聲明對象指針的通常語法形式爲:類名* 對象指針名;對象

(1)用指針訪問單個對象成員

  • 定義指針變量:Date *p,date1;
  • 初始化:指向一個已建立的對象 p=&date1;
  • 訪問:用「->」操做符,只能訪問該對象的公有成員

    p->setdate(2007,10,18);內存

例3.7 對象指針的使用
#include<iostream.h>
class exe{
public:
    void set_a(int a){ x=a; }
    void show_a(){ cout<<x<<endl; }
private:
    int x;
};
main()
{
    exe ob,*p; // 聲明類exe的對象ob和類exe的對象指針p
    ob.set_a(2);
    ob.show_a(); // 利用對象名訪問對象的成員
    p=&ob; // 將對象ob的地址賦給對象指針p
    p->show_a(); // 利用對象指針訪問對象的成員
    return 0;
}
2
2

(2)用對象指針訪問對象數組

對象指針不只能訪問單個對象,也能訪問對象數組.get

exe *p; //聲明對象指針p
exe ob[2]; //聲明對象數組ob[2]
p=ob; //將對象數組的首地址賦給對象指針
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;
}

結果:

10 20

通常而言,當指針加1或減1時,它老是指向其基本類型中相鄰的一個元素,對象指針也是如此. 本例中指針對象p加1時,指向下一個數組對象元素.

【例3.8】 本例說明如何經過對象指針來訪問對象數組,使程序以相反的順序顯示對象數組的內容
#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;
};
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;
}
7 8
5 6
3 4
1 2

指向類的成員的指針

類的成員自身也是一些變量、函數或者對象等。所以,也能夠直接將它們的地址存放到一個指針變量中,這樣就可使指針直接指向對象的成員,進而能夠經過指針訪問對象的成員。

可在類外定義指向類的成員的指針來控制對象的成員。

注意:

  • 指向成員的指針只能訪問公有數據成員和成員函數。
  • 使用要先聲明,再賦值,而後訪問。

(1)指向數據成員的指針

  • 聲明: 類型說明符 類名:: *數據成員指針名
  • 賦值: 數據成員指針名=&類名:: 數據成員名
  • 使用
    • 對象名. *數據成員指針名
    • 對象指針名->*數據成員指針名
【例3.9】 訪問對象的公有數據成員的幾種方式
#include<iostream.h>
class A{
public:
    A(int i) { z=i; }
int z;
};
void 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
}

(2)指向成員函數的指針

  • 聲明: 類型說明符 (類名∷ *指針名)(參數表);
  • 賦值: 成員函數指針名 = 類名∷成員函數名;
  • 使用
    • (對象名.*成員函數指針名)(參數表);
    • (對象指針名 -> *成員函數指針名) (參數表);
【例3.10】 訪問對象的公有成員函數的幾種方式
#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;
};
void 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;
}
相關文章
相關標籤/搜索