C、C++语言全部关键字解释

C/C++语言全部关键字解释

C语言32个关键字解释

C语言的关键字共有32个，根据关键字的作用，可分其为数据类型

关键字、控制语句关键字、存储类型关键字和其它关键字四类。

1数据类型关键字(12个)：

(1)char：声明字符型变量或函数

(2)double：声明双精度变量或函数

(3)enum：声明枚举类型

(4)float：声明浮点型变量或函数

(5)int：声明整型变量或函数

(6)long：声明长整型变量或函数

(7)short：声明短整型变量或函数

(8)signed：声明有符号类型变量或函数

(9)struct：声明结构体变量或函数

(10)union：声明联合数据类型

(11)unsigned：声明无符号类型变量或函数

(12)void：声明函数无返回值或无参数，声明无类型指针(基本上

就这三个作用)

(2)控制语句关键字(12个)：

A循环语句

(1)for：一种循环语句(可意会不可言传)

(2)do：循环语句的循环体

(3)while：循环语句的循环条件

(4)break：跳出当前循环

(5)continue：结束当前循环，开始下一轮循环

B条件语句

(Dif：条件语句

(2)else：条件语句否定分支(与if连用)

(3)goto：无条件跳转语句

C开关语句

(1)switch:用于开关语句

(2)case：开关语句分支

(3)default：开关语句中的“其他”分支

Dreturn：子程序返回语句(可以带参数，也看不带参数)

3存储类型关键字(4个)

(Dauto：声明自动变量一般不使用

(2)extern：声明变量是在其他文件正声明(也可以看做是引用变量)

(3)register：声明积存器变量

(4)static：声明静态变量

4其它关键字(4个)：

(1)const：声明只读变量(

2)sizeof：计算数据类型长度

(3)typedef：用以给数据类型取别名(当然还有其他作用

(4)volatile：说明变量在程序执行中可被隐含地改变

char8

int16

long32

float32

double64

这是占的位数bit

1Byte=8bit

除以8就是字节数byte

C语言32个关键字解释（［color=Teal］C语言小知识：［/color］）

auto：声明自动变量一般不使用

double：声明双精度变量或函数

int：声明整型变量或函数

struct：声明结构体变量或函数

break：跳出当前循环

else：条件语句否定分支（与if连用）

long：声明长整型变量或函数

switch:用于开关语句

case：开关语句分支

enum：声明枚举类型

register：声明积存器变量

typedef：用以给数据类型取别名（当然还有其他作用）

char：声明字符型变量或函数

extern：声明变量是在其他文件正声明（也可以看做是引用变量）

return：子程序返回语句（可以带参数，也看不带参数）

union：声明联合数据类型

const：声明只读变量

float：声明浮点型变量或函数

short:声明短整型变量或函数

unsigned：声明无符号类型变量或函数

continue：结束当前循环，开始下一轮循环

for：一种循环语句（可意会不可言传）

signed：生命有符号类型变量或函数

void：声明函数无返回值或无参数，声明无类型指针（基本上就这

三个作用）

default：开关语句中的“其他”分支

goto：无条件跳转语句

sizeof：计算数据类型长度

volatile：说明变量在程序执行中可被隐含地改变

do：循环语句的循环体

while：循环语句的循环条件

static：声明静态变量

if:条件语句

C++全部关键字说明

(l)auto

这个这个关键字用于声明变量的生存期为自动，即将不在任

何类、结构、枚举、联合和函数中定义的变量视为全局变量，而在函

数中定义的变量视为局部变量。这个关键字不怎么多写，因为所有的

变量默认就是auto的。

(2)register

这个关键字命令编译器尽可能的将变量存在CPU内部寄存器

中而不是通过内存寻址访问以提高效率。

(3)static

常见的两种用途：

1》统计函数被调用的次数；

2》减少局部数组建立和赋值的开销.变量的建立和赋值是需要一定的

处理器开销的，特别是数组等含有较多元素的存储类型。在一些含有

较多的变量并且被经常调用的函数中，可以将一些数组声明为

static类型，以减少建立或者初始化这些变量的开销.

详细说明：

1＞、变量会被放在程序的全局存储区中，这样可以在下一次调用的时

候还可以保持原来的赋值。这一点是它与堆栈变量和堆变量的区别。

2＞、变量用static告知编译器，自己仅仅在变量的作用范围内可见。

这一点是它与全局变量的区别。

3＞当static用来修饰全局变量时，它就改变了全局变量的作用域，

使其不能被别的程序extern,限制在了当前文件里，但是没有改变

其存放位置，还是在全局静态储存区。

使用注意：

1＞若全局变量仅在单个C文件中访问，则可以将这个变量修改为静态

全局变量，以降低模块间的耦合度；

2》若全局变量仅由单个函数访问，则可以将这个变量改为该函数的静

态局部变量，以降低模块间的耦合度；

3》设计和使用访问动态全局变量、静态全局变量、静态局部变量的函

数时，需要考虑重入问题(只要输入数据相同就应产生相同的输出)

(4)const被const修饰的东西都受到强制保护，可以预防意外的

变动，能提高程序的健壮性。它可以修饰函数的参数、返回值，甚至

函数的定义体。

作用：

1》修饰输入参数

a.对于非内部数据类型的输入参数，应该将“值传递”的方式改为

"const引用传递”,目的是提高效率。例如将voidFunc(Aa)改

为voidFunc(constA&a)。

b.对于内部数据类型的输入参数，不要将“值传递”的方式改为

“const引用传递”。否则既达不到提高效率的目的，又降低了函数

的可理解性。例如voidFunc(intx)不应该改为voidFunc(const

int&x)o

2＞用const修饰函数的返回值

a.如果给以“指针传递”方式的函数返回值加const修饰那么函数

返回值(即指针)的内容不能被修改，该返回值只能被赋给加const

修饰的同类型指针。

如对于：constchar*GetString(void);

如下语句将出现编译错误：

char*str=GetString();//cannotconvertfrom'constchar*'

to'char*'；

正确的用法是：

constchar*str=GetString();

b.如果函数返回值采用“值传递方式”，由于函数会把返回值复制到

外部临时的存储单元中，加const修饰没有任何价值。如不要把函

数intGetlnt(void)写成constintGetlnt(void)o

3>const成员函数的声明中，const关键字只能放在函数声明的尾部,

表示该类成员不修改对象.

说明：

consttypem;〃修饰m为不可改变

示例：

typedefchar*pStr;〃新的类型pStr;

charstring[4]="abc";

constchar*pl=string；

pl++；〃正确，上边修饰的是*pl,pl可变

constpStrp2=string;

p2++;〃错误，上边修饰的是p2,p2不可变,*p2可变

同理，const修饰指针时用此原则判断就不会混淆了。

constint*value;〃*value不可变，value可

变

int*constvalue;〃value不可变，*value可变

const(int*)value;//(int*)是一种type,value不可变,*value

可变

〃逻辑上这样理解，编译不能通过，需要tydefint*NewType;

constint*constvalue;〃*value,value都不可变

(5)volatile

表明某个变量的值可能在外部被改变，优化器在用到这个变

量时必须每次都小心地重新读取这个变量的值而不是使用保存在寄

存器里的备份。它可以适用于基础类型如：int,char,long.....也

适用于C的结构和C++的类。当对结构或者类对象使用volatile修

饰的时候，结构或者类的所有成员都会被视为volatile.

该关键字在多线程环境下经常使用，因为在编写多线程的程序时，同

一个变量可能被多个线程修改，而程序通过该变量同步各个线程。

简单示例：

DWORD_stdcallthreadFunc(LPVOIDsignal)

int*intSignal=reinterpret_cast(signal);

*intSignal=2;

while(*intSignal!=1)

sleep(1000);

return0;

)

该线程启动时将intSignal置为2然后循环等待直到intSignal为

1时退出。显然intSignal的值必须在外部被改变，否则该线程不会

退出。但是实际运行的时候该线程却不会退出，即使在外部将它的值

改为L看一下对应的伪汇编代码就明白了：

movax,signal

label:

if(ax!=l)

gotolabel

对于C编译器来说，它并不知道这个值会被其他线程修改。自然就把

它cache在寄存器里面。C编译器是没有线程概念的,这时候就需要

用到volatile。volatile的本意是指：这个值可能会在当前线程外

部被改变。也就是说，我们要在threadFunc中的intSignal前面加

上volatile关键字，这时候编译器知道该变量的值会在外部改变，

因此每次访问该变量时会重新读取，所作的循环变为如下面伪码所

示：

label:

movax,signal

if(ax!=l)

gotolabel

注意：一个参数既可以是const同时是volatile,是

volatile因为它可能被意想不到地改变。它是const因为程序不应

该试图去修改它。

(6)externextern意为"外来的”•,•它的作用在于告诉编译

器：有这个变量，它可能不存在当前的文件中，但它肯定要存在于工

程中的某一个源文件中或者一个D11的输出中。C++关键字(不同于

c的关键字)

1.C++包含的类型：

booltruefalse

2.类型声明所用到的关键字

class

public

private

protected

friend

mutable

explicit

this

3.虚拟与多态以及rtti

virtual

typeidO

static_cast<>()

dynamic_cast<>()

reinterpret_cast<>()

4.泛型编程相关

templateO

typename

5.全局函数和成员函数相关

inline

6.堆管理

new

delete

7.异常处理

try{}

catch(){}

throw()

［编辑本段］电脑语言用语

关键字是用来标识文件中各个记录的特定数据项目的值。

关键字是电脑语言里事先定义的,有特别意义的标识符，有

时又叫保留字。系统定义了以下关键字：

Const(常数)Dim(定义)As(为)Mod(取模)

And（并且）Or（或者）Not（非）

If（如果）Then（那么）Else（否则）

Stop（停止）End（结束）

Select（选择）Case（条件）Is（是）

For（计数）To（到）Step（步长）

Byref（传址）Byval（传值）

Sub（子程序）Function（函数）Exit（退出）

Do（做）Loop（循环）Until（除非）While（当）Wend（当结束）

Let（让）Call（调用）

Rem（注释）

Integer（整数）Long（长整数）Single（单精度小数）

Double（双精度,小数）Boolean（布尔）String（字符串，文字）

Me（我）Private（私有）Public（公共）

注意：vb里名称与关键字不区分字母的大小写；在c语言

里，一切都是小写字母

C,C++,java语言关键字调查统计：

C,C++,JAVA

共有的关键字—22个

intcharfloatdoubleshortlong

ifelse

switchcasedefault

forwhiledo

voidreturn

continuebreak

constgoto（JAVA中未用，但是保留字）

volatilestatic

C和C++

共有的关键字（除三者共有）一一10个

unsignedsigned

structenumunion

autoregisterextern

sizeoftypedef

C++和JAVA共有的关键字—11个（9个）

classnewpublicprivateprotectedthistrythrowcatch

（truefalse）

C+啸有的关键字（除JAVA和其共有的）一一20个

asmboolexplicitexportfriendinlinemutable

operatortemplate

typeidvirtualwarch_tdeletenamespacetypenameusing

const_castdynamic_castreinterpret_caststatic_cast

JAVA特有的关键字（除C++和其共有的）一一17个

abstractbooleanbyteextendsfinalfinallyimplements

importinstanceofinterface

nativepackagesupersynchronizedthrowstransient

strictfp

null（仅在java用，类似true和false不是关键字）

所以说：

C有22+10=32个关键字

C++有22+10+11+20=63个关键字

JAVA有22+9+17=48个关键字

C++关键字详细解释

autobreakcasechatclassconst

continuedefaultdeletedodoubleelse

enumexplicitexternfloatforfiend

gotoifinlineintlongmutable

newoperatorprivateprotectedpublicregister

returnshortsignedsizeofstaticstatic_cast

structswitchthistypedefunionunsigned

virtualviodwhile

C++语言关键字

asmdoifreturntry

autodoubleinlineshorttypedef

booldynamic_castintsignedtypeid

breakelselongsizeoftypename

caseenummutablestaticunion

catchexplicitnamespacestatic_castunsigned

charexportnewstructusing

classexternoperatorswitchvirtual

constfalseprivatetemplatevoid

const_castflostprotectedthisvolatile

continueforpublicthrowwchar_t

defaultfriendregistertruewhile

deletegotoreinterpret_

cast

关键字是预先保留的标识符，每个关键字都有特殊的含义。我们

不能在程序中使用与关键字同名的标识符。以下是C++所保留的关

键字全集。

(l)asm

asm已经被_asm替代了,用于汇编语言嵌入在C/C++程序里编程,从

而在某些方面优化代码.虽然用asm关键字编译时编译器不会报错,

但是asm模块的代码是没有意义的.

(2)auto

这个这个关键字用于声明变量的生存期为自动，即将不在任何类、结

构、枚举、联合和函数中定义的变量视为全局变量，而在函数中定义

的变量视为局部变量。这个关键字不怎么多写，因为所有的变量默认

就是

auto的。

(3)bad_cast,const_cast,dynamic_cast,reinterpret_cast,st

aticcast

(4)bad_typeid

也是用于异常处理的，当typeid操作符的操作数typeid为Null指针

时抛出。

(5)bool

不用多说了吧,声明布尔类型的变量或函数.

(6)break

跳出当前循环.

(7)case

switch语句分支.

(8)catch,throw,try

都是异常处理的语句。

(9)char

声明字符型变量或函数.

(10)class

声明或定义类或者类的对象.

(11)const

被const修饰的东西都受到强制保护，可以预防意外的变动，能提高

程序的健壮性＞它可以修饰函数的参数返回值甚至函数的定义体

作用：

1.修饰输入参数

a.对于非内部数据类型的输入参数应该将“值传递”的方式

改为“const引用传递”，目的是提

高效率。例如将voidFunc(Aa)改为voidFunc(constA&a)。

b.对于内部数据类型的输入参数不要将“值传递”的方式改

为“const引用传递”。否则既达不

到提高效率的目的，又降低了函数的可理解性。例如void

Func(intx)不应该改为voidFunc(constint

&x)o

2.用const修饰函数的返回值

a.如果给以“指针传递”方式的函数返回值加const修饰那

么函数返回值(即指针)的内容不能

被修改，该返回值只能被赋给加const修饰的同类型指针。

如对于：constchar*GetString(void);

如下语句将出现编译错误：

char*str=GetString();//cannotconvertfrom'constchar*'

to'char*'；

正确的用法是：

constchar*str=GetString();

b.如果函数返回值采用“值传递方式”，由于函数会把返回值

复制到外部临时的存储单元中，加

const修饰没有任何价值。如不要把函数intGetlnt(void)写

成constintGetlnt(void)o

3.const成员函数的声明中,const关键字只能放在函数声明的尾部,

表示该类成员不修改对象.

说明：

consttypem;〃修饰m为不可改变

示例：

typedefchar*pStr;〃新的类型pStr;

charstring[4]="abc";

constchar*pl=string；

pl++；〃正确，上边修饰的是*pl,pl可变

constpStrp2=string;

p2++;〃错误，上边修饰的

是p2,p2不可变,*p2可变

同理，const修饰指针时用此原则判断就不会混淆了。

constint*value;〃*value不可变，value可变

int*constvalue;〃value不可变，*value可变

const(int*)value;//(int*)是一种type,value不可变,*value

可变

〃逻辑上这样理解，编译不能通过，需要tydefint*NewType;

constint*constvalue;〃*value,value都不可变

(12)continue

结束当前循环，开始下一轮循环.

(13)default

switch语句中的默认分支.

(14)delete

经常用于动态内存分配的语句。

(15)do

在do-while循环结构中开始循环体。

(16)double

声明双精度变量或函数.

(17)else

条件语句否定分支(与if连用).

(18)enum

声明枚举类型.

(19)explicit

这个关键字声明说明符，可以只适用于同类构造函数声明。显式

构造函数不能在隐式转换的一部分。它只能用于显式构造一个对象。

(20)export

MSDN只说Theexportkeywordisnotsupportedontemplates.

一种导出语句吧..

(21)extern

(22)false,true

bool类型的两个枚举值.

(23)float

声明浮点型变量或函数.

(24)for

一种循环语句。

(25)friend

声明友元函数或者类。

(26)goto

无条件跳转语句。

(27)if

条件语句。常与else一起用。

(28)inline

声明定义内联函数,编译时将所调用的代码嵌入到主函数中。

(29)int

声明整型变量或函数.

(30)long

声明长整型变量或函数.

(31)mutable

这个关键字只适用于非静态和非const数据类成员。如果一个声明数

据成员是可变的，那么它在const成员函数的赋值是合法。

(32)namespace

动态导入到文档中的元素行为

C++中usingnamespacestd

(33)new

动态内存分配。返回一个适当类型、非零对象的指针

(34)operator

(35-37)private,protected,public

类私有/保护/公有函数和数据成员的标示.

(38)register

声明寄存器变量.

(39)return

子程序返回语句(可以带参数，也看不带参数)，返回函数调用点。

(40)short

声明短整型变量或函数.

(41)signed,unsigned

声明有符号类型变量或函数;声明无符号类型变量或函数.

(42)static

声明静态变量.

(43)struct

声明结构体变量或函数.

(44)switch

条件选择

(45)template

模板.

(46)this

访问类，结构或者联合的非静态成员函数。

(47)typedef

用以给数据类型取别名.

(48)typeid

用于获取一个在编译时类型的类型

(49)typename

仅在模板中使用，告诉编译器是一个未知的type。

(50)union

声明联合数据类型.

(51)using

(52)virtual

声明虚基类或虚函数。

(53)void

声明函数无返回值或无参数，声明无类型指针.

(54)volatile

(55)wchar_t

宽字.

(56)while

循环语句的循环条件

(57)class

类

C++语言中const关键字的详细使用解释

生中的const关键字的用法非常灵活，而使用const将大大改善程

序的健壮性，本人根据各方面查到的资料进行总结如下，期望对朋友

们有所帮助。

Const是空中常用的类型修饰符，常类型是指使用类型修

饰符const说明的类型，常类型的变量或对象的值是不能被更新的。

一、Const作用

如下表所示：

No.

作用

说明

参考代码

1可以定义const常量

constintMax=100;

2便于进行类型检查

const常量有数据类型，而宏常量没有数据类型。编译器可

以对前者进行类型安全检查，而对后者只进行字符替换，没有类型安

全检查，并且在字符替换时可能会产生意料不到的错误

voidf(constinti){........}

〃对传入的参数进行类型检查，不匹配进行提示

3可以保护被修饰的东西

防止意外的修改，增强程序的健壮性。

voidf(constinti){i=10;//error!}

〃如果在函数体内修改了i,编译器就会报错

4可以很方便地进行参数的调整和修改

同宏定义一样，可以做到不变则已，一变都变

5为函数重载提供了一个参考

classA

voidf(inti).....)〃一个函数

voidf(inti)const{......}〃上一个函数的重载

｝；

6可以节省空间，避免不必要的内存分配

const定义常量从汇编的角度来看，只是给出了对应的内存

地址，而不是象#(16支便一样给出的是立即数，所以，const定义的

常量在程序运行过程中只有一份拷贝，而#(16支加定义的常量在内存

中有若干个拷贝

#definePI3.14159〃常量宏

constdoulbePi=3.14159;〃此时并未将Pi放入ROM中

doublei=Pi;〃此时为Pi分配内存，以后不再分配!

doubleI=PI;〃编译期间进行宏替换，分配内存

doublej=Pi;〃没有内存分配

doubleJ=PI;〃再进行宏替换，又一次分配内存!

7提高了效率

编译器通常不为普通const常量分配存储空间,而是将它们

保存在符号表中，这使得它成为一个编译期间的常量，没有了存储与

读内存的操作，使得它的效率也很高

二、Const的使用

1、定义常量

(1)const修饰变量，以下两种定义形式在本质上是一样的。

它的含义是：const修饰的类型为TYPE的变量value是不可变的。

TYPEconstValueName=value;

constTYPEValueName=value;

(2)将const改为外部连接，作用于扩大至全局，编译时会分

配内存,并且可以不进行初始化,仅仅作为声明,编译器认为在程序其

他地方进行了定义.

extendconstintValueName=value;

2、指针使用CONST

(1)指针本身是常量不可变

(char*)constpContent;

const(char*)pContent;

(2)指针所指向的内容是常量不可变

const(char)*pContent;

(char)const*pContent;

(3)两者都不可变

constchar*constpContent;

(4)还有其中区别方法，沿着*号划一条线：

如果const位于*的左侧，则const就是用来修饰指针所指

向的变量，即指针指向为常量；

如果const位于*的右侧，const就是修饰指针本身，即指针

本身是常量。

3、函数中使用CONST

(1)const修饰函数参数

a.传递过来的参数在函数内不可以改变(无意义，因为Var

本身就是形参)

voidfunction(constintVar);

b.参数指针所指内容为常量不可变

voidfunction(constchar*Var);

c.参数指针本身为常量不可变(也无意义，因为char*Var

也是形参)

voidfunction(char*constVar);

d.参数为引用，为了增加效率同时防止修改。修饰引用参数

时:

voidfunction(constClass&Var);〃引用参数在函数内

不可以改变

voidfunction(constTYPE&Var);〃引用参数在函数内为

常量不可变

这样的一个const引用传递和最普通的函数按值传递的效果

是一模一样的,他禁止对引用的对象的一切修改,唯一不同的是按值

传递会先建立一个类对象的副本，然后传递过去,而它直接传递地址,

所以这种传递比按值传递更有效.另外只有引用的const传递可以传

递一个临时对象，因为临时对象都是const属性，且是不可见的，他

短时间存在一个局部域中，所以不能使用指针，只有引用的const传

递能够捕捉到这个家伙.

(2)const修饰函数返回值

const修饰函数返回值其实用的并不是很多，它的含义和

const修饰普通变量以及指针的含义基本相同。

a.constintfunl()〃这个其实无意义，因为参数返回本

身就是赋值。

b.constint*fun2()〃调用时constint*pValue=

fun2();

〃我们可以把fun2()看作成一个变量，即指针内容不可变。

*constfun3()〃调用时int*constpValue=

fun2();

〃我们可以把fun2()看作成一个变量，即指针本身不可变。

一般情况下，函数的返回值为某个对象时，如果将其声明为

const时，多用于操作符的重载。通常，不建议用const修饰函数的

返回值类型为某个对象或对某个对象引用的情况。原因如下：如果返

回值为某个对象为const(constAtest=A实例)或某个对象的

引用为const(constA&test=A实例)，则返回值具有const

属性，则返回实例只能访问类A中的公有(保护)数据成员和const

成员函数并且不允许对其进行赋值操作这在一般情况下很少用到＞

4、类相关CONST

(1)const修饰成员变量

const修饰类的成员函数，表示成员常量，不能被修改，同

时它只能在初始化列表中赋值。

classA

constintnValue;〃成员常量不能被修改

A(intx):nValue(x){};〃只能在初始化列表中赋值

)

(2)const修饰成员函数

const修饰类的成员函数，则该成员函数不能修改类中任何

非const成员函数。一般写在函数的最后来修饰。

classA

(

•••

voidfunction。const;〃常成员函数，它不改变对象的成

员变量.

〃也不能调用类中任何非const成员函数。

}

对于const类对象/指针/引用，只能调用类的const成员函

数，因此，const修饰成员函数的最重要作用就是限制对于const对

象的使用。

a.const成员函数不被允许修改它所在对象的任何一个数

据成员。

b.const成员函数能够访问对象的const成员，而其他成员

函数不可以。

(3)const修饰类对象/对象指针/对象引用

•const修饰类对象表示该对象为常量对

象，其中的任何成员都不能被修改。对于对象指针和对象引用也是一

样。

,const修饰的对象，该对象的任何非const

成员函数都不能被调用，因为任何非const成员函数会有修改成员变

量的企图。

例如：

classAAA

(

voidfund();

voidfunc2()const;

)

constAAAaObj;

aObj.fund();X

aObj.func2();正确

constAAA*aObj=newAAA();

aObj->fund();X

aObj->func2();正确

三、将Const类型转化为非Const类型的方法

采用const_cast进行转换。

用法：const_cast<type_id>(expression)

该运算符用来修改类型的const或volatile属性。除了

const或volatile修饰之外，type_id和expression的类型是一

样的。

•常量指针被转化成非常量指针，并且仍然

指向原来的对象；

•常量引用被转换成非常量引用，并且仍然

指向原来的对象；

­常量对象被转换成非常量对象。

C++经典语句(一)

1.1.2求两个数的和

程序如下：

#include<iostream.h>

voidmain()

inta,b,sum;//定义了三个整型变量

a=43;//把整数常量赋给变量a

b=37;

sum=a+b;//a与b相加的和赋给变量sum

cout«*Thesumis/z«sum;

cout«endl;//endl是回车换行的作用

}

