计算机程序设计

计算机程序设计2013.1C++语言概述——面向对象的程序设计语言

C++支持数据封装

C++类中包含私有、公有和保护成员

C++通过发送消息来处理对象

C++中允许友元破坏封装性

C++允许函数名和运算符重载

C++支持继承性

C++支持动态联编在C++中，结构可作为一种特殊的类，它虽然可以包含函数，但它没有私有或保护的成员。在C++中，类是支持数据封装的工具，对象则是数据封装的实现。类是类型，是对象的抽象，对象是类的具体实例。一个类可以有多个对象，每个对象都有自己的存储单元，而类不占存储单元。C++中类是数据和函数的封装体，它提供一种数据访问严格控制的机制，数据被隐藏在封装体中，该封装体通过操作接口与外界交换信息。送到一个对象的所有可能的消息都需要在对象的类描述中加以定义，即对每个可能的消息给出一个相应的办法。方法是在类中使用函数来定义的，使用一种类似于函数调用的机制把消息发送到一个对象上。友元可以是在类外定义的函数，也可以是在类外定义的整个类。友元可以访问类的私有成员。C++中可以通过定义虚函数来支持动态联编。面向对象的程序设计的（四）三大特征： （抽象）、封装、继承、多态。C++与C语言的关系：C语言是C++的一个子集，C++包含了C语言的全部内容。

C++保持与C语言的兼容

C++对C语言作了很多改进

C++与C语言的本质差别在于C++是面向对象的，而C语言是面向过程的。(1)增加了一些新的运算符，如::,new,delete,->*等；(2)改进了类型系统，增加了安全性；(3)引进了引用的概念，使用引用作函数参数带来了很大方便；(4)允许函数重载，允许设置缺省参数，提高了编程的灵活性；(5)引进内联函数，提高了程序效率；(6)可根据需要随时对变量进行说明。面向过程的程序设计将数据和对数据的操作分离，程序是由一个个的函数组成的，面向对象的程序设计将数据和操作封装在一起，程序是由一个个对象组成的，对象之间通过接口进行通信，它能够较好地支持程序代码的复用。C++数据操作基础2.1C++程序进行输入和输出的操作方法

#include<iostream.h>

intmain(){

intx,y;//定义两个整型变量

cin>>x>>y;//键盘输入变量值

cout<<“x=”<<x<<endl<<“y=”<<y<<endl;//按格式屏幕

return0; 输出变量值}cin是一个代表标准输入设备(一般代表键盘设备)的对象，

cout是一个代表标准输出设备(一般代表显示设备)的对象，它们都是C++系统预定义的对象。它们以及输入操作符“>>”和输出操作符“<<”都在头文件

iostream.h中被声明。2.2控制结构 顺序、分支（条件）、循环、转移2.2.1条件语句

if语句

if…else语句

if…elseif语句

？条件操作符

switch语句if(条件表达式){语句序列}if(条件表达式){语句序列1}else{语句序列2}if(条件表达式1){

语句序列1}elseif(条件表达式2){语句序列2}elseif(条件表达式3){语句序列3}else{语句序列4}if（条件表达式1）{

if（条件表达式2） { 语句序列1 }

else { 语句序列2 }}//未避免嵌套出现二义性，C++规定else子句总与其之前最近且尚未配对的if语句配对。？是一个三元操作符，被称为条件操作符。使用语法是：

表达式1？表达式2:表达式3

等价于：

if(表达式1)

表达式2；

else

表达式3；例：result=(a>=0)?a:-a

注意：表达式1、2、3的数据类型不能是void

类型。switch(变量名){

case值1:语句序列1；

break;

case值2:语句序列2；

break;……

default:语句序列n；}2.2.2循环语句

for

循环：for(exp1;exp2;exp3){statement;….}while

循环：while(expression){……}do…while

循环：do{statement;…...}while(expression);三种循环都可以嵌套。

