第一部分基础编程.docx

第一部分基础编程.docx

《第一部分基础编程.docx》由会员分享，可在线阅读，更多相关《第一部分基础编程.docx（30页珍藏版）》请在冰点文库上搜索。

第一部分基础编程

第一部分基础编程

第1章概述练习解答

EX0101

这是本书的第一个C++代码，其解答为：

//=====================================

//EX0101.cpp

//simplestprogramwithoutput

//=====================================

#include

//-------------------------------------

intmain（）{

std:

:

cout<<"Iamastudent.\n";

}//====================================

前面附着#的语句行：

#include

说严格些，它不是C++语句。

也就是说，它并不规定机器做什么，而是规定编译器在编译时做什么，它们也称为伪指令，用斜体区分。

输出用cout，它本是应用了C++提供的标准输入、输出的流资源，因此使用包含iostream的指令（用斜体表示）。

凡是涉及C++资源的，都在名为std的名表中注册，所以若默认使用C++资源，必须在包含指令后面再加：

usingnamespacestd;

代码中在cout前加了std:

:

，表示由于没有默认使用，只得在使用名字时加前缀，或者说，单一使用只须加前缀，便可以省略上述的名空间说明。

一般来说，语句中往往涉及C++各种资源的诸多使用，为了默认使用，在初学者的程序里，通常都会加上上述名空间使用语句。

另外，上述解答代码中，一些加了双斜杠的行是注释行，它不起执行的作用，只是给人阅读。

代码其实可以写成没有注释语句的形式：

#include

intmain（）

{

std:

:

cout<<"Iamastudent.\n";

}

本解答代码追求规范、个性化、可理解，习题与解答在题号上对应，所以在代码头上加上了一些注释。

代码中双引号括起来的是字串。

如果字串中本身含有双引号，则需要在双引号字符前加引导符\，例如：

描述“Isay"OK!

"”，用C++语句写为：

std:

:

cout<<"Isay\"OK!

\"\n";

\n是换行字符，它是用两个字符来描述一个控制行为的控制符。

语言的描述都是用有形可见的字符符号，也就是编程中使用的字符，恰如英语中的英文字符用以构成英语。

如果要用这些符号描述无形的控制行为则要加引导符'\'。

控制符在主教材CH3.2.1的表3-3上描述了一些，一般不常用。

intmain（）{

}

是一个函数描述，专业地说，为函数定义。

它是一个函数名（main），加上一对小（圆）括号，附上返回类型（int），再加上一对花括号，里面写上若干条语句。

左花括号的位置只要跟在右小括号后面，写在哪里都行。

不同的书写方式反映了编程的不同风格。

C语言风格的代码为：

//=====================================

//EX0101.cpp

//simplestprogramwithoutput

//=====================================

#include

//-------------------------------------

intmain（）{

printf（"Iamastudent.\n"）;

}//====================================

它使用了不同的资源（头文件）。

头文件是指以扩展名.h结尾的文件，头文件多在C语言中使用，C++当然可以兼用，但是C++更多使用的是没有.h扩展名的资源。

包含不同的资源，将导致代码中的输出采用不同的方式。

语句以分号结束，C++编译器以分号区分各语句单位。

语句总是写在函数中，表示计算或者输入、输出等操作。

EX0102

可由若干行语句来完成本问题的字符图形输出的工作。

//=====================================

//EX0102.cpp

//简单字符图形输出

//=====================================

#include

usingnamespacestd;

//-------------------------------------

intmain（）{

cout<<"*\n";

cout<<"***\n";

cout<<"*****\n";

cout<<"*******\n";

cout<<"*****\n";

cout<<"***\n";

cout<<"*\n";

}//====================================

main（）函数中的语句是要求机器执行的动作序列。

这里是由7个输出语句构成。

每个语句负责输出一行字符，这是为了直观。

然而，C++输出语句的能力并非一定按行为单位进行，可以用一条语句执行几行的输出。

下列是用一个输出语句通过反复执行<<操作，将字串送往输出设备，从而将该图形整个输出。

cout<<"*\n"<<"***\n"<<"*****\n"<<"*******\n"<<"*****\n"<<"***\n"<<"*\n";

我们看到，一条语句在一行写不下时，可以由接着下一行继续写。

编译器在识别到分号时才认可整条语句的结束。

所以，可以通过添加一些空格、空行，人为地构造优雅的代码格式。

上述语句可以这样写：

cout<<"*\n"

<<"***\n"

<<"*****\n"

<<"*******\n"

<<"*****\n"

<<"***\n"

<<"*\n";