程序运行结果如下：

Thissumis80

1.1.3计算圆面积

#include<iostream.h>

voidmain()

(

constfloatpai=3.14;//用const说明了一个float型常量pai,m

由于pai是常量，所以在

//程序中这个值不会被改变

floatradius;//说明了一个float型变量radius,用于存放半径

值

cout«*Enterradius:

cin»radius;//cin为iosream.h中说明的文件，作用为接收键

盘输入。如此

//时从键盘输入一个数2.5,就把输入的这个值送入变量radius,

floatarea=pai*radius*radius;//说明了一个float型常量

area,用于存放计算后的面积

cout＜〈”\nTheareaofcircleis:

cout«area«endl;//输出面积

）

程序运行结果如下：

Enterradius:2.5

Theareaofcircleis19.625

说明：这个程序相对于progam1_2有一个明显的优点，就是它

的输入数据不必在编程时确定而是在运行时由操作者直接从键盘输

入。

上面的程序称为简单程序。直观上看，它们都很短，进一步

分析发现它们有两个特点：

1）程序要做的事情是由程序员在编程时就安排好了的是固定不

变的。

2）程序要做几个动作也是由程序员在编程时安排好的程序实际

上是一个简单的命令序列。

下面的程序有了“判断”的能力。此程序用于温度值（撮氏与华

氏温度）的换算，输入温度值并指出该值是播氏。还是华氏（F）温

度，然后程序根据不同的输入（撮氏或华氏）进行不同的换算。

2.1按条件进行判断

#include<iostream.h>

voidmain()

(

floatt,tc,tf;

charcorf;

constfloatfac=l.8,inc=32;

cout«/zEntertemperature:

cin»t;//输入温度值

cin»corf;//指出是撮氏(C)或华氏(F)

if(corf==,ccorf=,C')

(

tc=t;

tf=t*fac+inc;

}

else

if(corf=='F'corf='f')

(

tf=t;

tc=(t-inc)/fac;

elsetc=tf=0.0;

cout«endl«z，Thetemperatureis:

cout〈〈tc«"C="<<tf<X"F\n";

)

程序运行结果如下：

Entertemperature:40.2C

Thetemperatureis40.2C=104.36F

下面是使用switch(开关)语句的程序。switch提供了多分

支选择的方法。

5.2简单的计算器程序

这个程序完成的功能是：输入两个数，然后输入运算符，在屏幕

上显示运算结果。

程序运行结果如下：

#include<iostream.h>

voidmain()

(

intx,y;

charop;

cout«*firstinteger:

cin»x;

cout«endl«*Secondinteger:

cin»y;

cout«endl«z，operator(+,*,/,%):";

cin»op;

switch(op)//switch开关分支语句从这里开始，根据表达式的值

分支

(

case'://如果op=='+'

cout<<endl<<x<<"+"<<y<<"="<<x+y;

break;//执行完毕，退出switch分支。下面的break语句的作用

相同

case：//如果op=='-'

cout<<endl〈<xW<<y<<"="<<x-y;

break;

case'://如果op=='*'

cout«endl«x«**z，«y«z，=z，«x*y;

break;

case7’:〃如果op—5/'

cout«endl«x«z，/>z«y«z，=z，«x/y;

break;

case'://如果op=='%'

cout<<endl<<x<<"%"<<y<〈"="<〈x%y;

break;

default:

cout«endl«z，Wrong!”;

)

)

程序运行结果如下：

firstinteger:12

secondinteger:7

operator(+,*,/,%):*

12*7=84

上面的这个程序可以由用户任意输入两个整数及运算符，完

成指定的运算，但是它的不便之处是当有多次运算要进行时，每算完

一次必须重新启动程序。下面的程序使用循环控制语句，使得程序可

以进行多次运算。〃program2_5.cpp

#include<iostream.h>

voidmain()

(

intx,y,quit=l;

charop,cont;

while(quit)//whiel循环语句，括号里面是一个表达式，称为控

制表达式。当这个表

{//达式的值为1时继续循环体内的代码。从这个大括号开始，进

入循环体。

cin»x;

cin»y;

cin»op;

switch(op)

(

case'+':

cout«endl<<x<<"+”<<y〈<"="<<x+y;

break;

case'-':

cout«endl«x«z，->z«y«*=z，«x-y;

break;

case'*':

cout<<endl<<x<<"*"<〈y<〈"="<G*y;

break;

case'/':

if(y=0)cout«endl«*Overflow!*;//判断y是否为0,避免除

0错误。

else

cout<<endl<<x<〈"/"<<y<〈"="<<x/y;

break;

case':

if(y—0)cout«endl«>zOverflow!*;〃判断y是否为0,避免除

0错误。

elsecout«endl«x«*%*«y«*=*«x%y;

break;

default:

cout«endl«A，Wrong!";

break;

)

cout〈＜endl〈〈“Doyouwanttocontinue?(yorn)”;

cin»cont;

if(cont=,n)quit=0;//当操作者输入字符'n'时,由于quit被

赋值0。

//当再次检测while表达式时，由于quit为0,所以退出while循

环。

)

)

这个程序所做出的改进是很明显的，只要在每次完成一次计

算后，用户回答是否继续时按下'y'键(或除'n'之外的任何字符)，就

可以连续运行，完成用户指定的四则运算，直到接收到字母'n'为止。

在循环体内必须有改变while表达式值的语句否则一旦进入死循环

就无法跳出，这种情形称为“死循环”，编程中应注意避免。

2.3计算e的值和求素数

e是自然对数的底它和n一样是数学中最常用的无理数常量。

其近似值的计算公式为：

e=l+l/l!+l/2!+l/3!+...+l/(n-l)!+r

当n充分大时，这个公式可以计算任意精度e的近似值。为了保

证误差r<e,只需l/(n-l)!(>r)<e

程序代码如下：

#include<iostream.h>

voidmainO

(

constdoubleeps=0.Ie-10;

intn=l;

floate=l.0,r=l.0;

do//开始do循环。循环条件由后面的while中的表达式值确定。

(

e+=r;

n++;

r/=n;

}

while(r>eps);

cout«*TheapproximateValueofnaturallogarithmbaseis:

cout«e«endl;

)

程序运行结果如下：

TheapproximateValueofnaturallogarithmbaseis:

2.71828

说明：

上面这个程序中使用了do循环，它是循环控制中的一种。循环

控制条件放在后面的while表达式中。

下面的程序用来求出1000以内的全部素数。

#include<iostream.h>

voidmain()

(

constintm=1000;

inti,j,isprime;

for(i=2;i<=m;i++)//这里用到了for循环控制语句。for循环语

句有三个表达式

{//第一个表达式赋给变量初值，第二个表达式为循环控制条件，

//第三个表达式为循环变量改变其值

isprime=l;

for(j=i-l;j>l;j—)

if(i%j==0)isprime=0;

if(isprime)cout«i«,,,;

if(i%30==0)cout«endl;

)

说明：

D当m值比较大时，这个程序计算量是比较大的，事实上这是用

来求出小于m的所有素数的最简单也是最笨的算法。

一种办法是作下面的改进：

把for(j=iT;j>l;j-)改为：

intil=int(sqrt(i));

for(j=il;j>l;j—)

为了确定整数i是不是素数，不需要用2,3,。。。，i-1来除

它，只需用2,3,。。。，sqrt(i)试除就可以了。

这里sqrt(i)是标准函数，功能是计算平方根，而int()则是把

浮点值围化为整型值。

另一种算法是埃拉脱散(Eratosthenes)筛法，将在以后介绍。

3.1统计学生成绩

已知n个学生的注册号和成绩，计算他们的平均成绩，并列出成

绩最好的前t名学生的注册号和分数。

程序代码如下：

#include<iostream.h>

voidmain()

constintn=3;

constintt=n;

intindex[n];//存放注册号

floatscore[n];//存放成绩

for(inti=0;i<n;i++)

cin»index[i]»score[i];//从键盘输入数据

floatsum=0;

for(i=0;i<n;i++)

sum+=score[i];//计算分数总和

cout.precision(2);//设置输出精度

cout«endl«z，Averagescore:,,«sum/n;

cout.width(28);//输出精度

cout«endl«A，registernumberscore”;

for(i=0;i<t;i++)//选取前t名分数最高的学生，输出其注册号和

成绩

(

floats=score[i];

intjl=i;

for(intj=i+l;j<n;j++)

if(s<score[j])

s=score[j];

jl=j；

)

if(jl>i)

(

score[jl]=score[i];

score[i]=s;

j=index[jl];

index[jl]=index[i];

index[i]=j;

)

cout.width(4);//输出序号，注册号和分数

cout«endl«i+l;

cout.width(11);//设置宽度

cout«index[i];

cout.width(16);

cout.precision(2);//设置输出精度

cout«score[i];

}

cout«endl;

程序运行结果如下:

£4270

15689

15867

ftueragescore：75

registernunberscore

115689

214270

315867说明

cout.precision⑵是一个函数调用语句，函数名是

precisionocout说明此函数是一个标准类的一个标准对象cout的

函数。所“标准”，即它们所涉及的流(stream)类和对象cout都是

由系统已经义好了的。其说明可以在头文件iostream.h中找到。函

数precision要求一个int型参数该参数指出在后面输出的浮点数

的精度取到小数点后的多少位。

cout.width。是另一个函数的用法。width决定了其后数据输出

的宽度。

3.2输出三角函数表

输出人0~90度之间每隔15度的正弦、余弦、正切函数值。

程序代码如下：

//program3_2.cpp

#include<iostream.h>

#include<math.h>

voidmain()

constfloatpai=3.1416f;

constintinterval=15;

cout.width(10);

cout«*Anglex";

cout.width(10);

cout«*sin(x)”;

cout.width(10);

cout<〈”cos(x)”;

cout.width(10);

cout«*tan(x)”;

floatarc;

cout.precision(4);

for(intdoa=0;doa<=90;doa+=interval)

(

arc=pai*doa/180;

cout«endl;

cout.width(10);

cout«doa;

cout.width(10);

cout«sin(arc);

cout.width(10);

cout«cos(arc);

cout.width(10);

if(doa==90)cout«*-，/;

elsecout«tan(arc);

cout«endl;

}程序运行结果如下:

Anglexsin<x>cos<x>tan<x>

0010

150.25880.96590.2679

300.50.8660.5774

450.70710.70711

600.8660.51.732

?50.96590.25883.732

901-3.62e—006—

说明：

1)本程序中使用了系统提供的标准库函数

sin(),cos(),tan(),它们都在头文件math,h中说明。因此在3行包

含了此文件。

2)由于当doa=90时，其正切函数趋于无穷大，故对它有特殊的

处理，否则如按正弦、余弦一样输出，当doa变到90时，运行将可

能溢出或打印一个超界的大数。

3.3Eratosthenes筛法求素数

在2_3节给出了一个求在一个范围内的全部素数的程序)下面给

