我有些C++程序设计的题不会做，请大仙帮我指点，我将不胜感激，跪谢！！

#include <iostream>

#include______ //看见下面的fstream没 所以这里是#include <QStream>

using namespace std；

void main( )

{

fstream fin，fout；

fout．open("my．txt"，ios：：out)； //打开文件

if(! fout．is_open( ))

return；

for(int i=0；i<3；i=i+1) //输出line的号

fout<<"This is line"<<i+1<<endl；

fout．close( )；

fin．open("my．txt"，ios：：in)； //打开文件

if(! fin．is_open( ))

return；

char str［100］；

while(______) /把文件东西读入到str知道文件结束 所以 判断文件结束的一个东东忘记是什么函数了,哥又不是百度,哥可以查msdn至此,后面不看了,出这道题的人傻逼,肯定不是一个公司程序员!/

{

fin．getline(str，100)；

cout<<str<<endl；

}

fin．close( )；

}

50．求两个浮点数之差的cha函数的原型声明、调用方法。

#include <iostream>

using namespace std；

void main( )

{

float a，b；

______;∥函数cha的原型声明 float cha( float x, float y );

a=12．5；

b=6．5；

float c=__________；∥调用函数cha cha( a, b );

cout<<c<<endl；

}

float cha(float x,float y)

{

float w；

w=x-y；

return w；

}

后面的不看了,上面两道题第一道题够二,第二道题你自己看书就能解决

问题分析与算法设计

最简单的算法是：采用穷举法，设定4X4矩阵中每一个元素的值后，判断每一行、每一列和两条对角线上的4个数字组成的四位数是否都是可逆素数，若是则求出了满足题意的一个解。

这种算法在原理是对的，也一定可以求出满足题意的全部解。但是，按照这一思路编出的程序效率很低，在微机上几个小时也不会运行结束。这一算法致命的缺陷是：要穷举和判断的情况过多。

充分利用题目中的“每一个四位数都是可逆素数”这一条件，可以放弃对矩阵中每个元素进行的穷举的算法，先求出全部的四位可逆素数(204个)，以矩阵的行为单位，在四位可逆素数的范围内进行穷举，然后将穷举的四位整数分解为数字后，再进行列和对角线方向的条件判断，改进的算法与最初的算法相比，大大地减少了穷举的次数。

考虑矩阵的第一行和最后一行数字，它们分别是列方向四位数的第一个数字和最后一个数字，由于这些四位数也必须是可逆素数，所以矩阵的每一行和最后一行中的各个数字都不能为偶数或5。这样穷举矩阵的第一行和最后一行时，它们的取值范围是：所有位的数字均不是偶数或5的四位可逆数。由于符合这一条件的四位可逆素数很少，所以这一范围限制又一次减少了穷举的次数。

对算法的进一步研究会发现：当设定了第一和第二行的值后，就已经可以判断出当前的这种组合是否一定是错误的(尚不能肯定该组合一定是正确的)。若按列方向上的四个两位数与四位可逆数的前两位矛盾(不是其中的一种组合)，则第一、二行的取值一定是错误的。同理在设定了前三行数据后，可以立刻判断出当前的这种组合是否一定是错误的，若判断出矛盾情况，则可以立刻设置新的一组数据。这样就可以避免将四个数据全部设定好以后再进行判断所造成的低效。

根据以上分析，可以用伪语言描述以上改进的算法：

开始

找出全部四位的可逆素数；

确定全部出现在第一和最后一行的四位可逆素数；

在指定范围 内穷举第一行

在指定范围内穷举第二行

若第一、第二、三行已出现矛盾，则继续穷举下一个数；

在指定范围内穷举第四行

判断列和对角方向是否符合题意

若符合题意，则输出矩阵；

否则继续穷举下一个数；

结束

在实际编程中，采用了很多程序设计技巧，假如设置若干辅助数组，其目的就是要最大限度的提高程序的执行效率，缩短运行时间。下面的程序运行效率是比较高的。

程序说明与注释

#include<stdioh>

#include<mathh>

int number[210][5]; /存放可逆素数及素数分解后的各位数字/

int select[110]; /可以放在矩阵第一行和最后一行的素数的下标/

int array[4][5]; /4X4的矩阵，每行0号元素存可逆素数对应的数组下标/

int count; /可逆素数的数目/

int selecount; /可以放在矩阵第一行和最后一行的可逆素数的数目/

int larray[2][200]; /存放素数前二、三位数的临时数组所对应的数量计数器/

int lcount[2];

int num(int number);

int ok(int number);

void process(int i);

void copy_num(int i);

int comp_num(int n);

int find1(int i);

int find2(void);

int find0(int num);

void p_array(void);

int main()