for(exp1;exp2;exp3){statement;….}等价于：

exp1;while(exp2){statement;……exp3;}例： intsum=0; for(intI=1;I<=10;I++)sum+=I;2.2.3转移语句

break

语句： 强制退出循环及中断case语句，直接 执行循环体后的语句。 continue语句：不完全退出循环，而是使循环重 新回到测试位置，并忽略此语句至循环结束前 的语句序列。 goto语句：无条件转移，只限在同一程序段内转换， 不能跳到另一函数或程序内。2.3数组、字符串和指针2.3.1数组1.数组对象声明

数据类型标识符[常量表达式]2.说明

(1)

数组中的每个元素具有相同数据类型；

inta[5];

(2)

访问数组元素时，使用下标值指明，第一个元素 下标值为0；

a[2]=12;

(3)

数组内各元素在内存中连续存放；(4)数组在声明的同时可以赋初值，初值个数小于等于数组元素个数，若小于，未提供初值的元素使用缺省值初始化；若等于，数组长度可以不指定。

inta[5]={1,2};floatb[]={1.0,2.5,3.2,4.9};(5)

多维数组的每一维大小都用[]单独括起，赋初值时按行赋给，初值个数同样小于等于每一维的元素个数。

例：inta[][3]={{2,3,4},{3,4,5},{1}}；

intb[3][2]={{0,1},{2}}；

intc[2][]={{1,2},{2,3},{3,4}}；//error只有外层数组的元素个数可以省略(6)

使用sizeof

函数求数组元素个数

inta[5]={2,3,5};floatb[][3]={{1.,2.,3.},{2,3}};intaNum=sizeof(a)/sizeof(int);intbNum=sizeof(b)/sizeof(float[3]);3.使用数组时的注意事项

(1)两个数组对象之间不能相互赋值；

inta[5],b[5];a=b;//error

(2)数组类型的操作数不能作为左值使用；

a++;//error

(3)

数组不能作为参数在函数之间进行参数传递，只能通过向函数传递指向数组对象的第一个元素对象的指针来达到传递数组的效果。例：voidf(int*p,intn){

while

(n-->0)cout<<*p++<<endl;}intmain(){inta[]={1,2,3,4,5};f(a,sizeof(a)/sizeof(int));

return0;}(4)

C++运行系统不能对数组访问的越界问题(下标值不正确)进行检查。2.3.2字符串与字符数组的关系：字符串是由一串字符组成的数组，但字符串的末尾一定是“\0”，而字符数组则不一定。与字符串有关的标准函数：

gets,puts fgets,fputs sprintf strcpy(str1,str2)strcat(str1,str2) strcmp(str1,str2)strlen(str)2.3.3指针

1.

定义：包含另一变量内存地址的变量。

3.

指针与数组的关系

数组是指针的另一种表示法。数组的名字实际就是数组的起始地址。 intarr[2]={0,1}; arr[1]和*(arr+1)是完全一致的。2.

声明

指针在使用前需进行声明，声明格式为：数据类型*变量；或数据类型*变量；4.对指针值的操作例：#include<iostream.h>intmain(){inta[]={1,2,3,4,5};int*IntPtr(&a[0]);int*Endofa(&a[4]);

while

(IntPtr<=Endofa) {cout<<*IntPtr++<<endl;}

return0;}(1)可以对指针值进行算术和关系操作；(2)只能在同类型的指针值之间进行关系比较操作，而且被比较的两个指针值指向同一数组对象的元素对象；(3)一个指针值可以与整数

0

进行相等或不等关系操作5.

“&”与“*”“&”是一个一元操作符，它操作一个对象，得到该对象的存储单元的地址值；

例：inti;int*p;p=&i;*p=*p+5;说明：“&”后必须跟左值表达式，而由“*”与其后的指针表达式形成的整个表达式也是左值表达式。左值表达式指程序中表达一个对象标识(对象引用)的表达式，因它可以放在赋值操作符的左边而得名。详细内容参见参考书[2]p164~165。“*”也是一个一元操作符，用于表达被指针指向的对象。6.new与delete

