C程序的结构实用

会计学1C程序的结构实用

块作用域又称局部作用域。由一对花括号“{}”所括起来的块中声明的标识符的作用域从声明处开始，一直到块结束的花括号为止。例如：

#include<iostream.h> voidmain(){ voidfun1(); intn; for(inti=0;i<5;i++)

{ intm; if(i%2)n++; } m=n/2; //错误，m未定义

n=i; fun1(); //fun1()函数调用

}2)块作用域第1页/共47页voidfun1(){cout<<"i="<<i<<endl; //错误，i未定义

}编译时，函数fun1()中的语句：

cout<<"i="<<i<<endl；将出现一个未定义错误，这是因为块作用域不能延伸到子函数中。第2页/共47页3)文件作用域#include<iostream.h>

intk;

voidmain() { k=5;{k++;} {intk=7;k++;cout<<"k="<<k;} cout<<“,k="<<k<<endl; }

程序运行结果为：k=8,k=6可见性遵循的一般规则：(1)标识符在引用前必须先声明。(2)在互相没有包含关系的不同作用域中声明同名的标识符时，两标识符互不影响。(3)如果在两个或多个具有包含关系的作用域中声明了同名标识符，则外层标识符在内层不可见。第3页/共47页1)静态生存期 静态生存期与程序的运行期相同。具有文件作用域的变量具有静态生存期。如果要在函数内部的块作用域中声明具有静态生存期的变量，则要使用关键字static。例如：staticintk；

具有静态生存期的变量，也称为静态变量。2)局部生存期 在块作用域中声明的变量具有局部生存期。此生存期诞生于声明点，而终止于其作用域的结束处。具有局部生存期的变量都具有块作用域。但当在块作用域内将变量说明为静态变量时，该变量则具有静态生存期。3)动态生存期 动态生存期由程序中特定的函数(malloc()和free())调用或由操作符(new和delete)创建和释放。具有动态生存期的变量在内存的堆区分配空间。2．生存期第4页/共47页3．局部变量和全局变量1)局部变量 局部变量包括自动(auto)变量、内部静态(static)变量和函数参数。2)全局变量 全局变量具有文件作用域。

第5页/共47页//EX5_1.cpp:演示局部变量和全局变量#include<iostream.h>inti=1; //全局变量i:静态生存期voidmain(){staticinta; //声明局部静态变量a:静态生存期

intb=-10; //声明局部变量b:局部生存期

intc=0; //声明局部变量c:局部生存期

voidother(void); //声明函数other()cout<<“main:"<<"i="<<i<<"a="<<a<<"b="<<b<<"c="<<c<<endl;c=c+8;

other(); //调用函数other()cout<<“main:"<<"i="<<i<<"a="<<a<<"b="<<b<<"c="<<c<<endl;

other(); //调用函数other()}第6页/共47页voidother(void){staticinta=1; //局部静态变量a:静态生存期

staticintb; //局部静态变量b:静态生存期

intc=5; //局部变量c:局部生存期

i=i+2;a=a+3;c=c+5;cout<<"other:"<<"i="<<i<<"a="<<a<<"b="<<b<<"c="<<c<<endl;b=a;}

程序运行结果为：

main:i=1a=0b=-10c=0 other:i=3a=4b=0c=10 main:i=3a=0b=-10c=8 other:i=5a=7b=4c=10第7页/共47页

静态成员为同类的所有对象共同拥有，用于解决同类对象之间数据和函数的共享问题。静态成员分为静态数据成员和静态函数成员。

(1)静态数据成员声明：staticintn(2)静态数据成员必须要在类外进行初始化，初始化的形式为：

<类型标识符><类名>::<静态数据成员名>=<值>

例如：intPoint::n=0;(3)静态成员属于类，而不属于任何一个对象；

(4)静态成员一样要服从访问控制限制；

(5)私有静态数据成员只能在类内引用，公有或保护静态数据成员可以在类外通过类名引用。

(6)静态函数成员可以直接引用该类的静态成员，但不能直接引用非静态数据成员；

(7)公有静态函数成员可以通过类名或对象名来调用。5.1.2静态成员第8页/共47页//EX5_2.cpp:演示使用静态成员#include<iostream.h>classpoint{private:intx,y; staticintcountP; //声明私有静态数据成员

public:point(intxx=0,intyy=0) //定义构造函数

{x=xx;y=yy;countP++;}point(point&p); //声明拷贝构造函数

intget_x(){returnx;}intget_y(){returny;}staticvoidget_c()

//定义公有静态函数成员

{cout<<“Objectid=”<<countP<<endl;}//私有静态数据成};//员在类内引用第9页/共47页point::point(point&p) //定义拷贝构造函数{x=p.x; y=p.y;