虽然增加了语句行，但是形象，只要注意在最后一行才打上分号，以表示前面的代码行只是一条语句的组成部分而已。

我们还看到，该语句是将各个字串按行分段表示和逐段输出的。

这有点极端，事实上，可以将各段字串拼合：

cout<<"*\n***\n*****\n*******\n*****\n***\n*\n";

它表示一个较长字串一次性送往输出设备去显示。

字串中的每个“\n”表示换行，它控制设备在相应的输出中执行换行。

所以整个字串的输出会在结果窗口中分段列在不同的行上。

如果一个字串实在很长，一行写不下，可以在行尾插入一个斜杠符号，以示意编译器下行继续，从而不被当作语句不完整而出现编译错误。

例如上述语句也可以这样写：

cout<<"*\n***\n*****\n*******\n*****\n*\

**\n*\n";

由于下一行必定从头算起以作为上一行的继续，因此书写格式上没法通过加空格来修饰，可能会觉得不够优雅。

一些超长的字串往往用数据文件的方式存取。

所以这种代码的形式只有在翻读前人书写的代码时还能看到，现代编程中很少能看到这种代码。

下列作为极端的例子，用几条语句执行一行的输出：

cout<<"";

cout<<"";

cout<<"";

cout<<"*";

cout<<"\n";

这5条语句构成了图形中第一行的输出字符。

空三格，然后显示一个'*'字符，最后换行。

在运行结果的窗口中，显示的字符总是按语句执行的先后顺序，从左到右，从上到下。

所以，输出一个图形，必须按顺序先输出最上面的字符行。

为了到达行中显示可见字符的位置，需要先输出几个空格。

为了输出下一行，在当前行必须先输出一个换行符（将控制符也作为一个字符进行输出），以使显示位置跃到下一行的开头。

逐个字符输出，用逐条语句描述，耗费了很多语句，才显示了很少的字符，因而从运行性能上来说划不来。

但是在需要通过计算来获得字符个数、字符内容和字符位置，从而进行批量自动（循环控制）输出，而代替人工的时候，这种输出形式却是学习循环控制的基础。

例如，输出三个'*'字符，可以用循环语句来实现：

for（inti=1;i<=3;i=i+1）

{

cout<<'*';

}

这是一个循环语句，花括号括起来的语句是被for循环描述，反复执行的语句序列，称为循环体，这里只含有一条语句。

这条语句执行的次数由for循环的描述头说明，因为i变量从1到3，不断地增1变化，说明该循环一共将进行3次，从而满足连输三个'*'的要求。

由于循环体只含有一条语句，C++语法规则允许省略花括号：

for（inti=1;i<=3;i=i+1）

cout<<'*';

该代码的语义与前面相同。

在开始循环时，先令i=1，然后判断是否i<=3，如果判断结果为假，则结束for循环语句，转去执行下一条语句。

否则，进入并执行循环体语句。

在这里，第一次判断时，i为1，所以是1<=3，所以，执行cout<<'*';语句，之后，循环变量i增1使其值为2，接着再判断i<=3，得到真值，于是继续进入并执行循环体语句，输出第二个'*'，周而复始，等到第三个'*'输出之后，再增1给i使其值为4，判断i<=3时，判断结果为假，于是整个for循环语句宣告结束。

这时候，便已经得到连续三个在屏幕上显示的'*'。

for循环的循环体中可能会有许多语句，但其都归属在for循环语句体内，作为一个循环语句的整体，被视为一个语句单位。

在循环语句的执行中，则自然按循环控制规则按序执行。

例如：

输出一行7个'A'字符，可以循环执行输出1个'A'字符7次，再输出一个换行符：

for（inti=1;i<=7;i=i+1）

cout<<'A';

cout<<"\n";

注意上面省略了包住循环体的花括号。

“cout<<'A';”语句归属于for循环，因而被执行了7次，“cout<<'\n';”语句却是在for循环语句之后，因而按序执行中，它只被执行一次。

这与代码：

for（inti=1;i<=7;i=i+1）

{

cout<<'A';

cout<<"\n";

}

是完全不同的。

因为后者，每次输出'A'后都要换行，而前者在连续输出7次'A'后统一执行一次换行。

从程序形态上看，因为所描述的循环体中有两条语句，所以花括号不能省，而前者可以省略花括号。

如果要输入一个整数，并将该整数的平方值随后输出，则其代码为：

#include

usingnamespacestd;

intmain（）

{

intn;

cout<

}

该程序的运行结果取决于输入的整数值。

程序运行结果往往并不由编程决定，而由运行中输入的数值来决定。