new

用于为指针分配内存空间；delete用于释放指针所占有的内存空间。

例：int*p;p=newint;//……deletep;两种内存分配方式：堆栈分配和堆内空间分配。标准C用malloc和free函数在堆内分配内存块和释放内存块。(2)当表达式中出现一个数组类型的操作数时，这个操作数被自动地强制为指向该操作数所标识的数组对象的第一个元素对象的指针值。下面两个赋值表达式是等价的：

inta[]={1,2,3};int*p;

p=a;p=&a[0];7.使用指针时的注意事项(1)在程序中注意保持指针值的确定性，避免出现悬空指针。因此在声明一个指针时，应立即对它进行初始化或赋初值；2.4函数2.4.1函数定义

函数是由功能相关的语句序列所组成的独立模块，是结构化程序的基本结构。函数类型函数名{数据类型参数1，………}{

函数体（语句序列）

}说明：函数类型指的是函数的返回值类型；若未设置函数类型，系统会自动将其假设为整数类型；若不希望函数返回任何值，就将函数类型设置为

void。2.4.2函数调用

当一个函数定义有形参时，在进行函数调用时，必须提供与形参个数、类型相同的实参。在C++中，有两种参数传递机制将实参的值传递给形参：值传递(值调用)和引用传递(引用调用)。1.值传递

在这种机制中，实参的值被拷贝到由相应形参名字所标识的对象中。在函数内部对形参的访问或更新都是是对这个对象的访问或更新。实参本身的值在调用前后和调用过程中都不发生变化。intdouble(inta){a*=2;cout<<“a=“<<a<<endl;returna;}#include<iostream.h>voidmain(){intb=10;double(b);cout<<“b=“<<b;}运行结果：

a=20b=102.引用传递

若希望通过函数调用改变实参的值，就必须采用引用传递机制。关于引用的具体含义及使用要点将在3.7节中讲解。2.4.3函数的其他特性1.缺省参数

函数声明时可以为一个或多个参数指定缺省参数值。 voiddelay(intx,inty=100);

当进行函数调用时，编译器按从左至右的顺序将实参与形参结合，若未指定足够的实参，则编译器按同样的顺序用函数声明中的缺省值来补足所缺少的实参。

delay(5);

等价于

delay(5,100);

若函数有多个参数，那么所有指定了缺省值的参数必须排在参数序列的最右边。

voidf(intx,inty=0,intz);//errorf(2,4);

2.递归函数

在函数内部直接或间接地调用函数本身，称为递归调用。递归调用要注意设置出口，避免死循环。当重载的函数带有缺省参数时，必须注意避免错误声明。

voidf(intx,inty=0);voidf(intx);//errorf(5);2.4.4函数重载

在C++中，允许两个或两个以上的函数采用相同的名字，只要使用不同类型、不同数目的参数或不同的返回值，编译器便知道在什么情况下该调用哪个函数，这就叫函数重载。例：intdoubleFun(intii){

return(2*ii);}

floatdoubleFun(floatff){

return(2*ff);}main(){intaa=1;floatbb=2.0;intisum;floatfsum;isun=doubleFun(aa);fsum=doubleFun(bb);}intdoubleFun(intii){

return(2*ii);}floatdoubleFun(int

ii){

return(2.0*ii);}注意：函数的返回类型不足以区分两个重载函数。类与对象

主要内容：

类的成员构造函数与析构函数；内联成员函数；静态数据成员和成员函数类和对象的定义this指针，const关键字友元函数引用3.1类的定义

类是对一组客观对象的抽象，它将该组对象所具有的共同特征（包括结构特征和行为特征）集中起来，以说明该组对象的能力和性质。类（class）是一种用户自定义的数据类型。

class

类名称

