會計學1第7章類與對象7.1

面向對象的程序設計

面向對象的程序設計的核心是用類來抽象地描述所需解決的某類問題，用對象來代表所要解決的具體問題。類是一個概念，即數據類型；而對象是實例，即變量。

編程案例：

現有二個三角形，需要編程計算它們的周長和面積。三角形：

邊長a；

邊長b；邊長c；

周長l；

面積s。某三角形：

邊長3；

邊長4；邊長5；

周長12；

面積6。類：數據類型對象：變量第1頁/共57頁

面向過程的程序設計方法：

(1)定義函數fun求三角形的周長和面積。三角形的邊長通過函數的參數傳入；

(2)在主函數中用二組變量分別表示二個三角形的邊長，并分別調用函數fun求得各三角形的周長和面積。缺點：數據之間沒有關系，數據和功能之間沒有聯系。

面向對象的程序設計方法：

(1)

定義一個表示三角形的通用模塊（類），描述三角形的數據（邊長、周長和面積），以及求周長和面積的方法（函數）；

(2)在主函數中用定義的類，說明二個變量（對象），并調用函數求三角形的周長或面積。優點：對象之間相對獨立；內部自成一體，不但包含對象屬性（數據），還包含數據的操作（函數）。7.1

面向對象的程序設計第2頁/共57頁7.2.1類

類是對某一類問題的抽象的描述。

某一類問題：在所關注的問題上是通用的；

抽象：只提取必要的信息。類定義的基本格式：

class類名{

private:

//私有成員

私有成員列表；

protected://保護成員

保護成員列表；

public:

//公有成員

公有成員列表；

}；7.2

類與對象私有成員只能在類中直接訪問；

保護成員可以在類中，及其派生類中直接訪問；

公有成員允許在任何地方直接訪問。設類的對象t有公有成員a和私有成員b，主函數中可直接使用t.a，但不能直接用t.b，只能間接訪問。類的缺省訪問特性是私有的，而結構體的缺省訪問特性是公有的。第3頁/共57頁例7-1

定義一個求三角形的周長和面積的類TRI。classTRI{floata,b,c;

public:

set(floata1,floatb1,floatc1){a=a1;b=b1;c=c1;}

floatgirth(){return(a+b+c);}

floatarea();

};floatTRI::area()

{

floats,t;

t=girth()/2;

s=sqrt(t*(t-a)*(t-b)*(t-c));

returns;

}7.2.1類成員函數可以在類中直接定義，也可以在類中說明，類外定義。類外定義時，用類名和作用域運算符（::）說明其所屬的類。第4頁/共57頁7.2.1類類定義的幾點說明：(1)訪問特性關鍵字出現的順序和次數均沒有限制，但同一訪問特性成員應相對集中以增加程序的可讀性；(2)與結構體定義相似，不能用關鍵字auto、register、extern說明成員的存儲類型，不能初始化數據成員；(3)類體中直接定義的成員函數具有內聯特性，類中說明類外定義的成員函數用inline說明才具有內聯特性。(4)類成員具有類作用域，即類的成員類中處處可見，沒有先后。

classmyclass{

public: voidf(){cout<<data;}

public: intdata;

};第5頁/共57頁對象

對象是類概念下的實例。類是對某一類問題的通用描述，只有對象才能表示具體的問題。類與對象的關系，類似于數據類型與變量的關系。1.對象的定義

定義對象的方法與定義結構體變量的方法相似，主要有3種：

(1)先定義類，再定義對象；

(2)定義類的同時，定義對象；

(3)不列出類名，直接定義對象。2.對象的使用

類體中直接使用類的非靜態成員，類體外必須指明成員隸屬的類。定義對象后，通過對象名和成員運算符“.”使用類的公有成員。7.2.2對象第6頁/共57頁例7-2

對象定義和使用

classA{

inta;

public:

intb;

voidset(intt1,intt2){a=t1;b=t2;}

voidprint(){cout<<a<<','<<b<<endl;}

intgeta(){returna;}

}a1;voidmain()

