程序填空完成功能：求分数序列2/1,3/2,5/3,8/5,13/8 ……的前20项之和。 #include ＜iostream＞ using namespace std; int main（) { double i,n=1,m=1,t,s=0 ; for （i=1;i＜=20;i++) { t = n ; n = m ; 【】; s = s + m/n ; } cout＜＜s＜＜endl; return 0; }

题目

相似考题

1.在下面程序横线处填上适当内容,使得程序的输出为9876。include using namespace std;te在下面程序横线处填上适当内容，使得程序的输出为9876。include ＜iostream＞using namespace std;template＜class T＞void f(【】){T t;for (int i=0;i＜n/2;i++){t=a Ii];a [i]=a[n-1-i];a [n-1-i]=t;}}int main ( ){int x[]={6,7,8,9};f(x,4);for (int i=0;i＜4;i++)cout＜＜x[i];cout＜＜end1;return 0;}

2.阅读下面程序: include int fun2(int m) { if(m%3==0) return 1; else return 0; }阅读下面程序：include ＜iostream.h＞int fun2(int m){if(m%3==0)return 1;elsereturn 0;}void fun1(int m, int &s){int i;for (i=1; i＜m; i++)if(fun2(i))S=S*i;}void main(){int n=9, s=2;fun1(n, s);cout＜＜s＜＜end1;}该程序的运行结果是【】。