{ typevars; memberfunctions;

public: typevars; memberfunctions; }；classCPerson{ charname;public: intage; floatheight; voidPrintAge(); voidPrintHeight();};注意：1.类名称一般以“C”开头，以区别于其他标识符。如

classCPen {……}2.定义类，除了给出操作名和数据结构外，还必须给出各个成员函数的实现。

CPen::MemberFunction（……）

{……}

由于不同的类允许有相同名称的成员函数，因此，在类外定义成员函数的实现时，必须在成员函数名前加上所属类名和作用域操作符“::”。3.类中的数据(又称数据成员)和函数(又称成员函数)分为三种类型，分别由三种访问控制修饰符public,private,protected

加以修饰。public:指定其后的成员是公有的。它们是类与外部 的接口，任何外部函数都可以访问公有数据 成员和成员函数。 这三种修饰符在类中可以任何次序出现，用于修饰在它们之后列出的成员名字能被程序的其它部分访问的权限。private:这一部分称为私有部分。若省略关键字 private，则必须紧跟在类名称后声明。类中的数据和函数若不特别声明，都被视为私有类型。 这种类型的数据只允许类本身声明的成员函数对其进行存取。classCPerson{ charname;public: intage; floatheight; voidPrintAge(); voidPrintHeight();};3.2对象的定义

对象是类的实例。对象可以在声明类时直接定义，也可以在声明类之后单独定义。

class

CPerson {……}zhang;

或 classCPerson {……}; CPenzhang

;protected：保护类型，这种类型的数据也只能被类本 身的成员函数访问，可以被派生类继承。通过对象可以访问类中的公有类型数据和成员函数，其使用方式为：对象名.成员函数名对象名.数据成员例：zhang.age=20;zhang.PrintAge();=“zhanglei“;//error通过指向类类型对象的指针访问类的公有数据成员和成员函数时，其使用方式为： 指针名->数据成员 指针名->成员函数例：CPerson*pWang;pWang->age=30;pWang->PrintAge();类和对象的关系就如同整型int与整型变量i之间的关系。3.3类的成员3.3.1构造函数构造函数是一个特殊的类成员函数，用于初始化类变量或分配内存空间。当用类定义一个对象时，自动调用构造函数，使对象保持一个确定的状态。1.构造函数的声明

classCExample { intI; public:

CExample(); …… }；2.构造函数的特点

(1)构造函数与类必须具有相同的名字。例：classCExample{CExample();CExample(inti);CExample(intx,inty);

private:intmember1,member2;};