{Aa2;

a1.set(1,2);a2.set(5,10);a1.print();

cout<<a2.geta()<<',‘<<a2.b<<endl;}7.2.2對象對象成員的使用：成員運算符，注意成員數據與函數成員的區別；公有成員和私有成員的操作權限；對象成員相對獨立，同類型對象賦值。12a1

a

ba2

a

b5

101

2a2=a1;程序輸出為：

1，2

5，10第7頁/共57頁例7-3

對象的指針和引用

classB{

inta,b;

public:

voidset(intt1,intt2){a=t1;b=t2;}

voidprint(){cout<<a<<','<<b<<endl;}

};voidmain()

{Bb1,*p1=&b1,&b2=b1,*p2;

b1.set(5,10);p2=newB;*p2=b1;

b1.print();b2.print();

p1->print();p2->print();

deletep2;}7.2.2對象對象的指針、引用和動態對象；用指針操作對象成員的形式。程序輸出為：

510

510

510

510第8頁/共57頁

程序中聲明一個對象時，系統需要根據其所屬的類的結構分配相應的內存空間；同時也可以對該對象的數據成員賦值，即初始化對象。當對象結束生命期時，系統需清理內存。這兩部分工作由類的構造函數和析構函數來完成。7.3.1構造函數

構造函數是類中與類同名的一組特殊的成員函數。定義對象時，系統自動調用相應的構造函數，初始化所定義的對象。構造函數定義的基本格式為：

類名(形參列表){初始化數據成員語句}構造函數類中說明，類外定義格式為：

(1)類中說明：類名（形參列表）；

(2)類外定義：類名::類名（形參列表）

{初始化數據成員語句}7.3構造函數與析構函數第9頁/共57頁例7-4

構造函數定義和調用

#include<iostream.h>classC{

inta,b;

public:

voidprint(){cout<<a<<'\t'<<b<<endl;}

};voidmain()

{

c1.print();

}7.3.1構造函數構造函數定義：公有；

造函數沒有函數類型，也不是void類型；函數體中不能用return語句返回函數值。構造函數調用：自動、參數一致。程序輸出為：

510

主函數中增加語句：

Cc1；//語法錯誤voidset(intt1,intt2){a=t1;b=t2;}Cc1;c1.set(5,10);C(intt1,intt2){a=t1;b=t2;}Cc1(5,10);第10頁/共57頁7.3.1構造函數關于構造函數的定義和使用，需注意以下幾點：(1)構造函數中，數據成員的初始化可以在函數體內實現，也可以通過數據成員列表的方式實現。例如，上例中的構造函數可以寫成如下形式：

C(intt1,intt2):a(t1),b(t2)

{}(2)在類中與類同名的成員函數一定是類的構造函數。(3)一個類可以有多個構造函數，但必須滿足函數重載的原則。(4)任何一個類均有構造函數，任何一個對象生成時必定要調用相應的構造函數來初始化其成員。如果類中沒有定義構造函數，系統編譯時會自動產生一個空的構造函數，此時數據成員的值不確定。第11頁/共57頁7.3.2

缺省構造函數

缺省的構造函數主要有3種情況：編譯系統自動生成的缺省構造函數

用戶沒有定義構造函數時，系統自動生成的沒有參數、函數體內沒有語句的構造函數。用戶定義的沒有參數的構造函數。用戶定義的所有參數都有缺省值的構造函數。定義、使用缺省的構造函數時注意：編譯系統自動生成的缺省構造函數僅用來生成對象，而不能初始化對象；只要用戶定義了構造函數，編譯系統將不再自動生成缺省的構造函數

。一個類中，最多有一個缺省的構造函數；但可能沒有缺省的構造函數。第12頁/共57頁例7-5

缺省構造函數定義使用

#include<iostream.h>

classA{

inta;

public:

A(){a=1;}

voidprint(){cout<<a;}

};classB{

inta;

public:

B(intt1){a=t1;}

voidprint(){cout<<a;}

};7.3.2

缺省構造函數