countP++; //私有静态数据成员在类内引用}intpoint::countP=0; //静态数据成员必须要在类外初始化voidmain(){point::get_c(); //第1次通过类名调用静态函数成员

pointa(4,5); //声明类的对象acout<<"pointa,"<<a.get_x()<<","<<a.get_y();a.get_c(); //第2次通过对象名调用静态函数成员

pointb(a);cout<<"pointb,"<<b.get_x()<<","<<b.get_y();point::get_c(); //第3次通过类名调用静态函数成员}第10页/共47页

在主函数中，分别采用类名和对象名来调用get_c()。第1次调用get_c()时由于还没有任何对象生成，只能采用类名的形式。由此可见，通过类名调用静态函数成员可以输出静态数据成员的初始值。后面的2次get_c()的调用既可以采用类名的形式，也可以采用对象名的形式。

程序运行结果为:

Objectid=0 pointa,4,5Objectid=1 pointb,4,5Objectid=2第11页/共47页//演示使用静态成员#include"iostream.h"#include"string.h"classstu{private:char*name,*num; staticinttotal; public: stu(char*,char*); ~stu(); voidprint(); staticintgettotal(){returntotal;}};第12页/共47页intstu::total=0;stu::stu(char*n1,char*n2)/*拷贝构造函数怎么设计？*/{name=newchar[strlen(n1)+1];num=newchar[strlen(n2)+1];strcpy(name,n1);strcpy(num,n2);++total;}voidstu::print(){ cout<<"\nname:"<<name <<"\nnum:"<<num <<"\ntotal:"<<total<<endl;}第13页/共47页stu::~stu(){ delete[]name; delete[]num; --total;}intmain(intargc,char*argv[]){stua("wang","000001"); stub("yang","000002"); stuc("tang","000003"); a.print();

cout<<endl<<"total:"<<a.gettotal()<<endl; b.print(); cout<<endl<<"total:"<<stu::gettotal()<<endl; return0;}第14页/共47页

声明友元函数是为了使普通函数或其它类的成员函数能访问本类的成员，友元函数在类声明中由关键字friend修饰。 普通函数声明为友元函数的形式：

friend<类型标识符><友元函数名>(参数表)

其它类的成员函数声明为友元函数的形式：

friend<类型标识符><类名>::<友元函数名>(参数表)

说明：

(1)友元函数的声明可以在类声明中的任何位置，既可在public区，也可在protected区，意义完全一样。

(2)友元函数的定义一般放在类的外部，最好与类的其他成员函数定义放在一起。5.1.3友元

1.友元函数第15页/共47页//EX5_3.cpp:演示使用普通函数作友元函数计算两点距离

#include<iostream.h>#include<math.h>

classpoint{private: doublex,y;public:point(doublexx=0,doubleyy=0){x=xx;y=yy;}doubleget_x(){returnx;}doubleget_y(){returny;}

frienddoubledistance(pointp1,pointp2);//普通函数作}; //point的友元第16页/共47页doubledistance(pointp1,pointp2)//定义point类的友元函数{return(sqrt((p1.x-p2.x)*(p1.x-p2.x)+(p1.y-p2.y)*(p1.y-p2.y)));}voidmain(){pointmyp1(1,1),myp2(4,5);//声明point类对象myp1和myp2cout<<"Thedistanceis:"<<distance(myp1,myp2)<<endl;}友元函数必须先接收对应类的对象，然后通过接收到的对象访问其所以成员第17页/共47页

如果友元是一个类，则称为友元类。友元类的声明形式为：

friendclass<友元类名>说明：

(1)友元类的声明同样可以在类声明中的任何位置；

(2)友元类的所有成员函数都成为友元函数。

例如，若A类为B类的友元类，即在B类中声明：

friendclassA;则A类的所有成员函数都成为B类的友元函数，都可以访问B类的私有和保护成员。2.友元类第18页/共47页

友元类的成员函数可以通过对象名直接访问到隐藏的数据，达到高效协调工作的目的。但在使用友元时还有两点需要注意：(1)

友元关系不能传递。B类是A类的友元，C类是B类的友元，C类和A类之间如果没有声明，就没有任何友元关系，不能进行数据共享。

(2)友元关系是单向的。如果声明B类是A类的友元，B类的成员函数就可以访问A类的私有和保护数据，但A类的成员函数却不能访问B类的私有和保护数据。第19页/共47页例：友元成员函数#include"string.h"#include"iostream.h"classst_n;classsco{private:intmat,eng;public: sco(inti1,inti2):mat(i1),eng(i2){} voidshow() {cout<<"\nmath:"<<mat; cout<<"\neng:"<<eng; } voidshow(st_n&st);//st_n还没具体定义，

//函数show（）在后面实现};第20页/共47页classst_n{private:char*name,*num;public:

friendvoidsco::show(st_n&); st_n(char*n1,char*n2) {name=newchar[strlen(n1)+1]; num=newchar[strlen(n2)+1]; strcpy(name,n1); strcpy(num,n2); }};第21页/共47页voidsco::show(st_n&st){ cout<<"\nname:"<<; cout<<"\nnum:"<<st.num; show();}intmain(intargc,char*argv[]){ st_na("wang","123456"); scob(72,82); b.show(a); return0;}第22页/共47页