{

int i,k,flag,cc=0,i1,i4;

printf("there are magic squares with invertable primes as follw:\n");

for(i=1001;i<9999;i+=2) /求满足条件的可逆素数/

{

k=i/1000;

if(k%2!=0&&k!=5&&num(i)) /若可逆素数的第一位不是偶数或5/

{

number[count][0]=i; /存入数组/

process(count++); /分解素数的各位数字/

if(number[count-1][2]%2!=0&& /若可逆素数满足放在矩阵第一行/

number[count-1][3]%2!=0&& /和最后一行的条件，记录可逆素数的/

number[count-1][2]!=5&& /下标，计数器加1/

number[count-1][3]!=5)

select[selecount++]=count-1;

}

}

larray[0][lcount[0]++]=number[0][0]/100; /临时数组的第一行存前二位/

larray[1][lcount[1]++]=number[0][0]/10; /临时数组的第二行存前三位/

for(i=1;i<count;i++) /将素数不重复的前二、三位存入临时数组中/

{

if(larray[0][lcount[0]-1]!=number[i][0]/100)

larray[0][lcount[0]++]=number[i][0]/100;

if(larray[1][lcount[1]-1]!=number[i][0]/10)

larray[1][lcount[1]++]=number[i][0]/10;

}

for(i1=0;i1<selecount;i1++) /在第一行允许的汇聚围内穷举/

{

array[0][0]=select[i1]; /取对应的素数下标/

copy_num(0); /复制分解的素数/

for(array[1][0]=0;array[1][0]<count;array[1][0]++) /穷举第二行/

{

copy_num(1); /复制分解的数字/

if(!comp_num(2))

continue; /若每列的前两位的组成与素数相矛盾，则试探下一个数/

for(array[2][0]=0;array[2][0]<count;array[2][0]++) /穷举第三行/

{

copy_num(2); /复制分解的数字/

if(!comp_num(3))

continue; /若每列的前三位的组成与素数相矛盾，则试探下一个数/

for(i4=0;i4<selecount;i4++) /在最后一行允许的范围内穷举/

{

array[3][0]=select[i4];

copy_num(3); /复制分解的数字/

for(flag=1,i=1;flag&&i<=4;i++) /判断每列是否可逆素数/

if(!find1(i))flag=0;

if(flag&&find2()) /判断对角线是否为可逆素数/

{ printf("No%d\n",++cc); p_array(); } /输出幻方矩阵/

}

}

}

}

}

int num(int number) /判断是否可逆素数/

{

int j;

if(!ok(number)) return 0;

for(j=0;number>0;number/=10) /将素数变为反序数/

j=j10+number%10;

if(!ok(j)) return 0; /判断反序数是否为素数/

return 1;

}

int ok(int number) /判断是否为素数/

{

int i,j;

if(number%2==0) return 0;

j=sqrt((double)number)+1;

for(i=3;i<=j;i+=2)

if(number%i==0) return 0;

return 1;

}

void process(int i) /将第i个整数分解为数字并存入数组/

{

int j,num;

num=number[i][0];

for(j=4;j>=1;j--,num/=10)

number[i][j]=num%10;

}

void copy_num(int i) /将array[i][0]指向的素数的各位数字复制到array[i]中/

{

int j;

for(j=1;j<=4;j++)

array[i][j]=number[array[i][0]][j];

}

int comp_num(int n) /判断array中每列的前n位是否与可逆素数允许的前n位矛盾/

{

static int ii; /用内部静态变量保存前一次查找到的元素下标/

static int jj; /ii:前一次查找前二位的下标，jj:前一次查找前三位的下标/

int i,num,k,p; /p:指向对应的要使用的前一次下标ii或jj/

int pcount; /pcount:指向要使用的临时数组数量的计数器/

switch(n){ /根据n的值选择对应的一组控制变量/

case 2:pcount=&lcount[0];p=&ii;break;

case 3:pcount=&lcount[1];p=&jj;break;

default:return 0;

}

for(i=1;i<=4;i++) /对四列分别进行处理/

{

for(num=0,k=0;k<n;k++) /计算前n位数字代表的数值/

num=num10+array[k][i];

if(num<=larray[n-2][p]) /与前一次最后查找到的元素进行比较/

for(;p>=0&&num<larray[n-2][p];(p)--);/若前次查找到的元素大，则向前找/

else

for(;p<pcount&&num>larray[n-2][p];(p)++); /否则向后找/

if(p<0||p>=pcount)

{

p=0; return 0;

}

if(num!=larray[n-2][p])

return 0; /前n位不是可逆素数允许的值则返回0/

}

return 1;

}

int find1(int i) /判断列方向是否是可逆素数/

{

int num,j;

for(num=0,j=0;j<4;j++)

num=num10+array[j][i];

return find0(num);

}