classC{inta;

public:

voidprint(){cout<<a;}

};classD{inta;

public:

D(intt1=3) {a=t1;}

voidprint(){cout<<a;}

};voidmain(){

Aa1;//a1.a=1Bb1;//編譯錯誤

Cc1;//c1沒有初始化

Dd1,d2(5); //d1.a=3,d2.a=5

}A(intt1=1){a=t1;}//？C(){}Bb2();//說明無參函數b2調用缺省構造函數建立對象時，不能給對象提供參數。無法確定調用哪個構造函數。第13頁/共57頁7.3.3

拷貝構造函數

拷貝構造函數：以對象的引用作為函數參數，即用一個已存在的對象去初始化一個新建立的同類對象。主要有二種情況：缺省的拷貝構造函數

在用戶沒有定義拷貝構造函數時，系統自動生成一個缺省的拷貝構造函數，將用于提供初始數據的對象的成員值依次復制到新定義的對象中。用戶定義的拷貝構造函數

用戶自定義的、以該類對象引用為參數的構造函數。當用戶定義了拷貝構造函數時，系統就不再自動生成缺省的拷貝構造函數?？截悩嬙旌瘮瞪蓪ο蟮姆绞剑侯惷?/p>

新對象名（已有對象名）；類名

新對象名=已有對象名；第14頁/共57頁例7-6

拷貝構造函數定義使用

#include<iostream.h>

classA{inta;

public:

A(intt){a=t;}

voidprint(){cout<<a;}

};classB{int*p;

public:

B(intt){p=newint(t);}

voidprint(){cout<<*p;}

voiddel(){deletep;}

};7.3.3

拷貝構造函數

voidmain(){

Aa1(1),a2(a1);

Bb1(5),b2=b1；

a1.print();a2.print();b1.print();b2.print();b1.del();b2.del();

}A(A

&t){a=t.a;}a1.a1a2.a1b1.p5b2.p5B(B

&t)

{p=newint(*t.p);}B(B

&t){p=t.p;}程序輸出為：

11

55

a2.p=a1.p第15頁/共57頁7.3.4構造函數與成員初始化列表

當類的數據成員是引用類型、常量型或對象時，不能在構造函數體中用賦值語句直接初始化，而應以成員列表的形式在函數頭部完成。使用時注意：初始化對象成員的基本形式：

類名（形參列表）：對象名（實參列表）//對象成員初始化

{普通成員（基本變量）初始化}普通成員也可以在列表中初始化。初始化列表只是提供了相應成員的初始化形式和數據，并沒有決定各個成員的初始化順序。列表中成員的初始化順序由類定義時成員的說明順序決定。列表中的成員初始化完成后，再執行構造函數函數體，初始化其他成員。第16頁/共57頁例7-7對象成員初始化

#include<iostream.h>

classA{inta;

public:

A(intt){a=t;}

intgeta(){returna;}

};classB{inta,b;

Aa1;intc,d;

public:

B(intt):d(t++),a1(t++),a(t++)

{c=t++;b=t;}

voidprint()

{cout<<a<<b<<c<<d<<a1.geta()<<endl;}

};7.3.4構造函數與成員初始化列表voidmain(){

Bb1(1);b1.print();}程序輸出為：

15432

初始化過程：

(1)列表中的成員

(2)函數體

語句順序成員說明順序：a→a1→d

：c→b第17頁/共57頁7.3.5析構函數

析構函數也是類的一種特殊成員函數，執行與構造函數相反的操作，用于撤銷對象時的清理，如釋放分配給對象的內存空間等。函數名由析構運算符“~”和類名組成。沒有函數類型，不能用return返回值。沒有參數，不能重載。由系統自動調用，調用順序與構造函數相反。通常無需定義，系統自動生成的缺省析構函數為：

~類名（）{}

當構造函數為類的指針成員分配了動態內存時，用戶應定義析構函數，釋放動態內存；此時，系統不再生成缺省的析構函數。第18頁/共57頁例7-8析構函數使用

#include<iostream.h>

#include<string.h>

classA{

char*s;public:

A(char*p);

~A();

voidprint(){

cout<<s<<endl;

}

};voidmain()

{Aa1("VisualC++"); a1.print();}7.3.5析構函數A::A(char*p){

s=newchar[strlen(p)+1];

strcpy(s,p);

cout<<"調用了構造函數\n";

}A::~A(){

delete[]s;

cout<<"調用了析構函數\n";

}程序輸出為：