使用const关键字声明的引用称为常引用，常引用所引用的对象不能被更新。用常引用做形参，不会发生对实参意外的更改。常引用的声明形式为

const<类型标识符>&<引用名>

注意：常引用的值不能被更新，所以常引用声明时，必须同时进行初始化。5.1.4常类型

1.常引用第23页/共47页//EX5_4.cpp:演示常引用做形参

#include<iostream.h>voiddisplay(constdouble&r);//常引用做形参{cout<<“r=”<<++r<<endl;}//错误：更改常引用的对象rvoidmain(){doubled(6.5);display(d);}

这段程序编译时有一个错误：

errorC2166:1-valuespecifiesconstobject。如果将display函数的定义语句改为:cout<<"r="<<r<<endl;

则得程序运行结果为:r=6.5第24页/共47页

使用const关键字声明的对象称为常对象。常对象的声明形式为const<类名><对象名>

或<类名>const<对象名>

声明常对象的同时，也要进行初始化，而且该对象以后不能再被更新。3.常成员函数 使用const关键字声明的函数称为常成员函数，常成员函数声明的形式为

<类型标识符><函数名>(参数表)const;2.常对象第25页/共47页

说明：

(1)const是加在函数声明后面的类型修饰符，它是函数类型的一个组成部分，因此在实现部分也要带const关键字。

(2)const关键字可以被用于对重载函数的区分，例如，可以在类中这样声明：

voidfun(); voidfun()const;

(3)常成员函数不能更新对象的数据成员，也不能调用该类中没有用const修饰的成员函数。

(4)常对象只用于调用它的常成员函数，而不能调用其他成员函数。第26页/共47页//EX5_5.cpp:演示常成员函数#include<iostream.h>classA{private: intx,y;public: A(inti=0,intj=0){x=i;y=j;}

voidfun() //定义普通成员函数

{cout<<"成员函数：x="<<x<<",y="<<y<<endl;}

voidfun()

const

//定义常成员函数

{cout<<"常成员函数：x="<<x<<",y="<<y<<endl;}};voidmain(){Aobj1(1,2); //声明普通对象obj1

obj1.fun(); //调用普通成员函数

constAobj2(3,4); //声明常对象obj2

obj2.fun();

//调用常成员函数}第27页/共47页

程序运行结果为： 成员函数：x=1,y=2

常成员函数：x=3,y=44.常数据成员常数据成员也用关键字const说明，常数据成员（包括常引用、常对象）由于不能被更新，因此只能用成员初始化列表的方式通过构造函数进行初始化。第28页/共47页//EX5_6.cpp:演示常数据成员#include<iostream.h>classA{private:

constintx; //常数据成员x

staticconstinty; //静态常数据成员ypublic:

constint&r; //常引用rA(inti):x(i),r(x){} //x和r用初始化列表获得初值

voidfun() {cout<<"x="<<x<<",y="<<y<<",r="<<r<<endl;}};constintA::y=5; //y的初始化在类外进行第29页/共47页voidmain(){Aobj1(1),obj2(2);obj1.fun();obj2.fun();}程序运行结果为：x=1,y=5,r=1x=2,y=5,r=2第30页/共47页

大型程序通常由多个文件组成一个项目（Project），理由是：1.将相关类和函数放在一个特定的文件中，对不同的文件进行单独编写、编译，最后再链接，避免重复劳动，提高工作效益。2.便于团队开发。按逻辑功能将程序分解成多个源文件，使程序容易管理，便于程序员的任务安排。大型程序基本上由三个部分构成：类的声明：通常做成.h文件（HeaderFiles）类成员的实现：通常做成.cpp文件（SourceFiles）主函数：通常做成.cpp文件（SourceFiles）5.1.5多文件结构第31页/共47页5.2动态内存分配5.2.1new运算符

new运算符用于动态分配一块内存空间。使用形式为：

指针变量=new<数据类型>[长度]例如分配一个可以容纳256个char型数据的空间:

char*Cbuffer=newchar[256];

使用new运算符时，需要注意：(1)如果分配的空间长度为1个单位，则可以省略[]和其中的整数，例如：

float*pNum=newfloat;与

float*pNum=newfloat[1];等价。第32页/共47页(2)使用new运算符分配内存空间时，其空间长度可以是变量，也可以是数值表达式，例如分配一个可以容纳10个int型数据的空间：