int find2(void) /判断对角线方向是否是可逆素数/

{

int num1,num2,i,j;

for(num1=0,j=0;j<4;j++)

num1=num110+array[j][j+1];

for(num2=0,j=0,i=4;j<4;j++,i--)

num2=num210+array[j][i];

if(find0(num1)) return(find0(num2));

else return 0;

}

int find0(int num) /查找是否为满足要求的可逆素数/

{

static int j;

if(num<=number[j][0])for(;j>=0&&num<number[j][0];j--);

else for(;j<count&&num>number[j][0];j++);

if(j<0||j>=count){ j=0;return 0; }

if(num==number[j][0]) return 1;

else return 0;

}

void p_array(void) /输出矩阵/

{

int i,j;

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

{

for(j=1;j<=4;j++) printf("%d ",array[i][j]);

printf("\n");

}

}

问题的进一步讨论

程序中大量技巧是用于尽早发现矛盾，减少循环次数，缩短运行时间。从实际效果看是相当不错的。但目前的程序仍然可以进一步优化。

当第四行设定了前三行后，尚未设定的行就没必要再使用穷举的方法，因为列方向设定好的三位数字已经限制了最后一个数字可能的取值，在可逆数中找出前三位数字与设定好的三位数字相同的素数。这些素数就是在这一列前面已设定好的三位数字的限制条件下可能的取值。此时每一列上只有不超过四个可能的取值。找出全部各列可能的取值(可能的四位可逆素数)，求出它们的交集。若交集为空，即没有共同的可能取值，则列间数据相互矛盾否满足则将交集中的数据填 入矩阵中就是题目的一个解。

算法可再进一步优化。先穷举一、二和四列的数据，然后用上面的算法来确定第三行的值，这样可进一步缩小穷举的范围，提高运行效率。

分析输出的结果。可以看出本题的基本解只有17种，每个解可通过旋转与反射获得同构的其它7个解，可以进一步改进程序，只输出17个基本解。

#include <stdioh>

int f(int a) //当a小于0时返回0,否则返回a

{

if(a<0)

return 0;

else

return a;

}

void main()

{

int gongzi,t;

double shui;

printf("请输入工资\n");

scanf("%d",&gongzi);

t=f(gongzi-2000);

switch( t ) {

case 100000: shui=t045; break;

case 80000: shui=t04; break;

case 60000: shui=t035; break;

case 40000: shui=t03; break;

case 20000: shui=t025; break;

case 5000: shui=t02; break;

case 2000: shui=t015; break;

case 500: shui=t01; break;

case 0: shui=t005; break;

}

printf("个人所得税为%f\n",shui);

}