(2)创建对象时自动执行构造函数，构造函数不能在程序中被显式调用。(3)构造函数不需要函数类型，不能被继承。(4)构造函数可以接受参数并能够重载。CExample::CExample(inti){member1=i;member2=0;}intmain(){CExampleex1;CExampleex2(1);CExampleex3(2,3);……}CExample::CExample(){member1=0;member2=0;}CExample::CExample(intx,inty){member1=x;member2=y;}(5)构造函数除可以用基本数据类型初始化对象外，还可以使用已存在的同类型的对象即类类型的对象来初始化正在创建的对象。为此，必须在类中定义一个特殊的构造函数来完成这个工作，这个构造函数被称为拷贝初始化构造函数。例：classCMyClass{

public:CMyClass(intx=0);CMyClass(CMyClass&c);//……

private:intmember;}；CMyClass::CMyClass(intx){member=x;}CMyClass::CMyClass(CMyClass&c){member=c.member;}注意：一是拷贝初始化构造函数必须使用引用参数；二是以值调用方式向一个函数传递参数时，拷 贝初始化函数也被调用。例：voidfun(CMyClassa); intmain() {CMyClassmy(5);fun(my);//…… }

(6)若程序没有为一个类定义任何构造函数，则编译器生成一个不带参数的公有构造函数，这个构造函数什么也不做，称为缺省构造函数。例：CExample::CExample { }3.3.2析构函数

析构函数与构造函数功能相反，也是类成员函数，通常用于释放已分配的内存空间或完成对象被清除前的一些清理工作。

classCExample {

public: CExample(); voidPrint(); ~CExample(); …… };析构函数的特点：1.与构造函数具有相同的名字，前面必须加上“~”符号。2.析构函数没有函数类型，不能被继承。3.3.3内联成员函数成员函数的定义方法：体内定义和体外定义。在类中定义的函数称为内联函数。类外定义的函数缺省情况下都是非内联函数。用关键字inline

可以强制转换。3.析构函数不能带有参数，而且不可以重载。4.析构函数在

结束时被自动调用。(参考书[2]6.4)classCRectangle{floatheight,width;public:voidSetHeight(floatx){height=x};voidSetWidth(floaty);voidPrintHeightAndWidth();}; voidinlineCRectangle::SetWidth(floaty){width=y}对于内联成员函数，编译时在所有调用该函数的地方将装入实际的函数代码。内联成员函数的声明必须出现在对它的每个调用之前。voidCRectangle::PrintHeightAndWidth(){cout<<“height=“<<height<<endl;cout<<“width=“<<width<<endl;}3.3.4带缺省参数的成员函数类似于一般函数，在类中声明成员函数时，可以为成员函数的参数指定缺省参数值。classCRectangle{CRectangle(intWidth=10,intHeight=5);//……};3.3.5对象与成员函数成员函数的参数和返回值不仅可以是整型、字符型、指针类型等，也可以把对象作为参数和返回值。classCPoint{floatx,y;public:CPoint(floata,floatb);CPointAdd(CPointA); ……}CPoint::CPoint(floata,floatb){ x=a; y=b;}CPointCPoint::Add(CPointA){ CPointB; B.x=x+A.x; B.y=y+A.y; returnB;}3.3.6静态数据成员和成员函数1.问题的提出

欲在几个函数之间实现数据共享，比较可取的方法有两种：

一是将数据存储在局部变量中，通过参数传递机制在各个函数之间共享；

二是将这些函数和数据封装在一个类中，通过建立该类的对象，使这些函数操作该类的数据成员达到共享的目的。第二种方法应作为首选，其次考虑参数传递，最后还可以考虑使用全局对象。若要在同一个类的多个对象之间共享数据该怎么办？2.静态数据成员

classCTest {

public:

static

intcount; }；

intCTest::count=0;

特点：1)用关键字static声明2)该数据成员只有一个拷贝被类的所有对象维护。3)必须在类中声明，且作用域也仅限于所属的类。4)必须象全局变量一样，在类外定义和初始化。5)程序的其它部分对静态数据成员的访问同样受它在类中声明的访问控制的限制。classCTest{

public:

static

intcount;voidSet(intw);voidDisplay();}；voidmain(){CTesta,b;a.Set(10);cout<<“Operatingona:”;a.Display();b.Set(10);cout<<“Operatingonb:”;b.Display();cout<<“Operatingona:”;a.Display();return;}运行结果：Operatingona:count=10Operatingonb:count=20Operatingona:count=20intCTest::count=0;voidCTest::Set(intw){count+=w;}voidCTest::Display(){

cout<<“count=“<<count<<endl;}#include

<iostream.h>3.静态成员函数当一个函数只存取静态数据成员时，这个函数应声明为静态成员函数。

#include

<iostream.h>classCTest{

public:

static

intcount;voidSet(intw);

staticvoidDisplay();}；intCTest::count=0;voidCTest::Set(intw){count+=w;}voidCTest::Display(){

cout<<“count=“<<count<<endl;}voidmain(){CTesta,b;a.Set(10);cout<<“Operatingona:”;

CTest::Display();b.Set(10);cout<<“Operatingonb:”;

CTest::Display();}特点：1)类外代码可以通过类名和作用域操作符来调用 静态成员函数，无需引用类的实例(对象)，甚至 类的实例(对象)可以不存在。3.3.7成员函数重载