調用了構造函數

VisualC++

調用了析構函數第19頁/共57頁例7-9構造函數與析構函數使用

#include<iostream.h>classA；classB；voidmain(){ Aa1,a2(1),a3(a1); Bb1(2,3),b2;}classA{inta;public: A(intx){a=x;cout<<"構造函數A\n";} A(){a=0;cout<<"缺省構造函數A\n";} A(A&t){a=t.a+10;cout<<"拷貝構造函數A\n";} ~A(){cout<<a<<',';cout<<"釋放A類對象\n";}};7.3.5析構函數程序輸出為：

缺省構造函數A

構造函數A

拷貝構造函數A

構造函數A

構造函數B

缺省構造函數A

缺省構造函數B第20頁/共57頁例7-9構造函數與析構函數使用

classB{ intb; Aa1;public: B(intx,inty):a1(x) {b=y;cout<<"構造函數B\n";} B()

{b=5;

cout<<"缺省構造函數B\n";

} ~B()

{cout<<b<<',';

cout<<"釋放B類對象\n";

}};7.3.5析構函數程序輸出為：

5,釋放B類對象

0,釋放A類對象

3,釋放B類對象

2,釋放A類對象

10,釋放A類對象

1,釋放A類對象

0,釋放A類對象第21頁/共57頁

類的各對象的數據相互獨立，類的成員函數代碼相同。成員函數如何區分其操作的數據所屬的對象？

C++中，類的各個非靜態成員函數中都有一個由系統提供的指針常量this，指向調用該成員函數的對象（當前對象），非靜態成員函數中的成員均被隱含地施加了this指針，即類中缺省引用的非靜態成員是this指針所指向的成員。如：

voidA::print(){cout<<a;}

即voidA::print(){cout<<this->a;}通常情況下，this指針由系統自動隱含使用。特定情況下，用戶必須顯式地使用this指針。7.4

this指針第22頁/共57頁例7-10this使用

#include<iostream.h>

classA{

inta,b;

public:

A(inta,intt)

{this->a=a;b=t;}Aadd(A&t)

{a=a+t.a;

b=b+t.b;

return*this;

}voidprint()

{cout<<a<<'\t'<<b<<endl;}

};7.4this指針voidmain()

{Aa1(1,2),a2(5,10);

a1.print();a2.print();a2=a1.add(a2);a1.print();a2.print();

}成員函數中直接使用的成員，通常等同于this->成員。程序輸出為：

12

510

612

612this->a=this->a+t.a;根據局部優先原則，參數a。第23頁/共57頁

同一個類的不同對象之間的普通成員是相互獨立的，即可以有不同的數據。而靜態成員則可實現不同對象之間的數據和函數共享。在類的定義中，用關鍵字static說明的成員為靜態成員，分靜態數據成員和靜態成員函數。7.5.1靜態數據成員

類的靜態數據成員不屬于特定對象，而屬于類；必須在類中說明的同時，在類外定義；改變了一個對象靜態數據成員的值，則所有其他對象的相應靜態數據成員的值均隨之改變。7.5

靜態成員A::ba24aa11a0classA{public:inta;staticintb,c;

A(intx,inty,intz){a=x;b=y;c=z;}};

intA::b,A::c=10;

Aa1(1,2,3),a2(4,5,6);A::c102356第24頁/共57頁例7-11類的靜態數據成員的定義與使用

#include<iostream.h>

classA{

inta;

staticintb,c;public:

A(intt){a=t;}voidadd()

{a++;b++;c++;}

voidprint()

{cout<<a<<'\t';

cout<<b<<'\t'<<A::c<<endl;

}

};intA::b,A::c=5;7.5.1靜態數據成員voidmain(){Aa1(0),a2(3);a1.print();a2.print();a1.add(); a1.print();a2.print();}靜態數據成員缺省初值為0；類中引用性說明格式為：

static數據類型成員名;類外定義格式為：

數據類型類名::成員名(初值)；

數據類型類名::成員名=初值；程序輸出為：

005

305

116

316第25頁/共57頁