如果要根据输入的整数值n，输出一个n*5的'Z'字符矩形，则因为无法在编程中确定n的值，而不能简单地用确定个数的输出语句来完成。

也就是说，下述语句行数不知道：

cout<<"ZZZZZ";

cout<<"ZZZZZ";

cout<<"ZZZZZ";

cout<<"ZZZZZ";

cout<<"ZZZZZ";

cout<<"ZZZZZ";

这时候，就需要用循环语句，设置循环变量初值，到运行中获得的n之终值，不断进行测试、增量、再测试、再增量的步骤，来控制输出语句的执行次数。

可以这样来实现输出n*5的字符矩形的任务：

#include

usingnamespacestd;

intmain（）

{

intn;

cin>>n;

for（intk=1;k<=n;k=k+1）

{

cout<<"ZZZZZ\n";

}

}

循环体中是输出5个字符'Z'并换行的语句，通过控制执行n次的循环，满足输出的要求。

如果将矩阵转过来，不是输出n*5，而是输出5*n的字符矩阵，则因为数字5是确定的，可以用5个循环语句来做：

#include

usingnamespacestd;

intmain（）

{

intn;

cin>>n;

for（intk=1;k<=n;k=k+1）//每个for循环都输出n个字符的行，共5个for

cout<<"Z";

cout<<"\n";//换行不能少

for（intk=1;k<=n;k=k+1）

cout<<"Z";

cout<<"\n";

for（intk=1;k<=n;k=k+1）

cout<<"Z";

cout<<"\n";

for（intk=1;k<=n;k=k+1）

cout<<"Z";

cout<<"\n";

for（intk=1;k<=n;k=k+1）

cout<<"Z";

cout<<"\n";

}

因为行中'Z'字符的个数，取决于输入的n值，编程时n不确定，而循环的次数可以用不确定量来描述，所以可用循环来描述输出含n个'Z'字符的输出：

for（intk=1;k<=n;k=k+1）

cout<<"Z";

cout<<"\n";

5*n的字符矩形输出用5个同样的代码来拼合，这样的代码显得冗长，完全可以通过循环语句的循环（二重循环）来简化：

for（intk=1;k<=5;k=k+1）

{

for（inti=1;i<=n;i=i+1）

cout<<'Z';

cout<<"\n";

}

它是将输出一行n个'Z'字符的语句集合，重复执行5次，或者说，将该语句集合作为循环体，外套一个重复5次的循环语句。

例如，输出一个'x'字符的5*5正方形，可以循环5次输出一行5个'x'字符，而输出一行5个'x'字符，又是一个循环5次的单字符输出，再追加一个换行：

for（intk=1;k<=5;k=k+1）

{

for（inti=1;i<=5;i=i+1）

cout<<'x';

cout<<"\n";

}

外循环的循环体内容便是输出一行5个'x'字符。

它由两条语句构成，一条是for循环语句，另一条是单独输出换行的语句。

这里用的for循环在结构上构成了内外二重循环。

需要注意的是内外二重循环的循环变量名最好不要相同，以示区别。

这里外循环变量用k，内循环变量用i。

而因为内循环中输出5个字符并换行的执行在编程时是确定的，所以可以直接用“cout<<"xxxxx\n";”语句替代内循环而使代码简化：

for（intk=1;k<=5;k=k+1）

cout<<"xxxxx\n";

那么，从输入中获得n值，输出一个n*n的'x'字符正方形，又该怎么编程呢？

想必读者会找到答案的。

第2章基本编程语句练习解答

EX0201

在分析与设计本问题时，首先需要明确问题的要求。

加法数列中每一项绝对值不小于10-8的浮点数都必须加到该级数的和中。

最后将这个结果值取小数点8位精度。

该加法数列中某一项tn表示为：

tn=sn+1–sn

如果计算到某一项tn<10-8时，那么，由于后面诸项的绝对值均不会超过tn，所以累计数列应到此为止，而忽略第n项之后值的求和计算。

因而循环求和只需要控制在逐项累计，到达一定的项，满足项值小于10-8时停止求和，便能够得到所要求的值。

算法描述为：

1设定双精度型（double）变量x

2用键盘输入x的值

3设定求和双精度型变量sum，存放初始值1

4设定项（双精度型变量）t，存放初始值x（从这项开始累计）

5设定整型循环变量i=2，跟踪累计的项数，作为项值计算的依据

6如果t的绝对值小于10-8，则转11

7否则，将t值加入sum

8计算后继t项

9循环变量i加1

10转6

11设置输出小数8位的定点方式

12输出sum值

13结束

其对应的代码为：

//=====================================

//EX0201.cpp

//级数求和

//=====================================

#include

#include//abs（）