intnSize=5; int*nPInt=newint[nSize+5];

(3)由new分配的内存空间是连续的，可以通过指针的变化访问所分配空间的每一个元素，例如：

int*nPInt=newint[10]; nPInt[5]=100;

或 *(nPInt+5)=100;(4)如果当前存储器无足够的内存空间可分配，则new运算符返回0(NULL)。第33页/共47页

由new运算符分配的内存空间在使用完毕后应该使用delete运算符释放。delete运算符的使用有两种形式:

delete指针或

delete[]指针例如：int*pInt=newint; deletepInt; int*pManyInt=newint[10]; delete[]pManyInt;使用delete运算符时，需要注意：(1)用new运算符获得的内存空间，只许使用一次delete，不允许多次对同一块空间进行多次释放，否则将会产生严重错误。(2)delete只能用来释放由new运算符分配的动态内存空间，不得使用delete运算符去释放程序中的变量、数组的存储空间。5.2.2delete运算符第34页/共47页1．链表概述 链表是一种动态数据结构，它的特点是用一组任意的存储单元(可以是连续的，也可以是不连续的)存放数据元素。一个简单的链表具有下图所示的结构形式。5.2.3动态内存分配的应用实例

定义单链表结构的最简单形式为:

structNode

{intdata;Node*next;

};第35页/共47页

定义一个链表类List，其中包含链表结点的插入、删除、访问等功能的成员函数，以便对链表进行操作。classList{Node*head; //声明一个链表结构指针

public:List(){head=NULL;} voidInsertList(intaData,intbData);//链表结点的插入

voidDeleteList(intaData); //链表结点的删除

voidOutputList(); //链表结点的访问

Node*Gethead(){returnhead;}};第36页/共47页voidList::OutputList() //链表结点的访问{Node*current=head; //建立链表头指针

while(current!=NULL) //如果链表存在，

{cout<<current->data<<“”; //显示链表结点的数据

current=current->next; //指向下一个结点

}cout<<endl;}3．链表结点的插入 如果要将新结点b插入到链表的结点a之前，则需要考虑下列几种情况:2．链表结点的访问第37页/共47页(1)插入前链表是一个空表，插入新结点b后，链表如图(a)所示。(2)若a是链表的第一个结点，插入新结点b后成为第一个结点，如图

(b)所示。(3)若a不是链表的第一个结点，则要先找出a的上一个结点ak，然后新结点b插到结点ak

与a之间，如图(c)所示。(4)若链表中不存在a，则新结点b插在最后，如图

(d)所示。

第38页/共47页//设aData是结点a中的数据，bData是新结点b中的数据voidList::InsertList(intaData,intbData){Node*p,*q,*s;s=(Node*)newNode;//动态分配一个新结点存储区

s->data=bData; //将新结点b的数据放入新存储区

p=head; //结点指针p指向链表头

if(head==NULL) //若是空表，

{ head=s; //将新存储区的地址赋给表头，即使

s->next=NULL; //新结点b作为第一个结点

} else //若不是空表

if(p->data==aData)

//若a是第一个结点

{

head=s;

//使新结点b作为第一个结点

s->next=p;

//将结点a接到新结点b的后面

}第39页/共47页

else //若a不是第一个结点

{

while(p->data!=aData&&p->next!=NULL)//找结点a { q=p; //使q指向p所指的结点

p=p->next; //

p本身指向下一个结点

}

if(p->data==aData) //若有结点a，则q指向的是ak { q->next=s; //将新结点b插入结点ak之后

s->next=p; //将结点a排在新结点b之后

}else //若没有结点a { p->next=s; //将新结点b排在链表末尾，即

s->next=NULL; //将新存储区排在链表末尾。

}

}}第40页/共47页

要在链表中删除结点a，并释放被删除的结点所占的存储空间，需要考虑下列几种情况:(1)若要删除的结点a是第一个结点，则把head指向a的下一个结点，如图

(a)所示。(2)若要删除的结点a不是第一个结点，则应使a的上一结点ak-1的指针域指向a的下一个结点ak+1，如图

(b)所示。(3)若空表或要删除的结点a不存在，则不作任何改变。4．链表结点的删除第41页/共47页//设aData是要被删除结点a中的数据成员voidList::DeleteList(intaData){Node*p,*q;p=head;if(p==NULL)return; //若p为空，则返回

if(p->data==aData) //若a是第一个结点

{head=p->next; //链表头指向下一个结点

deletep; //删除结点a

}

else //若a不是第一个结点

{第42页/共47页

while(p->data!=aData&&p->next!=NULL)//找结点a

{q=p; //使q指向p所指的结点

p=p->next; //

p本身指向下一个结点

}

if(p->data==a