在類體中用關鍵字static修飾的函數稱為類的靜態成員函數。靜態成員同樣為該類的所有對象所共有，不屬于某個特定的對象，函數內部沒有this指針。靜態成員函數可以類體中說明，類體外定義。類體中說明時必須用static修飾，類體外定義時不能用static修飾。靜態成員函數中訪問成員

只能直接訪問類的靜態成員，等同于類名::靜態成員；間接訪問類的非靜態成員，等同于類外訪問，即對象.非靜態成員。普通函數中訪問靜態成員

(1)

非靜態成員函數：通過this指針，或“類名::”訪問。

(2)

外部函數：可以指明其所屬的對象（對象.靜態成員），也可以指明其所屬的類（類名::靜態成員）。7.5.2靜態成員函數第26頁/共57頁例7-12類的靜態成員函數的定義與使用

#include<iostream.h>

classS{

inta;staticintb;public:

S(intt){a=t;}

staticvoidadd1()

{b++;//等同于S::b++

a++;//等同于this->a++,錯誤！

}

staticvoidadd2(St)；

voidprint(){cout<<a<<'\t'<<b<<endl;}

}；intS::b=5;

voidS::add2(St){t.a++;b++;}7.5靜態成員voidmain(){S::add1();//指明所屬類

Ss1(0);s1.print();s1.add2(s1);//指明所屬對象

s1.print();}刪除錯誤行后,程序輸出為：

06

07通過this訪問靜態成員也可通過類名::訪問，即S::b第27頁/共57頁7.6

常對象與常成員

用關鍵字const修飾類的成員或對象，在程序運行期間是不可改變的，稱為常成員或常對象。1.常數據成員在類中說明時加關鍵字const的數據成員。除靜態常數據成員以外，類的常數據成員只能在類的構造函數中通過初始化列表的方式初始化，不能通過賦值的形式初始化。類的靜態常數據成員只能在類外定義時初始化。常數據成員只能被讀取，不能被修改。第28頁/共57頁例7-13常成員數據的定義與使用

#include<iostream.h>

classT{

inta;

intconstb;//常成員,constintb;

constint&c;

//常成員引用

conststaticintd;

//靜態常成員public:

T(intt1,intt2):b(t2),c(a)

{a=t1;}voidprint(){cout<<a<<b<<c<<d<<endl;}

voidfun(){a++;}//不可改變b、c、d

};constintT::d=15; voidmain(){Tt1(5,10);t1.print();t1.fun();t1.print();}程序輸出為：

510515

6106157.6

常對象與常成員非常數據成員不可以引用常數據成員，常數據成員可以引用非常數據成員第29頁/共57頁7.6

常對象與常成員2.常成員函數

用關鍵const說明的成員函數稱為常成員函數：

函數類型函數名（形參表表）const;關鍵字const加在函數頭部的最后，而不是加在最前面。如果加在最前面，則表示函數的類型是一個常量。關鍵字const是函數類型的一個組成部分，原型說明時不可省略。常成員函數不能修改本類的數據成員，也不能調用其他非常成員函數。關鍵字const作為函數重載時區分不同函數的標志。重載的原則是：常對象調用常成員函數，一般對象調用一般成員函數。第30頁/共57頁7.6

常對象與常成員3.常對象

定義時通過const修飾的對象為常對象，其定義形式如下：

類名const

對象名；

或：

const

類名對象名；常對象定義時必須初始化；常對象的數據成員不允許被改變；通過常對象，只能調用類的常成員函數。非常對象，既可以調用非常成員函數，也可以調用常成員函數。第31頁/共57頁例7-14常成員函數與常對象使用

#include<iostream.h>

classA{

inta;

intconstb;

public:

A(intt1,intt2):b(t1)

{a=t2;}

voidprint()const;voidprint(){cout<<a-b<<endl;}

voidadd(intt){a+=t;}

};voidA::print()const

{cout<<a+b<<endl; } voidmain(){constAa1(5,10);Aa2(1,2); a1.add(3);//編譯錯誤

a2.add(3);a1.print();a2.print();}程序輸出為：

15

47.6