除析构函数外，所有成员函数都可以被重载，只要它们满足重载函数时的要求。2)静态成员函数不能直接引用该类的非静态数据成员或非静态成员函数。因为静态成员函数没有this指针来存放对象的地址。必须使用 对象名.成员名这种表达式来引用非静态成员。3.4this指针1.问题的提出

当一个类的多个对象引用同一个成员函数时，系统如何确定该引用哪个对象的数据成员？2.this指针的特点

每个成员函数（静态成员函数除外）都有一个this指针变量。

this是一个隐含的指针。

this用于指向以该成员函数所属类定义的对象。当某个对象调用成员函数时，成员函数的this指针便指向该对象。因此，当不同的对象引用同一个成员函数时，编译器就依据成员函数this指针指向的不同对象来确定引用哪一个对象的数据成员。

this关键字只能在成员函数内使用，并且不能被更新。在类X的成员函数中，this指针的类型为X*const

。3.5const关键字3.5.2

const的特点及使用注意事项3.5.1声明语法

const是一个类型修饰符，语法是：

Tconst

其中，T是一个类型表达式。const与T之间的关系是左结合的。1.使用const声明的对象不能被更新。2.由于这种对象不能被更新，因此必须进行初始化。

intconsta=2;a=1; //error5.在参数传递时，一个T*类型的对象可以用于const

T*类型的对象可以使用的场合，T&可以用于const

T&可以使用的场合，但反之不成立。3.const

常被用于声明函数的形参。指针类型或引用类型的形参使函数可以更新调用者中的对象，但若函数并不更新指针所指向的对象或引用所引用的对象，那么最好将这样的参数使用const关键字进行声明。4.当T是一个简单的类型名时，习惯上写作constT。例：constintx=0;类型适应：一种类型的对象可以用于另一种对象可以使用的场合。7.在类X中声明的const成员函数的this指针类型为：

constX*const8.由于const是函数类型的一个组成部分，因此可被用于参与函数重载的区分。

voidPrint()const;//类的常成员函数

voidPrint();6.对于类中不更新对象的数据成员的成员函数，可以将其使用const进行声明。当一个成员函数使用const进行声明后，就表明这个函数可以操作常对象。没有使用const关键字进行声明的成员函数则不能操作常对象。9.由于const对象必须初始化且不能被更新，因此，当类中声明了const数据成员时，只能通过成员初始化列表来构造该数据成员。例：classCExample{

public:CExample(intx);

private:

constinta;};CExample::CExample (intx):a(x){};

在类中声明静态的const数据成员时，classA{

private:

static

constintSIZE;}constintA::SIZE=10;3.6友元函数3.6.1定义

友元函数是一种特殊的函数，它不是类的成员函数，但允许它访问类的私有类型数据和保护类型数据。3.6.2声明方式

class

类名称 //相关的类

{ typevars; ……

public:

friend

函数类型函数名称(); //声明友元

…… }

friend

函数类型函数名称() //定义友元

{……}3.6.3特点1.友元可以是一个一般的函数(友元函数)，也可以是另一个类的成员函数(友元成员)，还可以是整个的一个类(友元类，这时类中的所有成员函数都是友元函数)。2.友元函数须在私有成员可被它访问的类中声明，而函数体则在类外声明。3.友元函数虽然在类中声明，但它不是该类的成员函数，而是独立于任何类的一般的外界函数，它被允许访问该类的所有对象的私有成员。4.C++中使用友元是为了提高程序的运行效率。但为了确保数据的完整性及数据封装与隐藏的原则，应尽可能不使用或少使用友元函数。3.7引用引用是给对象取一个别名，它引入了对象的一个同义词。error3.7.1定义

定义引用的关键字：T&

例：inti; int&j;int&j=i; j=i;j=6;注意：

(1)引用不产生对象的副本，而是对象的同义词，它们表示同一个对象。