学习编程，首先应该认认真真的学习一门语言。学习微软的，就先从VB开始，VB是比较好的入门语言，可视化的，比较简单，是非常好的入门语言。书籍最少应该准备两本，不可能一本书籍会包含VB的所有内容，在看书的时候，可以交叉的看，一本书籍中没有讲到的内容可以在另一本中看到，这样对学习是很有好处的，也能保证所学知识的完整性。学编程是一个很漫长的过程，不要着急，要理论与实践想结合，例程书籍也是很重要的，看源代码对学习也是很有帮助的，等你学完这门VB语言之后，学习别的语言是非常简单，可以尝试C语言，按照C——C++——VC的顺序学习，有助于知识的连贯性。或者学习Delphi，入门较为简单类似于VB，但比VB强大，即可作为入门又能做强、做大。 1． 明确学习目的学习编程对大多数IT业人员来说都是非常有用的。学编程，做一名编程人员，从个人角度讲，可以解决在软件使用中所遇到的问题，改进现有软件，可以为自己找到一份理想的工作添加重要得砝码，有利于在求职道路上谋得一个好的职位；从国家的角度，可以为中国的软件产业做出应有的贡献，一名优秀的程序员永远是被争夺的对象。学习编程还能锻炼思维，使我们的逻辑思维更加严密；能够不断享受到创新的乐趣，将一直有机会走在高科技的前沿，因为程序设计本身是一种创造性的工作。知识经济时代给我们带来了无限的机会，要想真正掌握计算机技术，并在IT行业里干出一番事业来，有所作为，具有一定的编程能力是一个基本条件和要求。 2． 打好基础学编程要具备一定的基础，总结之有以下几方面：（1）数学基础 从计算机发展和应用的历史来看计算机的数学模型和体系结构等都是有数学家提出的，最早的计算机也是为数值计算而设计的。因此，要学好计算机就要有一定的数学基础，出学者有高中水平就差不多了。（2）逻辑思维能力的培养学程序设计要有一定的逻辑思维能力，“逻思力”的培养要长时间的实践锻炼。要想成为一名优秀的程序员，最重要的是掌握编程思想。要做到这一点必须在反复的实践、观察、分析、比较、总结中逐渐地积累。因此在学习编程过程中，我们不必等到什么都完全明白了才去动手实践，只要明白了大概，就要敢于自己动手去体验。谁都有第一次。有些问题只有通过实践后才能明白，也只有实践才能把老师和书上的知识变成自己的，高手都是这样成材的。（3）选择一种合适的入门语言 面对各种各样的语言，应按什么样的顺序学呢？程序设计工具不外乎如下几类： 1）本地开发应用软件开发的工具有：Visual Basic 、Delphi 、VC++ ( C++ Builder ) 等；数据库开发工具有：Visual Foxpro 、Oracle Developer 、Power Builder 等。 2）跨平台开发开发工具如 Java 等。 3）网络开发对客户端开发工具如：Java Script 等；对服务器开发工具如：PHP 、ASP 、JSP 、ISAPI 、NSAPI 、CGI 等。以上不同的环境下几种开发工具中 VB 法简单并容易理解，界面设计是可设化的，易学、易用。选 VB 作为入门的方向对出学者是较为适合的。 3． 注意理解一些重要概念一本程序设计的书看到的无非就是变量、函数、条件语句、循环语句等概念，但要真正能进行编程应用，需要深入理解这些概念，在理解的基础上应用，不要只简单地学习语法、结构，而要吃透针对这些语法、结构的应用例子，做到举一反三，触类旁通。 4． 掌握编程思想学习一门语言或开发工具，语法结构、功能调用是次要的，最主要是学习它的思想。例如学习 VC 就要学习 Windows 的内在机理、什么是线程．．．．．．；学习 COM 就要知道 VTALBE 、类厂、接口、idl．．．．．．，关键是学一种思想，有了思想，那么我们就可以触类旁通。 5． 多实践、多交流掌握编程思想必须在编程实际工作中去实践和体会。编程起步阶段要经常自己动手设计程序，具体设计时不要拘泥于固定的思维方式，遇到问题要多想几种解决的方案。这就要多交流，各人的思维方式不同、角度各异，各有高招，通过交流可不断吸收别人的长处，丰富编程实践，帮助自己提高水平。亲自动手进行程序设计是创造性思维应用的体现，也是培养逻辑思维的好方法。 6． 养成良好的编程习惯编程入门不难，但入门后不断学习是十分重要的，相对来说较为漫长。在此期间要注意养成一些良好的编程习惯。编程风格的好坏很大程度影响程序质量。良好的编程风格可以使程序结构清晰合理，且使程序代码便于维护。如代码的缩进编排、变量命令规则的一致性、代码的注释等。 7． 上网学编程在网上可以学到很多不同的编程思想、方法、经验和技巧，有大量的工具和作品及相关的辅导材料供下载。例如网站“编程课堂”（ >

;     由于自学ks的社会性，为了体现公正和公平，试题不能像本科院校中常见的那样重复使用。自学ks的试卷内容有广泛且分散的特点，这要求考生必须全面地复习教材的内容。

1单项选择题

试题中的单项选择题中的多数试题涉及整本教材介绍的概念和知识点。为解答这类试题，要求考生要熟练地掌握和熟记大纲中指出的“识记”和“领会”的内容。考生应摘出教材中有关c语言的重要概念、定义、有关语言成分性质的叙述，对它们深入的理解和熟记，并对语言的一些基本规定能作简单的应用。清考生注意，理解、熟记和大段地背诵的区别。由于考题表现形式的多样性，理解是最重要的，仅对关键性的概念才有准确熟记的必要，多数的概念因是理解，并要求能熟练应用。试题通常要求对某个概念、术语或计算结果作出判断，或对一些规定作简单的应用等。由于计算机科学是一门新兴学科，许多概念还没有唯一性的定义，不同书籍由于出发点或论述领域不同，同一概念会有不同的说法，为此考生在复习迎考时，不要脱离指定自学ks教材，而从其它教材出发进行复习。

「例1」设有以下代码定义字符数组c和字符指针变量pc：

char c[10]=“abed”，pc＝c；

问（pc＋4）的值。供选择的答案有：

①“abcd‘   ②'\0'    ③ ' d'         ④不能确定

上述代码使字符数组c的前5个元素依次为：c[0]＝‘a’c[1]＝‘b’， c[2]＝‘c’， c[3]= ‘d'，c[4]＝’＼0‘。初始化pc＝c使字符指针变量pc指向c数组的首元素c[0]而表达式pc＋4的值是c[4]的指针。因此，表达式（pc＋4）就是引用c[4]所以问题的解答为②。

「例2」指出下列说法中错误的叙述。

①构成数组的所有元素的数据类型必须是相同的

②用指针法引用数组元素允许数组元素的下标越界