usingnamespacestd;

//-------------------------------------

intmain（）

{

doublex;

cin>>x;

doublesum=1;

doublet=x;

inti=2;

while（abs（t）>1e-8）

{

sum+=t;

t*=（-1）*x/i;

i++;

}

cout.precision（8）;

cout<

}//====================================

代码中while循环表现了算法6~10行的描述。

当然可以写出对等的for循环结构的实现。

//=====================================

//EX0201.cpp

//级数求和

//=====================================

#include

#include//abs（）

usingnamespacestd;

//-------------------------------------

intmain（）

{

doublex;

cin>>x;

doublesum=1;

doublet=x;

for（inti=2;abs（t）>1e-8;i++）

{

sum+=t;

t*=（-1）*x/i;

}

cout.precision（8）;

cout<

}//====================================

for循环是将循环变量的初始化、条件判断和循环变量的状态变化这三者合在一起描述，便于统一观察循环控制和循环变化规律，因而它总是体现了结构和紧凑。

在一般情况下，用for循环来合并相关语句，会使代码更优雅。

例如，将三个变量定义语句放在一起，将循环变量增值和项的更新计算放在一起，作为for循环的循环变量更新描述。

循环状态i的变化导致了t的变化，将它们放在循环描述的第三部分中，使得循环体得到简化，最后以一条简单语句描述加法数列的累计，循环体的花括号语句也因此而省略。

//=====================================

//EX0201.cpp

//级数求和

//=====================================

#include

usingnamespacestd;

//-------------------------------------

intmain（）{

doublex,sum=1,t;

cin>>x;

t=x;

for（inti=2;abs（t）>1e-8;t*=（-1）*x/i++）

sum+=t;

cout.precision（8）;

cout<

}//====================================

模仿学习：

主教材CH2.7.2中，例示了f0218.cpp和f0219.cpp两种方法的代码。

对于求通项t，要注意本题的通项计算需要根据前一项计算而得，不能通过通项公式计算：

tn=（-1）n+1xn/n!

分别计算分子和分母是一种无视xn和n!

的计算溢出的做法，但是如果在获得tn-1的前提下，对其做乘x除n操作便不会使结果溢出：

tn=tn-1*x/n

所以应该模仿f0218.cpp。

//=====================================

//EX0201.cpp

//级数求和

//=====================================

#include

#include

usingnamespacestd;

//-------------------------------------

intmain（）{

doublex;

cin>>x;

doublesum=1,item=-1;

for（inti=1;abs（item）>1e-8;i++）

{

item*=（-1）*x/i;

sum+=item;

}

cout<

}//====================================

代码中，abs（t）表示求t的绝对值，1e-8表示10的-8次方，它是一个正数，所以需要将t先求其绝对值再进行比较。

代码中，精确到小数点后8位，若用cout<

C++的流操作，默认定点数输出的精度为小数点后6位，即相当于执行了语句cout<

EX0202

我们知道求1到10的和，可以用求和公式直接求得，即：

（1+10）10/2。

对这10个数的求和，不需要访问内存空间，直接计算就可以得到结果。

但有时候需要面对10个存储单元，其存储单元的值预先并不知道。

求这10个存储单元值的和时，就需要逐个取出存储单元并累计求和。

假如10个整数放在数组a中，其10个单元为a[0]~a[9]，则将该10个整数求和之前，先设一个放置累计值的变量sum，初值为0，然后进入总次数为10的循环，不断读取数组中的元素，加到sum中，直到加完这10个整数，结果也就出来了：

intsum=0;

for（inti=0;i<10;i++）//循环从0到9

{

sum=sum+a[i];

}

cout<

注意上述代码在实现中，循环变量的初值和终值设置为0与9，是为了迎合数组的下标值。

C++的数组结构中，都是以0下标来描述其第一个单元的。

那么，如果要将这10个整数求积，则在for循环体中将＋改成＊就可以了。

intt=1;

for（inti=0;i<10;i++）

t=t*a[i];

cout<

注意代码中的花括号省略。

求积的累积与求和的累计稍有不同，求积的累积变量初值为1，而求和的累计变量初值为0。

共同的是，它们都必须在循环求值之前预先进行定义，在循环求值之后，才获得最终结果。

累积求积变量名的取名与累计求和变量名一样，也是人为的，可以按容易理解的方式来取名，这里分别取了sum和t这两个名字。

现在对于求n!

，则可以将数组的下标访问去掉，直接改成对循环变量进行乘法操作。

原先循环变量值充当数组的下标，因而其值从0开始循环到9，现在循环次数仍然是10次，但表示的是阶乘中依大小排列的每