常對象與常成員常對象只能引用常成員第32頁/共57頁例7-15根據鍵盤輸入的身份證號計算相應的年齡。程序設計從身份證號碼中提取出生年份，并與當前年份相減即可得到年齡。從身份證號碼中提取出生年份的方法是把身份證號碼作為一個字符串，然后把指定位置（從第7位到第10位）的數字字符轉換為一個整數。當前年份可以通過調用C++庫函數time來獲取。函數time返回time_t格式的系統當前日期，然后調用庫函數localtime將其轉換為一個tm類型的結構體變量，其中成員tm_year中存放以1900年為起點的年份數。類型time_t和結構體tm都在系統文件time.h中定義。7.7程序設計舉例第33頁/共57頁

源程序代碼

#include<iostream.h>#include<time.h>#include<string.h>classID{

charid[20];

//

身份證號

intage;

//

年齡public:

ID(char*id){strcpy(this->id,id);}

intval(char*p,inti,intj);//從身份證中提取出生日期

voidfun();//計算年齡

voiddisplay()

{ cout<<"身份證號："<<id<<endl; cout<<"年齡："<<age<<endl;

}};7.7程序設計舉例voidmain(){chars[20];cout<<"請輸入身份證號：";cin>>s;IDid(s);id.fun();id.display();}第34頁/共57頁

源程序代碼

intID::val(char*p,inti,intj){

//從身份證中提取出生日期

//將字符串從第i個字符開始的j個連續數字轉換為一個整數

intn=0,k=i+j;

while(i<k){ n=n*10+*(p+i)-'0';

i++;

}

return(n);}7.7程序設計舉例voidID::fun() //計算年齡{intyear=val(id,6,4);

//以下2行獲取當前時間,并存入tm類型的結構體變量t中

time_ttimer;timer=time(0);tmt=*localtime(&timer);age=t.tm_year+1900-year;}第35頁/共57頁例7-16定義一個數組類，實現將二維數組各行元素排序、各列元素排序、全體元素按內存順序排序等功能。程序設計

classArray{

inta[4][5];

public:

Array(intt[][5]);

voidprint();

voidfun1(); //行排序

voidfun2(); //列排序

voidfun3(); //內存順序排序

};7.7程序設計舉例第36頁/共57頁程序設計voidmain(){intdata[4][5]={…};Arraya1(data),a2(data);cout<<"\n原數組:\n";a1.print();cout<<"\n行排序:\n";a1.fun1();a1.print();cout<<"\n列排序:\n";a1=a2;a1.fun2();a1.print();cout<<"\n內存順序排序:\n";a1=a2;a1.fun3(); a1.print();}7.7程序設計舉例第37頁/共57頁例7-17定義一個類，將一組數組按給定的行列表示成一個二維數組。程序設計

classArray{

int*p;

//指針成員表示一組數組

intm,n;

//m、n分別為二維護數組的行數和列數

public:

Array(int*t,inta,intb);

~Array()

{

delete[]p;

}

//撤銷動態內存

intget(inti,intj);//取數組下標為[i][j]的元素

voidprint();

};voidmain()

{constinti0=3,j0=5;intdata[i0*j0]={…};

Arraya1(data,i0,j0);a1.print();

}7.7程序設計舉例第38頁/共57頁例7-18定義一個將學生類，將一組學生的數據存入對象數組，并根據成績學生信息排序。要求每個同學的信息中均含有該班成績的總分和平均分。程序設計

classSTU;//表示一個學生的類

voidinput(STUt[]);

voidsort(STU*p[]);

voidprint(STU*t[]);

voidmain()

{

STU*p[5],s[5];

input(s);

for(inti=0;i<STU::get_count();i++)p[i]=s+i;

sort(p);

print(p);

}7.7程序設計舉例第39頁/共57頁程序設計

classSTU{

floatscore;

charname[15];

staticintcount;

staticfloatsum,average;

public:

STU(){

count++;

}

~STU(){

count--;}

voidinput();

voidprint(){

cout<<name<<":"<<score<<endl;

}

staticintget_count(){

returncount;

}

staticfloatget_sum()

{

returnsum;

}

staticfloatget_average(){

returnaverage;

}

floatget_score()

{

returnscore;

}

};7.7程序設計舉例第40頁/共57頁程序結構