③一维数组元素的下标为1，2，3，……

④定义数组时的长度可以是整型常量表达式

由数组的概念知，数组的全部元素有相同的数据类型，另在定义数组时，需指出数组的元素个数，指定数组元素个数的表达式必须在编译时可计算的，即只允许是常量表达式，不可以含有变量。所以①和④是正确的叙述，不是问题要求的解答。在c语言中，当指针指向数组的某元素（不一定是数组的首元素）时，可利用该指针加减一个整表达式，构成指针表达式指向数组的某元素，然后用取内容运算符。间接引用指针表达式所指的数组元素。如有代码：

int a[100]， p；

表达式p＝＆a「20］使p指向a[20]，，通过p引用数组a[l]，可用表达式（p-19）。由c语言的约定，当指针指向数组某元素时，用指针表达式引用它所指的数组的某元素也可写成等价的下标引用形式，如表达式（p-9）可以等价地写成p[-19]这里-19是一个负整数，所以叙述②也是一个正确叙述。这种表示方法是借用下标表示法，与指针加减的整表达式引用数组元素，其中加减的整数实际不是数组元素的下标。还需要指出一点，指针与整表达式和的新指针不应该指向数组之外的别的地址。如前述的例子中指针变量p指向a[20]，表达式（p+n）中的 n要求不能小于 20，也不能大于 79最后，c语言规定数组元素的下标从0开始顺序编号，所以选择③才是错误的叙述。

2填充题

填充题要考核的内容与选择题的考核内容基本相同，但考核的形式不同。填充题的试题多数是从基本概念儿语言关于数据类型、程序对象、程序结构等的规定、c程序设计基本技巧等引伸的具体应用。如c语言规定每个字符占一个字节，每个字符串除存储它所包含的字符外，在字符串最后一个字符之后还存有一个字符串结束符。对于这样两个基本概念和规定，填充题可能是问具体的一个字符和一个字符串各占多少个字节等。因填充题是概念或规定的具体应用，解答的难度也就比选择题的要大，不可能有猜得分的机会。

「例3」下列函数的功能是统计并返回形参指针s所指向的字符串所含字符‘a’的个数。试完成程序，写出应填写在程序空框中的代码。

int counts（char s）

{ int n；

for（ n＝0；。 ； s＋＋）

if（s＝＝‘a’）n＋＋；

return n；

}

为统计字符指针s所指字符串包含的某字符的出现次数，必须用一个循环顺序考察整个字符串。由从指针s所指字符串的首字符开始，每考察一个字符后，指针s后移一个字符位置，考察循环直至字符率结束终止。所以填写在空框中的正确代码可写成 s！ ＝‘＼ 0’。由于字符串束符‘＼ 0’的代码为 8位全0，其值为 0，正确解答也可写成 s！＝ 0，或更简洁地写成s

「例4」在内存中存储‘a’要占用____字节，存储“a”又要占用____字节。

由于c语言规定字符只占1个字节，一个具体的字符当然也只占1个字节。字符串“a”要有1个字节用于存储字符‘a’，另需要1个字节存储字符串的结束符，所以它要占用连续的2个字节。

「例5」设整型变量a、b的值均为3，执行语句：

b＝ a＋＋， b＋＋， ＋＋a；

后，a的值为____，b的值为____

该试题的表达式书写形式一般不会直接出现在实际应用程序中，但作为考核考生对有关表达式的计算规则，也不失为是一个很有意义的试题。赋值表达式自右至左计算，而逗号运算符的优先级最低，并且逗号表达式自左至右逐一计算，并以最后子表达式的值为逗号表达式的结果。上述表达式的计算顺序可用以下3个表达式语句等价表示：

b＝a＋＋；b＋＋；＋＋a；

由以上一系列表达式知，变量b的最终值与其原来值无关，表达式b＝ a＋十是先计算a＋＋。表达式a＋十的值是变量a的原先值3，但又让变量a增1后变为4然后表达式b++又使变量b增1，变成4而计算++a的值，是让a增1，使a的值变为5所以上述表达式使变量a的值变为5，b的值变为4

如上述表达式改写为：

b＋＝（a＋＋，b＋＋，＋＋a）；

请读者回答执行该表达式后，变量a和b的值又分别为多少。

3程序分析题

程序分析题要求考生阅读程序，回答程序的输出结果，或指出程序的功能。回答这类问题，要求考生将自己当作一台假想的计算机，模拟执行序。

