以下程序的输出结果是( )。 include void main() {int f,f1,f2,i; f1=0;f2=1; printf("%以下程序的输出结果是( )。 include＜stdio.h＞ void main() {int f，f1，f2，i； f1=0；f2=1； printf("%d%d"，f1，f2)； for(i=3；i＜=5；i++) {f=-f1+f2，printf("%d"，f)； f2=f1；f1=f； } printf("\n")； }

题目

以下程序的输出结果是( )。 include void main() {int f,f1,f2,i; f1=0;f2=1; printf("%

以下程序的输出结果是( )。 include＜stdio.h＞ void main() {int f，f1，f2，i； f1=0；f2=1； printf("%d%d"，f1，f2)； for(i=3；i＜=5；i++) {f=-f1+f2，printf("%d"，f)； f2=f1；f1=f； } printf("\n")； }

相似考题

1.有以下程序#include <stdio.h>main(){ int f,f1,f2,i;f1=0;f2=1;printf("%d %d ",f1,f2);for(i=3;i<=5;i++){ f=f1+f2; printf("%d",f);f1=f2; f2=f;}printf("\n");}程序运行后的输出结果是【 1 0 】。

2.以下程序的输出结果是includein[fun(int n,int *s){int n,f2;if(n==0‖n==1)*s=1;else{以下程序的输出结果是 #include＜stdio.h＞ in[fun(int n，int *s) {int n，f2； if(n==0‖n==1) *s=1； else {fun(n-1，&f1)； fun(n-2，&f2)； *s=f1+f2； }} void main() { int x； fun(6，&x)； pfintf("\n%d"，x)；}A．7B．13C．9D．10

3.有以下程序A： int f1(int x，int y) { return x＞y?x:y; } int f2(int x,int y) { return x＞y?y:x; ) main() { int a=4,b=3,c=5,d=2,e,f,g; e=f2(f1(a,B),f1(c,D));f=f1(f2(a,B),f2(c,D)); g=a+b+c+d-e-f; printf("%d,%d,%d\n",e,f,g)； } 程序运行后的输出结果是( )。A．4,3,7B．3,4,7C．5,2,7D．2,5,7

4.下面程序的输出结果是 ( ) main( ) { int i，f1，f2； f1＝f2＝1； for(i＝0；i＜4；i+ +) { printf(”%d%d”，f1，f2)； f1+ ＝f2； f2+ ＝f1； } }A．1 2 3 4 5 6 7 8B．1 1 2 3 5 8 13 21C．1 1 3 5 7 9 11 13D．1 3 5 7 9 11 13 15

更多“以下程序的输出结果是( )。 include<stdio.h> void main() {int f,f1,f2,i; f1=0;f2=1; printf("% ”相关问题

第1题：

有以下程序
int fa(int x){return x*x;}
int fb(int x){return x*x*x;}
int f(int(*fl)(),int(*f2)(),int x}
{return f2(x)-f1(x)；}
main()
{int i；i=f(fa,fb,2)；printf("%d\n"，i)；}
程序运行后，输出结果是【】。

正确答案：4
4 解析：在主函数中调用函数f，函数f有三个参数，形参f1与f2分别是两个指向函数的指针。在f中执行f2(x)-f1(x)，实际上是执行了fb(2)-fa(2)，故执行i=(fa,fb,2)后i的龇2³-2²=4。
第2题：

有以下程序 #include<stdi0．h> void fun(int n，int*p) ( int f1，f2； if(n==1|| n==2)*p=1； else { fun(n-1，＆f1)；fun(n-2，＆f2)； *p=f1+f2； } } main { int s； fun(3，＆s)；printf("％d"，s)； } 程序的运行结果是( )。
A.2
B.3
C.4
D.5

正确答案：A
在函数fun中对参数n的值进行判断，如果其值等于1或2，则*p=1，否则，函数fun进行递归调用fun(n．1，＆f1)；fun(13．2，＆f2)；*p=n+f2；在主函数调用fun函数时传递给参数n的值为3，fun函数又递归用了两次自身fun(2，＆n)；fun(1，＆f1)；所以n和f2的值都为1，通过指针P的引用，变量S的值为2。
第3题：

有如下程序: include using namespace std; int main(){ int f, f1=0, f2=1; for(int

有如下程序：
#include＜iostream＞
using namespace std；
int main(){
int f, f1=0, f2=1;
for(int i=3; i＜=6; i++) {
f=f1+f2;
f1=f2; f2=f;
}
cout＜＜f＜＜end1;
return 0;
}
运行时的输出结果是( )。
A) 2
B) 3
C) 5
D) 8
A．
B．
C．
D．

正确答案：C
解析：在主函数中for循环语句执行4次，第一次循环结束时，变量f的值等于1，f1的值等于1，f2的值等于1；第二次循环结束时，变量f的值等于2，f1的值等于1，f2的值等于2；第三次循环结束时，变量f的值等于3，f1的值等于2，f2的值等于3；第四次循环结束时，变量f的值等于5，f1的值等于3，f2的值等于5；结束循环。
第4题：

有以下程序 include void fun(int n, int *p) { int f1,t2; if(n==1 |

有以下程序 #include ＜stdio.h＞ void fun(int n, int *p) { int f1,t2; if(n==1 ||n==2) *p=1; else { fun(n-1,&f1); fun(n-2,&f2); *p=f1+f2; } } main() { int s; fun(3,&s); printf("%d\n", s ); }
A．2
B．3
C．4
D．5

正确答案：A
解析：在调用一个函数的过程中又出现直接或间接地调用该函数本身，称为函数的递归调用。本题中的fun()函数直接调用了自身，所以它是一个递归函数。fun()函数中，当形参n为1或2时，让形参p所指内容为1。从这里可以看出形参p的用途是输出一个整数，所以我们不妨记作fun(1)=1、　fun(2)=1。如果是其他情况，那么输出结果*p的内容为f(n)=f(n-1)+f(n-2)。由此可见，　fun()函数的作用是求斐波纳契数列第n项的值(斐波纳契数列第1和2项的值为1，以后各项分别为前两项之和：1、1、2、3、5、8、13……)。主函数中通过fun()函数，求第3项值；所以输出结果为2，故应该选择A。
第5题：

有以下程序 int fa(int x) {return x*x；} int fb(int x) {return x*x*x；} int f(int(*f1)()，int(*f2)()，int x) { return f2(x)-f1(x)；} main() {int i； i=f(fa，fb，2)；pfintf(“%d\n”，i)； } 程序运行后的输出结果是
A．-4
B．1
C．4
D．8

正确答案：C
解析：函数f()有3个形式参数f1、f2和x，其中f1、f2是指向函数的指针变量。在main()函数中执行了函数调用“f(fa，fb，2)”，从而使f()的形式参数f1指向了fa，形式参数f2指向了fb，把实参2传给了形参变量x。函数f()中的return语句相当于“fb (2)-fa(2)”(fb(2)的返回值为2*2*2=8，fa(2)返回值为2*2=4)即(8-4)，值为4。函数f()执行后把返回值4赋给了i，输出i的值是4。
第6题：

有以下程序： int fa(int x) { return x*x;) int fb(int x) { return x*x*x;} int f(int (*f1)().int (*f2)(),int x) { return f2(x)-f1(x); } main() { int i; i=f(fa,fb,2);printf("%d\n",i); } 程序运行后的输出结果是( )。
A．-4
B．1
C．4
D．8

正确答案：C
解析：函数f()有3个形式参数f1、f2和x，其中f1、f2是指向函数的指针变量。在main()函数中执行了函数调用“f(fa,fb,2)”，从而使f()的形式参数f1指向了fa，形式参数f2指向了fb，把实参2传给了形参变量x。函数f()中的return语句相当于“fb(2)-fa(2)” (fb(2)的返叫值为2*2*2=8，fa(2)返回值为2*2=4)即(8-4)，值为4。函数f()执行后把返回值4赋给了i，输出i的值是4。所以4个选项中C正确。
第7题：

有以下程序,程序执行后,输出结果是【】include void fun(int*A) {a[0]=a[1];} main() {i

有以下程序，程序执行后，输出结果是【】
include＜stdio.h＞
void fun(int*A)
{ a[0]=a[1];}
main()
{ int a[10]={10,9,8,7,6,5,4,3,2,1,},i;
for(i=2;i＞1=0;i-) fun(&a[i]);
for(i=0;i＜10;i++) printf("%d,a[i]);
printf("\n");
}

正确答案：7777654321
7777654321 解析：本题主要考查函数的调用，第—次调用把数组元素a[2]的地址赋给a，此时a[1]即是原数组的a[3]等于7，再执行赋值语句a[0]=a[1]，则a[0]和a[1]中的值都是7，然后再把这个值返回给a[2]同样地第二次调用的时候函数返回值也是7，第三次调用返回值也是7，因此数组的前4个元素，即对a[0]、a[1]、a[2]和a[3]的值都为7，当执行第二个for循环时输出数组中所有元素的值7777654321。
第8题：

有如下程序includeusing namespace std;class base{public:virtual void f1(){cout<<

有如下程序 #include＜iostream＞ using namespace std； class base { public： virtual void f1() { cout＜＜"F1Base"； } virtual void f2() { cout＜＜"F2Base"； } }； class derive:public base { void f1() { cout＜＜"F1 Derive"； } void f2(int x) { cout＜＜"F2 Derive"； } }； int main() { base obj1，*p； derive obj2； p=& obj2; p-＞f1()； p-＞f2(); return ()； ) 执行后的输出结果是( )。
A．F1Derive F2Base
B．F1Derive F2Derive
C．F1Base F2Base
D．F1Base F2Derive

正确答案：A
第9题：

以下程序的运行结果为______。main(){ int i，f1，f2； f1=f2=1； for(i=0；i＜4；i++) { printf("%d %d"，f1，f2)； f1+=f2； f2+=f1； }}
A．1 1 2 3 5 8 13 21
B．1 1 2 2 5 5 10 10
C．1 2 5 8 9 8 13 21
D．0 1 1 2 4 5 15 21

正确答案：A
第10题：

以下程序的输出结果是
#include<stdio.h>
int fun(int n,int *s)
{ int f1,f2;
if(n==0||n==1)
*s=1;
else
{ fun(n-1,&f1);
fun(n-2,&f2);
*s=f1+f2;
} }
void main()
{ int x;
fun(6,&x);
printf("\n%d",x);}
A．7
B．13
C．9
D．10

正确答案：B
解析：考查函数的递归调用。n=0或n=1是递归的终止条件,然后利用已知值逐步递推求出未知值。通过传送地址值,在被调用函数中直接改变调用函数中的变量的值。
第11题：

有以下程序:include struct STU{char name[10]; int num;};void f1(struct STU c){ st

有以下程序： #include ＜stdio.h＞ struct STU { char name[10]; int num; }; void f1(struct STU c) { struct STU b={"LiSiGuo",2042}; c=b; } void f2(struct STU *c) { struct STU b={"SanDan",2044}; *c=b; } main() { struct STU a={"YangSan",2041}, b={"WangYin",2043}; f1(a); f2(&b); printf("%d%d\n",a.num,b.hum); } 执行后的输出结果是( )。
A．2041 2044
B．2041 2043
C．2042 2044
D．2042 2043

正确答案：A
解析：f2函数传递的是变量的地址，可以实现数据的交换，而f1函数传递的是值，调用完f1函数后，c的值改变了，但main函数中的a值并未改变。
第12题：

单选题
有以下程序：#include main(){　int x[]={8,2,6,12,5,15},f1,f2;　int *p=x;　f1=f2=x[0];　for(;p　{　　if(f1　　if(f2>*p)f2=*p;　}　printf("%d,%d",f1,f2);}程序的运行结果是（　　）。
A
15,2
B
15,15
C
2,15
D
8,8

正确答案： A
解析：
本题求数组的最大值和最小值，首先把数组x首地址的值赋给指针p，故*p初始值为8，而p是地址值，p+1相当于数组中下一元素的地址，在for循环，是求数组x对应的最大值和最小值，f1为最大值，f2为最小值。因此输出为15和2。答案选择A选项。
第13题：

有如下程序: include using namespace std; class base { public:virtual void f1(){

有如下程序： #include＜iostream＞ using namespace std； class base { public： virtual void f1() { cout＜＜"F1Base"; } virtual void f2() { cout＜＜"F2Base "; } }; class derive : public base { void f1 ( ) { cout＜＜"F1Derive"; } void f2( int x ) { cout＜＜"F2 Derive"; } }; int main () { base objl, * p; derive obj2; p = & obj2; p -＞ f1(); p -＞ f2(); return 0; } 执行后的输出结果是( )。
A．F1Derive F2Base
B．F1Derive F2Derive
C．F1Base F2Base
D．F1Base F2Derive

正确答案：A
解析：本题主要考察C++中虚函数机制及其继承过程中的要点。虚函数在基类中加关键词virtual声明，在派生类中重新定义。如果派生类没有覆盖虚函数，则程序执行中将会执行基类的虚函数版本。本题程序中，建立了基类base，其内函数voidf1()和voidf2()均被声明为虚函数，并在调用时会显式地发出声明。派生类derive利用public方式继承基类base，并覆盖其基类base中的虚函数f1()。对于base中的虚函数f2()，由于派生类derive中的同名函数f2()中带有参数intx，因此被编译器认为是函数重载，而不作虚函数覆盖处理，所以实际上派生类derive中包含两个f2()函数，一个不带参数，调用时执行基类base中的f2()函数版本，一个带参数intx，调用时执行重载后的版本。本题主函数中，定义了基类对象。obj1和基类指针*p，同时定义了派生类对象。obj2。p指向obj2时，“p-＞n()”函数调用执行派生类覆盖后的版本，输出F1Derive；“p-＞f2()”由于不带参数，因此执行未经派生类覆盖的函数版本，即基类base中的f1()函数版本。
第14题：

下列程序运行后的输出结果是( )。includeusing namespace std;void f1(int&x) { x＋＋; }void f2(int x) { ＋＋x; }int main(){int x=10,y=12;f1(x);f2(y);cout< return 0;}

A. 22
B.23
C.24
D.程序有误

参考答案：B
第15题：

有如下程序: include using namespace std; void f1(int& x, int& y){int z=

有如下程序：
#include＜iostream＞
using namespace std;
void f1(int& x, int& y){int z=x; x=y; y=z;)
void f2(int x, int y){int z=x; x=y; y=z;}
intmain(){
int x=10, y=26;
f1(x, y);
f2(x, y);
cout＜＜y＜＜end1;
return 0;
}
运行时的输出结果是( )。
A) 10
B) 16
C) 26
D) 36
A．
B．
C．
D．

正确答案：A
第16题：

有以下程序 int fa(int x) { return x*x; } int fb(int x) { return x*x*x; } int f(int (*f1)(),int (*f2)(),int x) { return f2(x)-f1(x); } main() { int i; i-f(fa, fb,2); printf("%d \n",i); } 程序运行后的输出结果是
A．4
B．1
C．4
D．8

正确答案：C
解析：函数f()有3个形式参数f1、f2和x，其中f1、f2是指向函数的指针变量。在main()函数中执行了函数调用“f(fa,fb,2)”，从而使f()的形式参数f1指向了fa，形式参数f2指向了fb，把实参2传给了行参变量x。函数f()中的return语句中的相当于“fb(2)-fa(2)”(fb(2)的返回值为2*2*2=8，fa(2)返回值为2*2=4)即(8-4)，值为4．函数f()执行后把返回值4赋给了i，输出i的值是4．所以4个选项中C正确。
第17题：

以下程序的输出结果是()。includeint fun(int n,int *s){ int f1,f2;if(n==0||n==1)*s=

以下程序的输出结果是( )。 #include＜stdio.h＞ int fun(int n，int *s) { int f1，f2； if(n==0||n==1) *s=1； else { fun(n-1，&f1)； fun(n-2，&f2)； *s=f1+f2； } } void main() { int x； fun(6，&x)； printf("\n％d" ，x)；}
A．7
B．13
C．9
D．10

正确答案：B
解析：n=0或n=1是递归的终止条件。然后利用已知值逐步递推求出未知值。注意：通过传送地址值，在被调用函数中直接改变调用函数中的变量的值。
第18题：

C 程序写运行结果。
class A
{
public:
void f1()
{
printf("A::f1\r\n");
}
virtual void f2()
{
printf("A::f2\r\n");
}
void callfunc()
{
printf("A::callfunc\r\n");
f1();
f2();
}
};
class B :public A
{
public:
void f1()
{
printf("B::f1\r\n");
}
void f2()
{
printf("B::f2\r\n");
}
void callfunc()
{
printf("B::callfunc\r\n");
f1();
f2();
}
};
int main()
{
B *pB=new B;
pB->callfunc();
A *pA=pB;
pA->callfunc();
return 0;
}

正确答案：
第19题：

8 写出下列程序所有可能的运行结果。
int a;
int b;
int c;
void F1()
{
b=a*2;
a=b;
}
void F2()
{
c=a+1;
a=c;
}
main()
{
a=5;
//Start F1,F2 in parallel
F1(); F2();
printf("a=%d\n",a);
}

正确答案：
第20题：

有如下程序include using namespace std;class base{public:virtual void f1(){cout<

有如下程序#include ＜iostream＞using namespace std;class base{public: virtual void f1() { cout＜＜"F1Base "; } virtual void f2() { cout＜＜"F2Base "; }};class derive: public base{ void f1() { cout＜＜"F1Derive "; } void f2( int x ) { cout＜＜"F2Derive "; }};int main(){ base obj1, * p; derive obj2; p = & obj2; p -＞ f1(); p -＞ f2(); return 0;} 执行后的输出结果是
A．F1Derive F2Base
B．F1Derive F2Derive
C．F1Base F2Base
D．F1Base F2Derive

正确答案：A
解析：本题主要考查C++中虚函数机制及其继承过程中的要点。虚函数在基类中加关键字virtual声明，在派生类中重新定义；如果派生类没有覆盖虚函数，则程序执行中将会执行基类的虚函数版本。题目程序中，建立了基类base，其内函数void f1()和void f2()均被声明为虚函数，并在调用时会显式的发出声明。派生类derive利用 public方式继承基类base，并覆盖其基类base中的虚函数f1()；对于base中的虚函数f2()，由于派生类 derive中的同名函数f2()中带有参数int x，因此被编译器认为是函数重载，而不作虚函数覆盖处理，因此实际上派生类derive中包含两个f2()函数，一个不带参数，调用时执行基类base中的f2()函数版本，一个带参数int x，调用时执行重载后的版本。题目 main()函数中，定义了基类对象。obj 1和基类指针*p，同时定义了派生类对象obj2。p指向。obj2时：p-＞f1()函数调用执行派生类覆盖后的版本，输出D1；p-＞ f2()由于不带参数，因此执行未经派生类覆盖的函数版本，即基类base中的f1()函数版本。
第21题：

有以下程序:includeiht fun(iht n,int*p){int f1,f2;if(n==1||,n==2)*p=1;else{fun(n－

有以下程序： #include＜stdio.h＞ iht fun(iht n，int*p) { int f1，f2； if(n==1||，n==2)*p=1； else { fun(n-1，&f1)；fun(n-2，&f2)； *p=f1+f2； } } main() { int s； fun(3，&s)； printf("%d\n"，s)； } 程序的运行结果是______。
A．2
B．3
C．4
D．5

正确答案：A
解析：本题考查的重点是理解递归函数。fun()为递归函数，递归结束条件时n为1或2，从而fun(3，&s)得fun(2，&s)+fun(1，&s)＝1+1＝2，因此选项A是正确的。
第22题：

以下程序输出结果是 ______。includevoid n(int i);void f2(int i);char st[]=”Howd

以下程序输出结果是 ______。 #include＜iostream.h＞ void n(int i)； void f2(int i)； char st[]=”Howdoyoudo!”； void fl(int i){ cout＜＜st[i]； if(i＜3){ i+=2： f2(i)： } } void f2(int i) { cout＜＜st[i]； if(i＜3) { i+=2； f1(i)； } } void main() { int i=0； f1(i)； }
A．How
B．do
C．Hwo
D．Hwoy

正确答案：C
第23题：

有如下程序includeusing nameSpace std;class base{public:vinual void f1() { cout<

有如下程序 #include＜iostream＞ using nameSpace std； class base { public： vinual void f1() { cout＜＜"F1 Base"； } virtual void f2() { cout＜＜"F2Base"； } }； class derive：public base { void f1() { cout＜＜"F1Derive"； } void f2(int x) { cout＜＜"F2Derive"； } }； int main() { base obj1，*p； derive obj2； p=&obj2； p—＞f1()； p—＞f2()； return 0； } 执行后的输出结果是
A．F1Derive F2Base
B．F1Derive F2Derive
C．F1Base F2Base
D．F1Base F2Derive

正确答案：A
解析：本题主要考查C++中虚函数机制及其继承过程中的要点。虚函数在基类中加关键字virtual声明，在派生类中重新定义；如果派生类没有覆盖虚函数，则程序执行中将会执行基类的虚函数版本。题目程序中，建立了基类base，其内函数voidf1()和voidf2()均被声明为虚函数，并在调用时会显式的发出声明。派生类derive利用public方式继承基类base，并覆盖其基类base中的虚函数f1()；对于base中的虚函数f2()，由于派生类derive中的同名函数f2()中带有参数intx，因此被编译器认为是函数重载，而不作虚函数覆盖处理，因此实际上派生类derive中包含两个f2()函数，一个不带参数，调用时执行基类base中的f2()函数版本，一个带参数intx，调用时执行重载后的版本。题目main()函数中，定义了基类对象。obj1和基类指针*p，同时定义了派生类对象。obj2。p指向。obj2时：p—＞f1()函数调用执行派生类覆盖后的版本，输出D1：p-＞f2()由于不带参数，因此执行未经派生类覆盖的函数版本，即基类base中的f1()函数版本。

niusouti.com

题目

相似考题

更多“以下程序的输出结果是( )。 include<stdio.h> void main() {int f,f1,f2,i; f1=0;f2=1; printf("% ”相关问题

相关内容