3.以下程序的输出结果是【】。 include using namespace std; int main() {int s,i;for(s=以下程序的输出结果是【】。include ＜iostream＞using namespace std;int main(){int s,i;for(s=0,i=1;i＜3;i++)s+=i;cout＜＜s＜＜end1;return 0;}

4.下面程序的运行结果是【】。 include using namespace std; class count{ static int n;下面程序的运行结果是【】。include ＜iostream＞using namespace std;class count{static int n;public:count(){n++;}static int test(){for(int i=0;i＜4;i++)n++;return n;}};int count::n = O;int main(){cout＜＜count:: test()＜＜" ";count c1, c2;cout＜＜count:: test()＜＜endl;return 0;}

更多“程序填空完成功能：求分数序列2/1,3/2,5/3,8/5,13/8 ……的前20项之和。 #include ＜iostream＞ using namespace std; int main（) { double i,n=1,m=1,t,s=0 ; for （i=1;i＜=20;i++) { t = n ; n = m ; 【】; s = s + m/n ; } cout＜＜s＜＜endl; return 0; }”相关问题

第1题：

有以下程序:include using namespace std;class sample{private: int n;public: samp

有以下程序： #include ＜iostream＞ using namespace std; class sample { private: int n; public: sample(){} sample (int m) { n=m; } sample add(sample s1,sample s2) { this-＞n=s1.n+s2.n; return (*this); } void disp() { cout＜＜"n="＜＜n＜＜end1; } }; int main () { sample s1(10) ,s2(5),s3; s3.add(s1,s2); s3.disp(); return 0; } 程序运行后，输出的结果是( )。
A．n=10
B．n=5
C．n=20
D．n=15

正确答案：D
解析：本题考核this指针的应用。本程序中，sample类的add成员函数中使用了this指针，this指针指向当前对象自身，该成员函数中的语句“this-＞n=s1.n+s2.n；”用于修改当前对象的数据成员n的值，语句“return(*this)；”用于返回当前对象自身，即对当前对象进行了修改。对于主函数调用add()成员函数语句“s3.add(s1，s2)；”。此时，this指针指向的是对象s3，执行该语句前，s3的数据成员n未赋值，执行完该语句后，就修改了s3的私有成员n的值，使其为15。
第2题：

若有以下程序:include using namespace std;int f(){static int i = O;ints= 1;s＋=i;

若有以下程序：#include ＜iostream＞using namespace std;int f(){ static int i = O; ints= 1; s+=i; i++; return s;}int main(){ int i, a =0; for(i=0;i＜5;i++) a+=f(); cout＜＜a＜＜end1; return 0;}程序运行后，输出的结果是( )。
A．20
B．24
C．25
D．15

正确答案：D
第3题：

有以下程序:include using namespace std;int main ( ){ int n[3],i,j,k = 2; for(i

有以下程序: #include ＜iostream＞ using namespace std; int main ( ) { int n[3],i,j,k = 2; for(i = 0;i＜k;i++) n[i] = O; for(i = O;i＜k;i++) { for(j = O;j＜k;j++) n[j] = n[i] + 1; } cout＜＜n [0 ] ＜＜end1; return 0; } 上述程序运行后，输出结果是( )。
A．0
B．1
C．2
D．3

正确答案：D
解析：本题考核数组的定义、初始化及其使用。根据程序逐步分析：程序首先给数组n的所有元素赋初值0，然后执行一个嵌套的循环结构。嵌套循环的执行过程如下：①i=0时，j分别取值0、1，使得n[0]、n[1]的值分别变1、2，内层循环结束。②i=1时，对外层循环进行判断，符合循环条件，执行内层循环，j分别取值0、1，使得n[0]、n[1]的值变为3、3，退出内层循环。③i=2时，判断外层循环，不再符合循环条件，退出外层循环，执行cout语句，输出n[0]的值为3。
第4题：

若有以下程序:includeusing namespace std;int f(){ static int i=O; int s=1; s＋=i;

若有以下程序： #include＜iostream＞ using namespace std； int f() { static int i=O； int s=1； s+=i； i++； return s； } int main() { int i，a=0； for(i=0；i＜5；i++) a+=f()； cout＜＜a＜＜endl； retrun 0； } 程序运行后，输出的结果是
A．20
B．24
C．25
D．15

正确答案：D
解析：本题考核静态局部变量在函数中的使用。静态局部变量就是将局部变量说明为静态的。静态局部变量既有在局部域作用的特性(即变量只能在变量的作用范围内被访问)，又可以永久存在(变量的值得以保留，并可继续使用)。静态局部变量只在第一次执行时初始化一次。在函数f中定义了一个静态局部变量i，它的初始值为0，还定义了一个局部变量s(它的初始值为1)，用来返回计算所得值。函数f中所进行的数据加工是s+=i和i++。即每调用一次函数f，返回(i+1)的值后，i的值增1。再看主函数，在主函数main中，通过一个for语句连续调用f函数5次，并把每次调用f函数的返回值相加并存入a。最后输出a的值。在了解各函数功能以及调用关系后就可计算出a的值为15。
第5题：

若有以下程序: include using namespace std;int f(){static int i = 0;ints= 1;s＋=i

若有以下程序： #include ＜iostream＞ using namespace std; int f() { static int i = 0; ints= 1; s+=i; i++; return s; } int main() { int i,a = 0; for(i = 0;i＜5;i++) a+=f(); cout＜＜a＜＜endl; return 0; } 程序运行后，输出的结果是
A．20
B．24
C．25
D．15

正确答案：D
解析：本题考核静态局部变量在函数中的使用。静态局部变量就是将局部变量说明为静态的。静态局部变量既有在局部域作用的特性(即变量只能在变量的作用范围内被访问)，又可以永久存在(变量的值得以保留，并可继续使用)。静态局部变量只在第一次执行时初始化一次。在函数f中定义了一个静态局部变量l它的初始值为0，还定义了一个局部变量s(它的初始值为1)，用来返回计算所得值。函数f中所进行的数据加工是s+=i和i++。即每调用一次函数f，返回(i+1)的值后，i的值增1。再看主函数，在主函数main中，通过一个for语句连续调用f函数5次，并把每次调用f函数的返回值相加并存入a。最后输出a的值。在了解各函数功能以及调用关系后就可计算出a的值为15。
第6题：

以下程序的输出结果是 include void reverse(int a[ ] ,int n) { int i,t;for(i=0

以下程序的输出结果是
#include＜iostream.h＞
void reverse(int a[ ] ，int n)
{ int i,t;
for(i＝0;i＜n/2;i＋＋)
{t＝a[i] ;a[i] ＝a[n－1－i] ;a[n－1－i] ＝t;}
}
void main( )
{ int b[10] ＝{1,2,3,4,5,6,7,8,9,10};int i,s＝0;
reverse(b,8) ;
for(i＝6;i＜10;i＋＋) s＋＝b[i] ;
cout ＜＜ S;
}
A．22
B．10
C．34
D．30

正确答案：A
解析：在main函数中，调用reverse函数将b数组中的前8个成员进行互置，执行完毕后，b数组中的成员为{8,7,6,5,4,3,2,1,9,10}，在执行for循环结构后，将b[6] ,b[7] ……b[9] 的值相加，结果为 1＋2＋9＋10＝22。注意:在计算累加和时，应将累加变量赋值为零。
第7题：

假定n=3,,下列程序的运行结果是()。includeint Fun(int m)void main(){cout<<"Pleas

假定n=3，，下列程序的运行结果是( )。 #include＜iostream．h＞ int Fun(int m) void main() { cout＜＜"Please input a number:"； int n,s=0； cin＞＞n； s=Fun(n)； cout＜＜s＜＜endl； } int Fun(int m) { iht p=1,s=0； for (int I=1；I＜=m；I++) { p*=I； S+=p； } return s； }
A．7
B．9
C．8
D．10

正确答案：B
第8题：

有如下程序:includeusing namespace std;int s=0;class sample{ static int n;public

有如下程序： #include＜iostream＞ using namespace std； int s=0； class sample { static int n； public： sample(int i) { n=i； } static void add() { s+=n； } }； int sample：：s=0； int main() { sample a(2)，b(5)； sample：：add()； cout＜＜s＜＜endl； return 0； } 程序运行后的输出结果是
A．2
B．5
C．7
D．3

正确答案：B
解析：本题考核静态数据成员和静态成员函数的应用。程序中定义一个类sample，它包括一个静态数据成员n和一个静态成员函数add，并在类的构造函数中给类私有静态数据成员n赋值。在主函数main中，定义对象a(2)时，通过构造函数使静态数据成员n的值变为2，在定义对象b(5)时，通过构造函数使静态数据成员n=5(覆盖了前面的n=2)，再执行sample：：add()使全局变量s=5。
第9题：

有以下程序:include using namespace std;class sample{private:int n;public:sample

有以下程序： #include ＜iostream＞ using namespace std; class sample { private: int n; public: sample(){} sample(int m) { n=m; } void addvalue(int m) { sample s; s.n=n+m; *this=s; } void disp () { cout＜＜"n="＜＜n＜＜endl; } }; int main() { sample s (10); s.addvalue(5); s.disp(); return 0; } 程序运行后的输出结果是
A．n=10
B．n=5
C．n=15
D．n=20

正确答案：C
解析：本题考核this指针的应用。上述程序中sample类定义了一个addvalue非静态成员函数。addvalue函数的原型是：void addvalue(sample *this,int m);，该函数的第一个参数是执行该类对象的一个指针即this指针。由于这个参数是系统隐含的，所以我们在定义该成员函数时并没有看到这样一个参数。在成员函数的定义体中，可以通过this访问这一参数。上述程序的最后输出结果是15。
第10题：

若有如下程序:includeusing namespace std;int s=0;class sample{static int n;pubic

若有如下程序： #include＜iostream＞ using namespace std； int s=0； class sample { static int n； pubic： sample(int i) { n=i； } static void add() { S+=n； } }； int sample::n=O； int main() { sample a(2),b(5)； sample::add()； cout＜＜s＜＜endl； return 0； } 程序运行后的输出结果是( )。
A．2
B．5
C．7
D．3

正确答案：B
第11题：

有以下程序:include using namespacestd;class sample{private:int n:public:sample

有以下程序： #include ＜iostream＞ using namespace std; class sample { private: int n: public: sample () {} sample(int m) { n=m; } sample add(sample s1, sample s2) this-＞n=s1.n+s2.n; return (*this); } void disp () { cout ＜＜"n="＜＜n＜＜end1; } }; int main() sample s1(1)0,s2(5),s3; s3.add(s1,s2); s3.disp(); return 0; } 程序运行后，输出的结果是
A．n=10
B．n=5
C．n=20
D．n=15

正确答案：D
解析：本题考核this指针的使用。类成员函数add中通过this指针实现私有数据成员n的赋值。
第12题：

下面程序的功能是()。include include using namespace std;int main (){ in

下面程序的功能是( )。 #include ＜iostream＞ #include ＜string＞ using namespace std; int main () { int i=1, n=0; char s[80],*p; p=s; strcpy(p,"It is a book.."); for (; *p !=' \0' ;p++) { if(*p=='') i=0; else if (i==0) { n++; i=1; } } cout＜＜"n=" ＜＜n＜＜end1; return 0; }
A．统计字符串中的单词个数
B．统计字符串中的空格个数
C．统计字符串中的字母个数
D．统计字符串中的全部字符个数

正确答案：B
解析：本题通过for循环对字符串进行扫描，遇到'＼0'结束扫描。程序首先将i的值置为1，n的值置为0。在for循环中，通过if语句判断*p指向的字符是否为空格，如果是空格则将i的值置为0，而在elseif语句，如果i的值为0，则n++，然后将i的值重新置为1。如此反复，最后统计出字符串中的空格个数。
第13题：

以下程序的输出结果是includevoid reverse(int a[],int n){ int i ,t; for(i=0;

以下程序的输出结果是 #include＜iostream．h＞ void reverse(int a[]，int n) { int i ，t； for(i=0;＜n/2;i++) { t=a[i]=a[i] =a[n-1-i]；a[n-1-i]=t；} } void main() { int b[10]={1，2，3，4，5，6，7，8，9，10}；int i，s=0； reverse(b，8)； for(i=6;i＜10;i++)s+=b[i]； cout＜＜s； }
A．22
B．10
C．34
D．30

正确答案：A
解析：在main函数中，调用reverse函数将b数组中的前8个成员进行互置，执行完毕后，b数组中的成员为{8，7，6，5，4，3，2，l，9，10}，在执行for循环结构后，将b[6]，b[7]……b[9]的值相加，结果为l+2+9+10=22。注意：在计算累加和时，应将累加变量赋值为零。
第14题：

以下程序的输出结果是 ( )。 include using namespace std; int f(int b[],int m, in

以下程序的输出结果是 ( )。 #include ＜iostream＞ using namespace std; int f(int b[],int m, int n) { int i,s = O; for(i = m;i＜n;i+=2) s+=b [i]; return s; } int main ( ) { int x a[] = {1,2,3,4,5,6,7,8,9}; x = f(a,3,7); cout＜＜x＜＜end1; return 0; }
A．10
B．18
C．8
D．15

正确答案：A
解析：本题考查对数组以及数组作为函数参数的掌握程度。本题通过参数传递将数组a传给f()函数中的数组b，并由s传递返回值给主函数中的x。主函数中，x=f(a,3,7)，即把数组a传给f()函数中的数组b，把3传给m，把7传给n。所以函数f()中的for循环中，是从3开始循环，经过两次循环后，实现a[3]和a[5]值的累加，并存入s中，然后返回给主函数中的x。所以x的值为10。故本题答案是A。
第15题：

若有以下程序:include using namespace std;int f(){static int i = 0;int s = 1;s＋=

若有以下程序： #include ＜iostream＞ using namespace std; int f() { static int i = 0; int s = 1; s+=i; i++; return s; } int main() { int i,a = 0; for(i = 0;i＜5;i++) a+=f(); cout＜＜a＜＜endl; return 0; } 程序运行后，输出的结果是
A．20
B．24
C．25
D．15

正确答案：D
解析：本题考核静态局部变量在函数中的使用。静态局部变量就是将局部变量说明为静态的。静态局部变量既有在局部域作用的特性(即变量只能在变量的作用范围内被访问)，又可以永久存在(变量的值得以保留，并可继续使用)。静态局部变量只在第一次执行时初始化一次。在函数f中定义了一个静态局部变量i，它的初始值为0，还定义了一个局部变量s(它的初始值为1)，用来返回计算所得值。函数f中所进行的数据加工是s+=i和i++。即每调用一次函数f，返回(i+1)的值后，i的值增1。再看主函数，在主函数main中，通过一个for语句连续调用f函数5次，并把每次调用f函数的返回值相加并存入a。最后输出a的值。在了解各函数功能以及调用关系后就可计算出a的值为15。
第16题：

以下程序的输出结果是includevoid reverse(int a [ ] ,int n){int i,t;for(i=0;i

以下程序的输出结果是 #include＜iostream.h＞ void reverse(int a [ ] ，int n) {int i,t; for(i=0;i＜n／2;i++) {t=a[i]；a[i]=a[n-1-i]；a[n-1-i]=t;} } void main( ) {int b[10]={1，2，3，4，5，6，7，8，9，10}；int i，s=0； reverse(b，8)； for(i=6；i＜10;i++)s+=b[i]； cout ＜＜ S； }
A．22
B．10
C．34
D．30

正确答案：A
解析：在main函数中，调用reverse函数将b数组中的前8个成员进行互置，执行完毕后，b数组中的成员为{8，7，6，5，4，3，2，1，9，10}，在执行for循环结构后，将b[6]，b[7]……b[9]的值相加，结果为1+2+9+10=22。注意：在计算累加和时，应将累加变量赋值为零。
第17题：

假定有如下程序:include using namespace std;int s =0;class example{ static int n

假定有如下程序： #include ＜iostream＞ using namespace std; int s =0; class example{ static int n; public: example(int i){ n=i; } static void add( ){ s+=n; } }; int example::n=0; int main( ){ example a(2),b(5); example::add(); cout＜＜s＜＜endl; return 0; }程序运行后输出结果为( )。
A．2
B．3
C．7
D．5

正确答案：D
解析：程序中定义一个类example，它包括一个静态数据成员n和一个静态成员函数add()，并在类的构造函数中给类的私有静态数据成员n赋值。在主函数main()中，定义对象a(2)时，通过构造函数使静态数据成员n的值变为2；在定义对象b(5)时，通过构造函数使静态数据成员n=5，再执行example::add()使全局变量s=5。
第18题：

以下程序的输出是【】。 include using namespace std; fun(intm) { static int n=1; n=m

以下程序的输出是【】。
include＜iostream＞
using namespace std；
fun(intm)
{
static int n=1；
n=m*n;
return(n);
}
void main()
{
int i;
for(i=1;i＜=3;i++) cout＜＜fun(i);
}

正确答案：126
126 解析：局部静态变量在离开作用域之后，并没有被销毁，而是仍然驻留在内存当中，直到程序结束。第一次调用 fun 函数时n的值等于1，第二次调用 fun 函数时n的值等于2，第三次调用 fun 函数时n的值等于6，每次调用 fun 函数时，保留上次调用时n的值不变。
第19题：

有以下程序:include using namespace std;class sample {private: iht n;public: sam

有以下程序： #include ＜iostream＞ using namespace std; class sample { private: iht n; public: sample(){} sample(int m) { n=m; } void addvalue(int m) { sample s; s.n=n+m; *this=s; } void disp() { cout＜＜"n="＜＜n＜＜end1; } }; int main() { sample s(10); s.addvalue(5); s.disp(); return 0; } 程序运行后的输出结果是
A．n=10
B．n=5
C．n=15
D．n=20

正确答案：C
解析：本题考核this指针的应用。上述程序中sample类定义了一个addvalue非静态成员函数。addvalue函数的原型是：voidaddvalue(sample*this,intm)；，该函数的第一个参数是执行该类对象的一个指针即this指针。由于这个参数是系统隐含的，所以我们在定义该成员函数时并没有看到这样一个参数。在成员函数的定义体中，可以通过this访问这一参数。上述程序的最后输出结果是15。
第20题：

下面程序的输出结果是()。include using namespace std;void main( )int i,j,m=0,n=0;

下面程序的输出结果是( )。 #include ＜iostream＞ using namespace std; void main( ) int i,j,m=0,n=0; for(i=0;i＜2;i++) for(j=0;j＜2;j++) if(j＞ =i) m=1;n++; cout＜＜m＜＜endl; cout＜＜n;
A．1 1
B．1 4
C．1 6
D．0 2

正确答案：A
解析：注意整个二重循环作用的语句为：if(j=i)m=1;，而n++语句并不为二重循环控制。其实不论循环多少次，m、n的值总为1。
第21题：

若有以下程序:includeusing namespace std;int fun(){static int i=0;int s=1;s＋=i;i

若有以下程序： #include＜iostream＞ using namespace std; int fun() { static int i=0; int s=1; s+=i; i++; return s; } int main() { int i,a=0; for(i=0;i＜5;i++) a+=fun(); cout＜＜a＜＜endl; return 0; } 程序运行后，输出的结果是( )。
A．20
B．24
C．26
D．15

正确答案：D
第22题：

有以下程序:include using namespace std;class sample{private:intn;public:sample(

有以下程序：#include ＜iostream＞using namespace std;class sample{private: int n;public: sample() {} sample(int m) { n=m; } sample add(sample s1,sample s2) { this-＞n-s1.n+s2.n; return (*this); void disp() { cout ＜＜"n="＜＜n＜＜end1; } };int main (}{ sample s1(10),s2(5),s3; s3.add(s1,s2); s3.disp (); return 0;}程序运行后，输出的结果是
A．n=10
B．n=5
C．n=20
D．n=15

正确答案：D
解析：本题考核this指针的应用。上述程序中，sample类的add成员函数中使用了this指针，this指针指向当前对象自身，该成员函数中的语句：this-＞n=s1.n+s2.n；，用于修改当前对象的数据成员n的值，语句：return(*this)；用于返回当前对象自身，即对当前对象进行了修改。对于main()函数调用add成员函数语句“s3.add(s1，s2)；”。此时，this指针指向的是对象s3，执行该语句前，s3的数据成员n未赋值，执行完该语句后，就修改了s3的私有成员n的值，使其为15。
第23题：

若有如下程序:includeusing namespace std;int s=0;class sample{static int n;publi

若有如下程序： #include＜iostream＞ using namespace std; int s=0; class sample { static int n; public: sample(int i) { n=i; } static void add() { S+=n; } }; int sample::n=0; int main() { sample a(2),b(5); sample::add(); cout＜＜s＜＜endl; return 0; } 程序运行后的输出结果是( )。
A．2
B．5
C．7
D．3

正确答案：B
第24题：

若有如下程序:include using namespaces std;int s=0;class sample {static iht n;pu

若有如下程序： #include ＜iostream＞ using namespaces std; int s=0; class sample { static iht n; public: sample(int i) { n=i; } static void add() { s+=n; } }; int sample::s=0; int main() { sample a(2),b(5); sample::add(); cout＜＜s＜＜endl; return 0; } 程序运行后的输出结果是
A．2
B．5
C．7
D．3

正确答案：B
解析：本题考核静态数据成员和静态成员函数的应用。程序中定义一个类sample，它包括一个静态数据成员n和一个静态成员函数add，并在类的构造函数中给类私有静态数据成员n赋值。在主函数main中，定义对象a(2)时，通过构造函数使静态数据成员n的值变为2，在定义对象b(5)时，通过构造函数使静态数据成员n=5(覆盖了前面的n=2)，再执行sample::add()使全局变量s=5。

程序填空完成功能：求分数序列2/1,3/2,5/3,8/5,13/8 ……的前20项之和。 #include ＜iostream＞ using namespace std; int main（) { double i,n=1,m=1,t,s=0 ; for （i=1;i＜=20;i++) { t = n ; n = m ; 【 】; s = s + m/n ; } cout＜＜s＜＜endl; return 0; }

题目

相似考题

相关内容

程序填空完成功能：求分数序列2/1,3/2,5/3,8/5,13/8 ……的前20项之和。 #include ＜iostream＞ using namespace std; int main（) { double i,n=1,m=1,t,s=0 ; for （i=1;i＜=20;i++) { t = n ; n = m ; 【】; s = s + m/n ; } cout＜＜s＜＜endl; return 0; }