对于这类试题常有两种可用的方法。一是从程序的初值、循环结构、条件等发现程序的规律厂是完全从模拟执行出发读程序，求出程序的输出结果。如采用后一种方法，由于程序执行的动态性，程序中的有关变量，随着程序的执行，变量的值就会不断变化。一般来说，随时记住全部变量的当前值是非常困难的。一个行之有效的方法是用一个变量表，将程序中的全部变量罗列在该表中，某个变量值的变化记录在该变量当前值的栏中，这样就能方便地列出各个变量的动态变化过程。在这里，考生要当心函数形参及函数的局部变量与实参变量及程序的外部全局变量同名的情况。为了区别它们，对于函数形参和局部变量可以标上它所属的函数名，以与同名的实参变量及外部全局变量相区别。由于试题程序总是完成某种有一定意义的计算工作。一般来说，程序的执行过程舍有某种规律存在。如能找出程序的规律，就不需要逐句阅读程序的语句，能直接导出程序的结果。程序的规律从以下几个方面着手：有关变量的初值，特别是数组的初值；程序的循环控制结构，特别是遍历数组的循环，它的循环控制变量将控制数组元素下标的变化；循环体中的语句的条件，一般条件有两种形式，一种是由数组元素值的大小描述，另一种是由元素的下标值描述，前者用于对其值满足某种条件的元素进行指定的计算，后者用于对满足条件的某些位置上的元素进行指定的计算。

最容易出题，变化也最多的是数组（包括字符串）处理程序，正确解答这类试题要熟练掌握两点：一是引用数组元素的两个等价方法，即用数组首元素指针（数组名）和下标引用数组元素，及通过指向数组元素的指针间接引用数组的元素；二是一些常用的简单算法，如数组或字符串遍历、插入元素或删除元素，以及常用的排序方法等。对于文件处理程序，要注意文件当前的读/写位置，即对于读文件，注意当前读人的数据及前读头位置；对于写文件，要注意当前写入的数据。另外要特别指出的是，通过读程序，能发现程序执行的规律是非常有用的技术。但这个技术的掌握是建立在熟读大量的程序和自己编写过大量程序的基础上的。如一个程序是对数组的前n个元素执行某种 *** 作。考生在阅读这种程序时，不妨假定输入的n值为4或5，将n等于4或5的结果类推到任意的n

「例6」阅读下列程序，写出程序运行后的输出结果。

＃ include <stdioh>

main（）

{int a[][3]={1，2，3，4，5，6，7，8，9}；

int i，j，s1＝ 0，s2＝ 0；

for（i= 0；i<3， i++）

for（j＝0；j<3；j++）{

if（i＝＝j）sl+＝a[i][j]；

if（i+j==2） s2+=a[i][j]；

}

printf（“sl＝%ds2=%d\n”， sl，sz）；

}

首先将二维数组a的初值写成每行3个元素，由于程序只提供9个初值，a只有3行：

1 2 3

4 5 6

7 8 9

程序用a[i][j]引用a的元素，所以外循环i是控制行的循环，内循环j是控制列的循环，这两重循环控制遍历整个数组 a的全部元素。条件 i==j表示当行下标与列下标相等时，即是 a的主对角钱上的元素时，将它们累计到变量s1，所以s1的值为15条件i+j==2用于控制行下标与列下标之和为行列下标之和为某个常数的元素是同在某条右高左低斜线上的元素。对于3行3列的二维数组来说，就是副对角线上的元素。将这些元素累计于变量s2，所以s2的值也是15

「例7」阅读下列程序，简述程序的主要功能。

main（）

{ int i，s[10]，p=&s[9]；

for（i=0；i<10；i++） scanf（“%d”，&s[i]）；

for（；p>=s；p——） print（“%d”，p）；

printf（“\n ）；

}

程序中定义的变量i用于循环控制，数组s用于存储读人的整数，指针变量p的初值指向数组s的末元素。程序的第一个循环用于顺序输入数组s的10个元素的情。从程序的第二个循环代码知，每循环一次，指针p减1，即指向数组的前一个元素，循环条件直至循环处理了数组的首元素后结束，循环体只是简单地输出指针当前所指的数组元素。所以该循环实现从数组的末元素开始逆序遍历数组输出。这样程序的功能可简述如下：

“顺序输入10个整数，并逆序输出它们的值。”

4程序设计题

程序设计题是给出问题，要求考生自己独立编写程序。考生平时认真参加上机实习，自己编写程序，是能解答这类试题的基本条件。多数考生学了程序设计以后，能基本了解教材的内容，能解答大部分前述三种类型的试题，平时还能指出别人程序的错误，但由于很少自己动手，或不知道从何着手编写程序等原因，自己还一直不会编程序。简单程序的设计通常要包含两个步骤：首先是设想计算方法，即用什么方法来解决给定的计算问题；其次是将求解方法告诉计算机，命令计算机怎么做。第一步工作人们采用常人的思维习惯，而第二步工作必须采用计算机的思维习惯。对于程序设计的初学者来说，最困难的可能还是很难适应计算机程序的思维习惯，人们几乎无法承受程序必须将要计算机完成的计算过程描述得几乎绝对的精细和精确。但对计算机来说，这又是非常必要的。编写程序就是在向计算机讲话，非常精确地告诉计算机怎么做。

