习题课2文档格式.docx

习题课2文档格式.docx

《习题课2文档格式.docx》由会员分享，可在线阅读，更多相关《习题课2文档格式.docx（13页珍藏版）》请在冰豆网上搜索。

cin>

>

a;

if（a<

1000||a>

999）

{cout<

error"

endl;

cin.get（）;

return0;

}b=encipher（a）;

c=exemption（b）;

密码是：

b<

明码是：

c<

}问题：

（1）调用pow函数会降低运行效率

{for（i=5;

i>

=0;

i--）

b+=（（（int）（a/pow（10,i））+7）%10）*（int）pow（10,（5-i））;

}

（2）在循环结束后输出效率更高

for（i=6;

=1;

{c=c*10;

b=（（a%10）+7）%10;

c=c+b;

//cout<

b;

//不要在循环体内输出}cout<

c;

//改为在循环结束后输出效率更高

（3）输入明码“000”0一类的，但是在我的程序中没有办法对这种数字比较大小进行判断。

（4）输入明码“333”，密码会出现0，而不是000，或者是输入明码7733，会输出44，而不是0044，为了在不同情况下补齐到六位又该怎样设计比较好？

程序测试3-1

1、编写一个程序，测试3个函数，它们都能够把main函数中的变量count的值增至3倍。

这3个函数说明如下：

（a）tripleByValue函数通过值传递count的一份副本，把值增至3倍并返回这一结果。

（b）tripleByReference函数通过引用参数传递count，用别名（即引用参数）把count原来的值增至3倍。

（c）tripleByPointer函数通过指针参数传递count的地址，用间址方式把count原来的值增至3倍。

doubletripleByValue（doublex）

{returnx*3;

//传值参数不能修改实参的值}doubletripleByReference（double&

x）

{x=x*3;

//指针参数通过间址修改实参的值

returnx;

}doubletripleByPointer（double*x）

{*x=*x*3;

//引用参数通过别名修改实参的值

return*x;

}intmain（）

{doublecount;

1,Pleaseinputcount:

"

count;

count=tripleByValue（count）;

//通过函数返回值修改count的值

tripleByValue:

count<

2,Pleaseinputcount:

tripleByReference（count）;

//也可以count=tripleByReference（count）cout<

tripleByReference:

3,Pleaseinputcount:

tripleByPointer（&

count）;

//也可以count=tripleByPointer（&

count）cout<

tripleByPointer:

（1）求值函数应该用return返回计算结果值，不应在函数内输出求值结果

voidtripleByValue（doublex）

{x=x*3;

x<

}voidtripleByReference（double&

x）

}voidtripleByPointer（double*x）

{*x=*x*3;

*x;

}

（2）引用参数和指针参数的应用。

引用参数和指针参数都可以通过形参读/写实参。

2、已知勒让xx多项式为1ì

ï

p

n（x）=í

xï

（（2n-1）p（x）-（n-1）p（x））/n

n-1n-2

î

n=0

n=1

n>

1

编一程序，定义递归函数求

doublepoly（double&

x,intn）;

pn（x）的值。

主函数从键盘上输入x和n的值，调用poly函数测试。

//计科（）-xx

doublepoly（double&

int）;

intmain（）

{intn;

doublex,p;

inputn（n>

=0）\t"

n;

inputx（x>

0）\t"

x;

p=poly（x,n）;

p<

}doublepoly（double&

x,intn）

{if（n==0）return1;

else

{if（n==1）returnx;

elsereturn（（2*n-1）*poly（x,n-1）-（n-1）*poly（x,n-2））/n;

}}

问题：

（1）为什么x用引用参数？

（2）warningC4715:

“poly”:

不是所有的控件路径都返回值

x,intn）{if（n==0）return1.0;

if（n==1）returnx;

if（n>

1）return（（2*n-1）*poly（x,（n-1））-（n-1）*poly（x,（n-2）））/n;

}//如果条件都不成立怎么办？

（3）表达式计算：

return（（2*n-1）*poly（x,n-1）-（n-1）*poly（x,n-2）/n）;

return（2*n-1）*poly（x,n-1）-（n-1）*poly（x,n-2）/n;

if（n==0）return0;

指出以下程序中的错误：

x,intn）{if（n=0）return0;

elseif（n=1）returnx;

else

return（（（2*n-1）*poly（double&

x,int（n-1））-（n-1）*poly（double&

x,int（n-2）））/n）;

}

1“==”与“=”○2return1○3形参与实参的形式○函数原型

函数调用

4表达式书写

○doublepoly（double&

x,intn）;

poly（double&

x,int（n-1））

程序测试4-1

本程序的main函数调用RandAry函数，生成20个1～20之间的随机数；

调用OutAll函数显示生成的随机数序列；

调用OutUnlike函数，删除生成序列中的重复数值，仅显示序列中的不同数值。

显示数据不改变原来的相对顺序。

cstdlib>

ctime>

voidRandAry（intary[],intn,intmin,intmax）;

//生成随机数序列

voidOutAll（intary[],intn）;

//输出数组全部元素

voidOutUnlike（intary[],intn）;

//输出数组中不相同元素intmain（）

{constintN=20;

intary[N];

生成20个1～20之间的整数:

\n"

RandAry（ary,N,1,20）;

//生成N个1～20之间的随机整数放在数组ary中OutAll（ary,N）;

//输出数组全部原始数据

输出不相同数据序列:

OutUnlike（ary,N）;

//输出不相同的数据，不改变原来的相对顺序}

//生成n个min～max的随机数序列，放在数组ary中

voidRandAry（intary[],intn,intmin,intmax）

{inti,k;

srand（unsigned（time

（0）））;

//为随机数生成器设置种子值

for（i=0;

i<

i++）//获取指定范围的随机数

{do{k=rand（）;

}

while（k<

min||k>

max）;

ary[i]=k;

voidOutAll（intary[],intn）

{inti;

for（i=0;

i++）//输出全部数据

ary[i]<

}voidOutUnlike（intary[],intn）

{inti,j;

i++）

{if（ary[i]）

//输出非0元素

elsecontinue;

//不查找0元素

for（j=i+1;

j<

j++）//查找非0相同数据

if（ary[i]==ary[j]）//删除相同元素值

ary[j]=0;

}cout<

（1）函数功能要清晰。

不应在OutAll函数中增加判断元素值：

if（ary[i]）ciut<

（2）正确使用函数参数。

voidOutAll（int*ary,inty）

{for（inti=0;

20;

i++）//不使用y参数

'

\t'

}（3）数组访问的边界处理

程序测试4-2

本程序的main函数定义了一个用二维数组m表示的4×

4方阵。

程序中：

调用setMatrix函数，对方阵元素赋不大于100的随机整数；

调用diagonal函数，依次把m阵的主对角线、次对角线放在数组a中。

constintN=4;

voidsetMatrix（intmatrix[][N],intn）;

//对矩阵matrix置随机数，n是元素个数//把matrix的主、次对角线元素放在ary中。

n是对角线元素个数

voiddiagonal（intmatrix[][N],int*ary,intn）;

{intm[N][N],a[2*N],i,j;

setMatrix（m,N*N）;

//调用函数，对方阵元素赋不大于100的随机整数cout<

N<

*"

方阵：

N;

i++）//输出方阵元素

{for（j=0;

j<

j++）

m[i][j]<

}//调用函数，依次把m阵的主对角线、次对角线放在数组a中

diagonal（m,a,N）;

对角线元素：

2*N;

i++）//输出对角线元素

a[i]<

}voidsetMatrix（intmatrix[][N],intn）//matrix是二维数组参数

{inti,*p;

//p是一级指针变量

p=*matrix;

//二维数组作降维处理

i++,p++）

*p=rand（）%100;

//对数组元素赋随机数}voiddiagonal（intmatrix[][N],int*ary,intn）

{ary[i]=matrix[i][i];

//主对角线

ary[i+n]=matrix[i][n-i-1];

//次对角线}}

（1）如何定义setMatrix函数。

从main函数可得函数原型：

//n是元素个数

如何实现？

matrix是二维数组，逻辑二级指针，n是元素个数，没有行列信息。

用数组降维处理。

（2）提高diagonal函数的效率。

（3）正确使用参数。

规则与建议

C++程序通常分为两个文件：

头文件（.h）——保存程序的声明（declaretion）；

定义文件（.cpp）——保存程序的实现。

1、头文件的结构

（1）版本说明

（2）预处理块

（3）函数和类结构说明

【规则1-1】用#include<

filename>

引用标准库头文件。

编译器将从标准库目录开始搜索。

【规则1-2】用#include”filename.h”引用非标准的头文件。

编译器将从用户的工作目录开始搜索。

【规则1-3】头文件中只存放“声明”，不存放“定义”

【规则1-4】为防止头文件的定义内容被重复引用，使用ifndef/define/endif结构产生预处理块。

【规则1-5】不提倡使用全局变量，尽量不要在头文件中出现如

externintvalue;

这样的说明。

2、定义文件的结构

（1）版本说明、功能说明

（2）对头文件的引用

（3）程序的实现体，包括数据和代码

3、代码书写

代码书写的良好风格，是阅读、调试程序的基础

【规则2-1】用空行分隔逻辑块。

如类、函数、语句功能块。

【规则2-2】一行代码只做一件事情。

便于阅读和跟踪。

【规则2-3】一行代码不超过80个字符，便于打印。

【建议2-3】尽量在变量说明的同时初始化。

【规则2-4】程序分界符大括号“{”与匹配的反括号“}”应独占一行，并且位于同一列对齐。

括号对{}中的语句按逻辑以缩进格式书写。

【规则2-5】注释准确简洁易懂。

注释放在代码的上方或右方。

【规则2-6】修改代码的同时修改注释。

4、函数设计

【建议4-1】函数功能要单一，不要设计多用途的函数。

【建议4-2】函数体规模要小，尽量控制在50行代码之内。

【建议4-3】函数原型书写形式参数名可以增加可读性。

【规则4-4】对不需要修改的指针参数和引用参数用const约束。

【规则4-5】默认参数只能从后向前挨个设置。

【规则4-6】不要使用参数传递的隐式类型转换处理数据。

【规则4-7】函数类型和函数返回类型是两个不同的概念。

【建议4-8】求值算术函数使用传值参数，用return返回计算值。

【建议4-9】功能性函数用return返回错误信息。

【规则4-10】名字相同，参数不同（包括类型、顺序不同）的函数才是重载函数。

仅仅返回值类型不同则错误。

【建议4-11】尽量用内联函数取代宏代码，提高程序执行效率。

5、程序效率

程序的时间效率是指运行速度；

空间效率是指程序占用内存或外存的状况；

全局效率是指站在整个系统的角度上考虑的效率；

局部效率是指站在模块或函数的角度上考虑的效率。

【规则5-1】在满足正确性、可靠性、健壮性及可读性等程序质量的因素下，设法提高程序的效率。

【规则5-2】以提高全局效率为主，提供局部效率为辅。

【规则5-3】找出限制效率的“瓶颈”。

【规则5-4】先优化数据结构和算法，再优化代码。

【规则5-5】在时间优化和空间优化上做出平衡。

6、一些有益的建议

【建议6-1】当心视觉上不易分辨的操作符书写错误。

例如：

==和=||&

&

<

=>

=等容易发生“丢失”

【建议6-2】变量（指针、数组）被创建后及时初始化，防止把未初始化的变量作为右值使用。

【建议6-3】当心变量初值、默认值错误，或精度不够。

【建议6-4】当心数据类型转换发生错误，尽量使用显式类型转换。

【建议6-5】当心变量发生上溢、下溢，以及数组下标越界。

【建议6-6】当心忘记编写错误处理程序，或者错误处理程序本身有误。

【建议6-7】当心文件I/O有错误。

【建议6-8】避免编写技巧性很高的代码。

【建议6-9】不要设计面面俱到、非常灵活的数据结构。

【建议6-10】重用高质量的代码；

重写质量差的代码（不要修补）。

【建议6-11】尽量使用标准库函数，不要“发明”已经存在的库函数。