面向對象的編程有兩部分組成：

(1)類的定義；

(2)類的測試

主函數中用定義的類說明對象，然后通過對象調用有關的成員函數。構造函數

用形參初始化數據成員。根據數據成員，分3種情況：

(1)普通變量作成員；

(2)數組作成員；

(3)指針作成員。析構函數

釋放構造函數中分配的動態空間，只有數據成員為第3種情況時才需定義。7.7程序設計舉例第41頁/共57頁輸出函數

根據要求，按3種數據成員采用適當的方法輸出數據成員。功能函數

完成題目提出的操作要求，如排序、取字符串中的數字、調整元素（行列）位置等。測試程序（主函數）

(1)定義對象時注意

類的數據成員為非字符數組時，對象的參數只能是與形參對應的數組名；而數據成員為字符數組時，對象的參數除了數組名外，還可以是字符串常量。

(2)調用成員函數時注意

調用語句基本格式為：對象.成員函數（實參）；

注意成員函數調用的順序和參數。7.7程序設計舉例第42頁/共57頁數據成員為普通變量

構造函數中直接把實參賦給數據成員。數據成員為一維數組

構造函數的形參為指針變量（一維數組）和整型變量（數組大?。瘮刁w中通過循環語句把形參賦給數據成員，其他功能函數體中通過循環語句操作一維數組。數據成員為字符數組

構造函數的形參為指針變量（字符數組），通過字符串處理函數（賦值）、循環語句等方法操作字符數組。數據成員為二維數組

構造函數的形參為行指針（二維數組）和整型變量（二維數組行數），通過二層循環語句操作二維數組。7.7程序設計舉例第43頁/共57頁數據成員為指針變量用new為指針變量分配動態空間；分配動態空間后，指針變量等同于數組。然后用操作數組的方法操作指針變量所指指動態動態空間，注意指針變量所指位置，盡可能不要移動。如：

classmycalass{

int*p,num;

char*str;

public:

myclass(inta[],intn,char*s)

{num=n;p=newint[num];

for(inti=0;i<num;i++)p[i]=a[i];

str=newchar[strlen(s)+1];strcpy(str,s);

}7.7程序設計舉例第44頁/共57頁1.試定義一個類STR，將字符串中的數字字符依次全部移到字符串的后半部。具體要求如下：

(1)私有數據成員char*p;p為待處理的字符串。

(2)公有成員函數STR(char*s);構造函數，用s初始化數據成員p。voidmove(char&t1,char&t2);交換兩個字符的位置。voidfun();根據題意處理字符串p。算法要求：從左到右依次對字符串p的每個字符進行檢測，如果在數字字符的右側有非數字字符，則通過調用函數move()將該非數字字符與前一個字符進行交換，直到前一個字符為非數字字符為止。~STR();析構函數，撤銷所占用的動態存儲空間。voidprint();輸出數組中的所有元素。

(3)在主函數中對類STR進行測試。7.8習題第45頁/共57頁7.8習題voidSTR::fun(){for(char*p1=p;*p1;p1++){if(*p1>'9'&&*p1<'0')continue;char*p2=p1;while(*p2>='0'&&*p2<='9')p2++;if(!(*p2))break;while(*p2&&p2>p1){move(*p2,*(p2-1));p2--;}}}voidmain()

{STRt(“12AS353hjk56”);

t.print();t.fun();t.print();

}#include<iostream.h>#include<string.hclassSTR{char*ppublic:STR(char*s){p=newchar[strlen(s)+1];strcpy(p,s);}voidfun();voidmove(char&t1,char&t2){chart=t1;t1=t2;t2=t;}voidprint(){cout<<p<<endl;}~STR(){delete[]p; }};第46頁/共57頁2.試定義一個類Array，將二維數組的各列依次循環右移n次。具體要求如下：

(1)私有數據成員inta[4][4];待處理的數組。

(2)公有成員函數Array(intt[][4],intn);構造函數，用數組t初始化數組a，n表示數組的行數。voidright();將數組a各列循環右移1次，其中，數組的最右一列移至數組的最左邊。voidrmove(intn);利用成員函數rig