「例8」编一个程序，从名为“texttxt”的文本文件中读取一个字符显示在屏幕上。

本例题要求实现最简单的文件处理。如考生知道文件处理程序的编写要点，就能方便地写出程序。

文件处理程序有以下几个要点：

（l）在程序的开始处，用包含预处理命令，包含标准文件stdioh定义文件指针变量和存储文件名的字符数组。如以下代码所示：

＃ include<stdioh>

file fp  / 定义文件指针变量 fp/

char fname「40」＝“某文件名”；

（2）如文件名在程序执行时输入，可用以下代码：

prinif（“请输入文件名（包括文件的目录路径、文件的扩展名）\n）；

scanf（“%s%c”，fname）；/输入文件名及其随后的回车符。/

（3）使用文件前，必须先打开文件，常用的有两种打开方式：

老文件打开为了让程序从正文文件输入数据，用读方式打开，则用以下代码：

if（（fp＝fopen（fname，“r‘’））== null） {/ 为读打开/

printf（“%s文件不能打开，结束程序的执行\n”，fname）；

return；

}

若文件打开为了让程序向正文文件输出数据，则用以下代码：

fp=fopen（fname，“w”）；/为写打开/

读打开时，要求被打开文件已存在。写打开时，若被打开文件不存在，则建立一个以fname内容命名的新文件；若被打开文件已存在，则该文件上的数据被删除。

（4）文件使用结束后，要及时关闭，如以下代码所示：

fclose（fp）；/ 以后中又可用于打开文件。/

（5）调用有关文件输入输出库函数。最经常使用的有：

调用函数 fgetc（）从文件输入下一个字符，如：

ch＝ fgetc（fp）；/将输入字符存于变量 ch/

调用函数fscanf（）从文件按指定格式输入数据，如：

fscanf（fp，“%d%d”，&k，&j）；/从文件输入两个整数分别存于k和j/除在第一位置增加一个文件指针变量实参外，其余与函数scanf（）的用法全相同。

调用函数fputc（）向文件输出一个字符，如：

fputc（ch，fp）；/将变量ch中的字符输出到文件。/

调用函数fprintf（）向文件按指定格式输出数据，如：

fprintf（fp，“%d%d\n”，k，j）；

该函数调用是按格式要求将k和j的值输出到文件。除在第一位置增加一个文件指针变量实参外，其余与函数prinif（）的用法全相同。

（6）从正文文件逐一输入字符，作某种处理的程序结构为：

int c；/若要用eof测试文件结束，则不能为char类型/

file fp；

……/说明有关变量和设置初值等/

if（（fp＝fopen文件名，“r”））==null）{/以输入方式打开/

printf（“不能打开文件%s/n”，“文件名字符列”）；

return；

}

while（（c=fgetc（fp））！= eof）{

……/ 这里对刚读人的字符信息c作某种处理/

}

fclose（fp）；

……/ 输出处理结果/

（7）字符逐一生成输出，形成新文件程序的一般结构形式有：

int c；/也可以是 char类型/

对于本例题，只要包含上述（1）、（3）、（5）和（4）即可，写成完整程序如下：

＃ include<stdioh>

filefp；/定义文件指针变量 fp/

char fname[40]=“texttxt”；

main（）

{char c；/或 int c/

if（（fp= fopen（fname，“r”））＝＝ null）{ /为读打开/

printf（“%s文件不能打开，结束程序的执行\n”，fname）；

return；

}

c=fgetc（fp）；/将从文件输入的字符存于变量c/

printf（“%c\n”， c）；

fclose（fp）；/中所指文件关闭/

}

「例9」编写函数f，该函数没有浮点型数组形参float[]和整型形参n，函数的功能是计算并返回p[]中前n个元素的平均值。由于函数返回已知数组的平均值，函数的头有以下形式：

float f（ float p[]， int n）

函数为了计算平均值，需要两个计算步骤，首先是求出数组元素之和，然后将求得的和除以元素个数。严格地说，函数还因防止形参n小于等于0的情况，假定当n小等于0时，函数返回0值。为求数组元素和，需要一个存储和的变量（例如说s）。求和通过遗历数组实现，有两种实现方法：

一是引入一个循环控制变量（例如说i），并让 i作为弓佣数组元素的下标（如 p[i]）。所以有以下代码：

float f（float p［］， int n）

｛ int i； float s；

if（n<=0）return 00；

for（ s＝00， i＝0； i<n； i++） s+= p[i]；

return s/n；

}