出的程序其算法比原来的好。

program3_5是对2~1000的所有素数进行检测，用小于该数的数

试验，如果都不能除尽，就找到了一个素数。本节的程序也是用来求

1000以内的所有素数，但其思想简单而巧妙。它是把2~1000所有的

整数放到一起首先把2保留，把2的所有素数从中去掉，再保留3,

同时删去所有3的倍数，下一个数是5,7...o好象是一把筛子，把

不需要的数逐步筛去，留下的正是所求的数。

程序代码如下：

#include<iostream.h>

#include<iomanip.h>

voidmain()

(

constintn=1000;

inti=l,j,count=0,sieve[n+1];

for(j=l;j<n;j++)sieve[j>j;//把广n存入sieve[n]

while(i<n+l)//从while循环开始完成全部素数的产生和输出。

(

while(sieve[i]=l)i++;//跳过值为1的分量，表示下一个分量

必为一素数

cout«setw(4)«sieve[i];//setw(4)设置以宽度为4的格式输出

数据。setw(4)

//等价于cout.width(4)

count++;

if(count%15==0)cout«endl;

for(j=i;j<n+l;j+=i)

sieve[j]=l;

)

程序运行结果如下:

235711131?192329313741434?

53596167717379838997101103107109113

12?13113?139149151157163167173179181191193197

199211223227229233239241251257263269271277281

283293307311313317331337347349353359367373379

383389397401409419421431433439443449457461463

467479487491499503509521523541547557563569571

577587593599601607613617619631641643647653659

661673677683691701709719727733739743751757761

769773787797809811821823827829839853857859863

8778818838879079119199299379419479539679719??在本节

以前给出的程序都是由一个函数组成的，实际上，一个真正的C++程

序几乎都包含若干个由用户自定义的函数。

在下面的几个程序实例中，都调用了由用户定义的函数。

4.1三次方程求根

按照Cardan公式，计算三次方程x3+px+q=0的一个实根的公式为:

在计算实根xr的程序中，把计算一个浮点数的立方根的程序作

为一个用户定义的函数，而在主程序中两次调用这个函数。

在计算6过程中，使用迭代公式:

程序代码如下：

#include<iostream.h>

#include<math.h>

floatcuberoot(float);//自定义函数的原型

voidmainO

(

floatp,q,xr;

cout«*Inputparamertersp,q:";

cin»p»q;

floata=sqrt(q/2*q/2+p/3*p/3*p/3);

xr=cuberoot(-q/2+a)+cuberoot(-q/2-a);//调用cuberoot函数

cout«endl«*Therealrootoftheequationis”<<xr;

floatcuberoot(floatx)//