二是由于函数的数组形参实际是一个指针变量，遍历数组直接可用指针形参p实现。循环次数可让变量 j控制， j的初值为 n，每次循环后让 j减 1，循环直至 j为 0结束。写成 c代码如下：

float f（ float p[]， int n）

｛ floa s； int j=n；

if（ n<=0） return 00；

for（ s＝00； j>0； j——） s+=p++；

return s/n；

}

每个人都在知道，知识改变命运，无论在任何时候知识都是非常重要的。

在IT行业中，知识是不断更新变化的，对于Java程序员来说，在技术不断更新的同时，自己也是需要不断的充电，这样才能在行业里面站稳脚跟。

程序员想要进步是离不开学习的，在学习过程中应该掌握哪些小技巧呢？下面广州电脑培训为大家具体介绍。

一、一定要看书学习Java，前期学习和后期学习的情况是不同的，后期学习会变得更加容易一下。

在学习的过程中，很多人发现能够选择的学习方法是非常多的，视频学习、培训学习和看书学习等多种方法，每个人适合的学习方法是不同的，应该如何把Java学习变得越来越简单呢？Java程序开发学习的不只是皮毛，想要成为高手，任何一点细节的内容都不能错过。

其实书籍的学习才是最好的载体，书籍里面蕴含的知识是非常丰富的，IT培训认为通过看书能让自己变得更加聪明，并且编写代码更加流畅。

二、编程学会独立思考在这个网络发达的时代中，很多人都知道不会的可以问百度，对百度的依赖性是非常大的。

但是在查百度的过程中，要知道如何把查看的东西变成自己的，比如一个简单的JBDC的初级问题，在编程的过程中是经常使用的，如果每一次使用都需要去百度查找，那么想要掌握编程是不可能的。

一般情况下，经常使用的东西应该铭记于心，并且能够做到信手拈来的效果，这才是一个高手应该具备的能力。

三、了解算法，不断优化程序想要快速掌握Java开发，最重要的就是不断的练习和学习，在学习过程中无论自己学到那个程度，都需要不断的优化自己编写的程序，程序的优化对后期的使用有很大的帮助。

并且广州北大青鸟认为在进入后期时，应该注重算法的了解，根据算法进行优化，这能让程序更加完美。

四、任何一个程序都需要进行改进学习是一个非常漫长的过程，在开始学习的时候，每个人都会编写一些简单的程序，前期编写的小程序是非常简单的，仅仅能够实现一些简单的功能。

随着自己技术的不断加深，我们可以在这个程序上面实现更多的内容，知道程序达到完善，这样程序的性能才能达到最佳。

五、在学习过程中积累经验，学会总结在学习的时候，最忌讳的就是一把抓，最后可能什么都抓不到。

在学习过程中，最重要的就是学会总结，把自己学习的思路、遇到的问题和解决的方法记录下来，并且还需要记下在整个学习过程中自己积累的经验和技巧。

在北大青鸟广州计算机学院学习的过程中，你会发现这样的积累能够让你得到很快的成长。

以下是基于冒泡排序算法对10个数组元素按从小到大进行排序的示例代码：

```

#include <stdioh>

void bubble_sort(int array[], int n);

int main() {

int numbers[10] = { 1, 8, 4, 9, 6, 7, 2, 5, 3, 10 };

int i;

printf("Original array: ");

for (i = 0; i < 10; i++) {

printf("%d ", numbers[i]);

}

bubble_sort(numbers, 10);

printf("\nSorted array: ");

for (i = 0; i < 10; i++) {

printf("%d ", numbers[i]);

}

return 0;

}

void bubble_sort(int array[], int n) {

int i, j, temp;

for (i = 0; i < n - 1; i++) {

for (j = 0; j < n - i - 1; j++) {

if (array[j] > array[j + 1]) {

temp = array[j];

array[j] = array[j + 1];

array[j + 1] = temp;

}

}

}

}

```

注释：

- `bubble_sort`函数使用冒泡排序算法对数组进行排序。

- 外部循环从0到n-1，指定要进行n-1次排序，因为我们需要比较相邻的元素。

- 内部循环从0到n-i-1，因为在每次迭代i时，我们都会放置最大的元素在数组的最后面。

- 如果array[j]>array[j + 1]，则交换它们的位置。

在此示例中，我们将数据固定在代码中，但您可以在代码中询问用户要排序的数字。

以上就是关于我有些C++程序设计的题不会做，请大仙帮我指点，我将不胜感激，跪谢！！全部的内容，包括:我有些C++程序设计的题不会做，请大仙帮我指点，我将不胜感激，跪谢！！、高手们，帮忙啊，c语言程序设计、请求各位C语言好的师兄师姐了，今年我才接触C语言，这个弄不懂啊！等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！