提示:内容已经过期谨慎付费，点击上方查看最新答案
C/C++程序设计
- 有如下程序：
#include
main( )
{char s[ ]=“abcdef”;
s[3]=‘ ’;
printf(“%s ”,s);}
执行后的输出结果是：输出结果是（ ）。 - 在下面有关析构函数特征的描述中，正确的是（ ）
- 若变量已正确定义并赋值，符合C语言语法的表达式是（ ）
- C语言中，用关键字（ ）定义单精度实型变量，用关键字（ ）定义双精度实型变量。
- 定义如下变量和数组: int i; int x[3][3]={1,2,3,4,5,6,7,8,9};则语句
for(i=0;i<3;i++)
printf("%d ",x[i][2-i]);
的输出结果是（ ）。 - 设有如下说明
typedef struct
{ int n; char c; double x;
}STD;
则以下选项中，能正确定义结构体数组并赋初值的语句是（ ） - 类声明的内容用花括号括起来，在花括号后跟（ ）符号表示类声明结束
- C语言提供的专门用于字符串输入输出的函数是（ ）函数和（ ）函数。
- 类中能访问静态成员的函数是（ ）
- 关于虚基类，以下说法错误的是（ ）
- 表达式a=3*5,a*4的值为（ ），a的值为（ ）。
- 关于循环结构的嵌套，说法错误的是（ ）
- 以下对一维数组元素的初始化不正确的是（ ）
- 若已定义变量char ch；则调用getchar输入一个字符并赋给变量ch的正确语句是（ ）。
- 执行完循环for(i=1;i<100;i++);后，i的值为（ ）
- 设整型变量 m,n,a,b,c,d 均为1，执行 (m=a>b)&&(n=c>d)后, m,n 的值是（ ）
- 若变量已正确定义，在执行以下语句while（ch=getchar(）==‘A’);时，输入字符‘A’后，ch的值是（ ）。
- 有以下程序：
#include
long fib(int n)
{ if(n>2)return(fib(n-1)+fib(n-2));
else return(2);}
main()
{ printf("%ld ",fib(6));}
程序的输出结果为（ ） - 若有a=1, b=0, c=2, d=3,则条件表达式a < b ? c : d的值是（ ）
- 以下语句或语句组中, 能正确进行字符串赋值的是（ ）
- 有以下程序段
int k=0;
while(k>1)k++;
while 循环执行的次数是（ ） - 读出以下语句的输出结果是( )。
int x=10,y=10;
printf(“%d %d ”,x--,--y); - 在类外定义成员函数时，”:: ”运算符两侧分别连接（ ）
- 两个指针变量的指向相同时，表明两个指针变量是（ ）。
- 采用重载函数的目的是（ ）
- 下列哪种类型的函数适合声明为内联函数（ ）
- 当类A成为类B的友元类时，以下说法正确的是（ ）
- 若有说明: int i, j=7, *p=&i;, 则与i=j; 等价的语句是（ ）。
- 有函数调用语句：fun（（exp1,exp2），（exp3,exp4,exp5））;此函数调用语句含有的实参个数是（ ）
- 若有说明int a[3][4];则对a数组元素的正确引用是（ ）
- 设类A中有静态数据成员x，两个A类对象a和b，若a.x=10，则b.x的值为（ ）
- 下列关于类和对象的关系描述不正确的是（ ）
- 在C++的类声明中，用public关键字声明的类成员的访问权限是（ ）
- main()
{static inta[][3]={9,7,5,3,1,2,4,6,8};
int i,j,s1=0,s2=0;
for (i=0;i<3;i++)
for (j=0;j<3;j++)
{if(i==j)s1=s1+a[i][j];
if(i+j==2)s2=s2+a[i][j];
}
printf (“%d %d ”,s1,s2);}
程序的输出结果为（ ）。 - 已知i、j、k为int型变量，若从键盘输入：1,2,3<回车>，使i的值为1、j的值为2、k的值为3，以下选项中正确的输入语句是（ ）
- 若x=5.6，执行++x后表达式的值为（ ），变量x的值为（ ）。
- 面向对象程序设计的特点不包括以下哪一项（ ）
- 下面程序段的输出为（ ）
int a=15, b=10, c=20, d;
d = a > 12 ? b : c;
switch(d)
{
case 5: printf("%d,", a);
case 10: printf("%d,", b);
case 20: printf("%d,", c);
default: printf("# ");
} - 关于引用,下列的说法中错误的是（ ）
- 在C语言中，引用数组元素时，其数组下标的数据类型允许是（ ）
- 以下程序的输出是（ ）
struct st
{ int x; int *y;
} *p;
int dt[4]={ 10,20,30,40 };
struct st aa[4]={ 50,&dt[0],60,&dt[0],60,&dt[0],60,&dt[0],};
main()
{ p=aa;
printf("%d ",++(p->x));
} - 所谓数据封装就是将一组数据和与这组数据有关操作组装在一起,形成一个实体,这实体也就是（ ）
- 机器语言的优点是（ ）
- 下列四组字符串中都可以用作C语言程序中的标识符的是（ ）。
- 下列关于指针定义的描述，错误的是（ ）。
- 当一个派生类公有继承一个基类时，基类中的所有公有成员成为派生类的（ ）
- 拷贝构造函数的调用时机不包括（ ）
- 不正确的指针概念是（ ）。
- 若变量已正确说明为float类型，要通过语句scanf("%f %f %f ",&a,&b,&c);给a赋于10.0，b赋予22.0，c赋予33.0，不正确的输入形式是：（ ）
- 已知类A是类B的友元，类B是类C的友元，则（ ）
- 有以下程序
main()
{ char a='a',b;
printf("%c,",++a);
printf("%c ",b=a++);}程序运行后的输出结果是( )。 - int *p,i;
i=10;
p=&i;
i=*p+1;
执行完上面的语句段后， i的值是（ ）。 - 赋值运算符的优先级比算术运算符的（ ）。
- 基类中的protected成员，通过哪种派生，其在派生类中的可见性为protected? （ ）
- 表达式（float）（5%3）的计算结果是（ ）。
- 如果一个类的成员函数是另一个类的友元函数，则称这个成员函数为友元成员。
- 间接访问运算符“*”的作用是访问指针变量所指的变量的内容。
- 二维数组的基类型是指二维数组元素的类型。
- 数组可分为一维数组和多维数组（二维或二维以上）。
- 若有定义：char ch；通过指针p输出ch中字符的语句是printf（”%c”,ch）;。
A:abc B:abcd C:ab D:abcdef
答案:ga
A:一个类中可以定义多个析构函数 B:析构函数名与类名完全相同 C:析构函数可以有一个或多个参数 D:析构函数不能指定返回类型
答案:析构函数不能指定返回类型
A:a=b+c，a++ B:a=a+7; C:int(12.3%4) D:a=a+10=c+b
答案:a=b=c+2
A:int char B:int double C:float double D:float char
答案:float doubleAI参考:正确选项是【C语言中，用关键字（float ）定义单精度实型变量，用关键字（double ）定义双精度实型变量】。在C语言中，float是用来定义单精度实型变量的关键字，而double则是用来定义双精度实型变量的关键字。int和char是用来定义整型变量和字符型变量的关键字。'
A:3 5 7 B:1 5 9 C:3 6 9 D:1 4 7
AI参考:输出结果为：C:3 6 9。解释：题目中定义了一个二维数组x，其大小为3x3。在for循环中，i的值从0到2，每次循环都会访问数组中的一行。由于数组下标从0开始，因此i=0时访问第一行，i=1时访问第二行，i=2时访问第三行。在循环体内，使用了2-i来计算列的下标，即第一列对应0，第二列对应1，第三列对应2。因此，当i=0时，x[i][2-i]为3；当i=1时，x[i][2-i]为6；当i=2时，x[i][2-i]为9。因此输出结果为C选项中的三个数字：3、6、9。'
答案:per是结构体变量名
A:”;” B:”. ” C:”,” D:”:”
A:gets puts B:putchar getchar C:getchar putchar D:puts gets
AI参考:正确答案是C语言提供的专门用于字符串输入输出的函数是getchar函数和putchar函数。getchar函数用于从标准输入流（通常是键盘）读取一个字符，而putchar函数用于将一个字符输出到标准输出流（通常是显示器）。这两个函数都是C语言中用于字符串输入输出的基本函数，可以用来读取和输出单个字符或字符串。因此，选项C是正确答案。'
A:虚函数 B:构造函数 C:静态成员函数 D:析构函数
AI参考:正确选项是【C:静态成员函数】。在C++中，静态成员函数可以在类中访问静态成员，而构造函数、析构函数、虚函数等不能直接访问静态成员。因此，正确答案为C。'
A:虚基类的初始化是由最后的派生类完成的 B:一个基类在作为某些派生类的虚基类的同时也可作为另一些派生类的非虚基类 C:虚基类的关键字virtual 必须在继承方式的关键字private、protected和public的前面 D:虚基类使用关键字virtual，只对紧跟其后的基类起作用
A:20 15 B:20 60 C:4 60 D:60 15
AI参考:正确选项是B:20 60 。首先，表达式a=3*5的结果是15，然后a*4的结果是60。所以，表达式a=3*5,a*4的值为20，a的值为60。'
A:外层循环可包含两个以上内循环,可以相互交叉 B:嵌套循环的跳转禁止跳入同层的另一循环 C:for，while，do-while都可以相互嵌套，层数不限 D:其余说法都错误
AI参考:关于循环结构的嵌套，说法错误的是C: for，while，do-while都可以相互嵌套，层数不限。在循环结构的嵌套中，外层循环只能包含一个内循环，且内循环的结束通常会导致外层循环的结束。因此，选项C的说法是不正确的。选项A、B和D都是关于循环嵌套的正确描述。'
A:int a[5]={0,1,2}; B:int a[5]={0,1,2,3,4}; C:int a[ ]={0,1,2,3,4}; D:int a[5]={0,1,2,3,4,5};
AI参考:对于这个问题，答案为 D：int a[5]={0,1,2,3,4,5};原因分析：A: int a[5] = {0, 1, 2}; 这是一种正确的数组初始化方式，它将数组中的每个元素初始化为特定的值。B: int a[5] = {0, 1, 2, 3, 4}; 这是一种正确的数组初始化方式，同样是将数组中的每个元素初始化为特定的值。C: int a[] = {0, 1, 2, 3, 4}; 这是一种不正确的数组初始化方式，因为在C语言中，如果只给出数组的大小，而没有给出具体的元素值，那么数组中的元素将会被初始化为0。所以这个选项是正确的。D: int a[5] = {0, 1, 2, 3, 4, 5}; 这是一种错误的数组初始化方式，因为数组的大小是5，但是给出的元素数量超过了数组的大小，所以这个选项是不正确的。所以，正确答案为D：int a[5]={0,1,2,3,4,5};。'
A:ch==getchar( ) B:ch=getchar( ) C:getchar( ) D:getchar(ch )
A:99 B:102 C:101 D:100
A:1，0 B:0，1 C:1，1 D:0，0
A:A B:0 C:不确定 D:1
AI参考:正确选项是【A:A】。 在执行while（ch=getchar(）==‘A’）语句时，首先调用getchar()函数从标准输入读取一个字符，并将其赋值给变量ch。由于while语句的条件是ch等于从标准输入读取的字符是否等于字符A，因此当输入字符A时，该条件成立，循环会继续执行。在循环过程中，变量ch的值会根据输入的字符进行更新，所以最终ch的值会是输入的字符A。因此，选项A是正确的。"
A:30 B:2 C:16 D:8
A:2 B:1 C:3 D:0
A:char *sp="right!"; B:char s[12]; *s="right!"; C:char *sp; *sp="right!"; D:char s[10]; s="right!";
A:有语法错，不能执行 B:执行1次 C:一次也不执行 D:无限次
A:9 10 B:10 9 C:10 10 D:9 9
A:返回值类型 类名 B:类名 函数名 C:函数名 类名 D:返回值类型 函数名
A:指向同一内存单元地址或者都为空。 B:占据的内存单元相同。 C:都没有指向。 D:都不是空指针。
A:提高速度 B:减少空间 C:实现共享 D:使用方便，提高可读性
A:函数语句较少，调用频率高 B:函数体逻辑较复杂 C:函数执行时间较长 D:函数体语句较多
A:类B所有成员函数都可以通过对象名直接访问类A中的私有成员 B:类A所有成员函数成为类B的成员函数 C:类B所有成员函数都成为类A的友元函数 D:类A所有成员函数都成为类B的友元函数
AI参考:正确选项是【B:类A所有成员函数成为类B的成员函数】。当类A成为类B的友元类时，意味着类A和类B之间的某种特殊关系被建立起来。在这种情况下，类A中的成员函数可以访问类B中的任何公有、保护和友元函数。但要注意，这是在类B的所有成员函数作为类A的成员函数的情况下实现的，即类A的成员函数通过对象名可以直接访问类B中的成员变量，包括私有成员。这种情况下，B的私有成员的访问限制会被突破，这是问题的核心和正确答案。然而，这种情况下并不是类A的所有成员函数成为类B的友元函数，C和D选项都与这个结论相违背。'
A:i= B:i= *p; C:*p=* D:i=* *p;
A:5 B:4 C:2 D:1
A:a(2)(2) B:a[2][4] C:a[1,3] D:a[1+1][0]
A:9 B:11 C:10 D:不能确定
A:类需要分配空间 B:类是创建对象的模板，是对象的抽象 C:对象是类的一个具体实例 D:对象需要分配存储空间
AI参考:正确选项是D:对象需要分配存储空间。在面向对象编程中，类是创建对象的模板，是对象的抽象，对象是类的具体实例。类需要分配空间来存储属性和方法，而对象是类的实例化，需要分配存储空间来存储对象的属性和状态。因此，选项A和B是正确的描述。选项C也是正确的描述，因为对象是从类中创建出来的具体实例。因此，选项D是不正确的描述，因为对象也需要分配存储空间来存储其属性和状态。'
A:内部的 B:私有的 C:公有的 D:保护的
AI参考:正确选项是 C:公有的。在 C++ 中，public 关键字用于声明类的成员变量和成员函数，表示这些成员可以被类的任何对象访问。因此，public 关键字声明的类成员的访问权限是公有的。其他选项中，private 关键字表示成员只能被类的对象访问，protected 关键字表示成员可以被同一个类的对象、派生类对象和友元访问，而内部访问则没有明确的权限限制，可能会引起访问冲突。'
A:12 10 B:18 10 C:15 10 D:14 14
AI参考:正确答案是 C:15 10。根据题目描述，程序首先定义了一个二维数组a并初始化了一些值，然后使用两个循环遍历数组，并使用条件语句进行判断，将符合条件的元素相加。最后输出s1和s2的值。在循环中，如果i和j相等，那么s1的值就会增加a[i][j]，如果i+j等于2，那么s2的值就会增加a[i][j]。最终的输出结果应该是15和10，因为数组中只有一行元素满足条件。因此，选项C是正确的答案。'
A:scanf("%2d%2d%2d",&i,&j,&k); B:scanf("%d,%d,%d",&i,&j,&k); C:scanf(""%d %d %d",&i,&j,&k); D:scanf("i=%d,j=%d,k=%d",&i,&j,&k);
A:6 6 B:6 7 C:5 6 D:7 6
AI参考:正确选项是【B:6 7 】。解释：执行++x后，x的值会加1，所以表达式的值为x+1，即5.6+1=6。同时，变量x的值也会增加1，变为原来的值+1，即原来的值+1=原来的值+2，所以变量x的值为原来的值+1后的值，即原来的值+2=7。所以答案为B选项。'
A:静态 B:继承 C:多态 D:封装
A:10,20,# B:15,10,20,# C:10 D:10,20
A:引用主要是用来作函数的形参和函数的返回值 B:在声明引用时,要给它另开辟内存单元 C:在声明引用时,必须同时使它初始化 D:引用是给被引用的变量取一个别名
AI参考:关于引用，下列说法中错误的是选项C：在声明引用时，必须同时使它初始化。引用是C++中的一种特性，它允许我们通过一个已经存在的变量名来访问另一个变量，而不是创建一个新的变量。引用必须在声明时初始化，但初始化后，引用可以指向任何地方，包括其他变量、常量、表达式等。因此，选项C的说法过于绝对，不准确。其他选项A、B、D都是正确的说法。'
A:整型表达式 B:任意类型的表达式 C:整型常量 D:整型常量或整型表达式
A:11 B:51 C:10 D:60
AI参考:输出结果为 `51`。程序中定义了一个结构体类型 `struct st`，其中包含一个整数 `x` 和一个指向整数的指针 `y`。然后定义了一个指向该结构体的指针 `p`，并将其指向了 `aa` 数组的首个元素。在 `printf` 函数中，使用了 `p->x` 来访问结构体中的 `x` 成员，并使用 `++` 运算符将其递增。由于 `p` 指向的是 `aa` 数组的首个元素，因此 `p->x` 的值实际上是数组 `aa` 中第一个元素的 `x` 值，即 `50`。因此，输出结果为 `51`。'
A:对象 B:函数体 C:类 D:数据块
A:移植性好 B:易学 C:运算效率高 D:可读性好
A:str_1 Cpp pow while B:Iam one_half start$it 3pai C:print _3d db8 aBc D:Pxq My->book line# His.age
A:指针是一种变量，该变量用来存放某个变量的地址值。 B:指针变量的命名规则与标识符相同。 C:指针变量的类型与它所指向的变量类型一致。 D:在定义指针时，标识符前的“*”号表示后面的指针变量所指向的内容。
A:private成员 B:友元 C:protected成员 D:public成员
A:如果函数的形参是类的对象，调用函数时，进行形参和实参结合时 B:当用类的一个对象去初始化该类的另一个对象时 C:如果函数的返回值是类的对象，函数调用完成返回时 D:将一个对象赋值给另一个对象时
AI参考:正确选项是：C:如果函数的返回值是类的对象，函数调用完成返回时。拷贝构造函数是在类中定义的一个特殊构造函数，用于在创建对象时，将一个已存在的对象作为参数进行复制。它的调用时机包括：1. 如果函数的形参是类的对象，调用函数时，进行形参和实参结合时（A正确）；2. 当用类的一个对象去初始化该类的另一个对象时（B正确）；3. 如果函数的返回值是类的对象，函数调用完成返回时（D正确），这可以用于创建对象时使用该函数的返回值。而题目中并未提及将一个对象赋值给另一个对象的情况（D正确），因此选项C是不正确的。'
A:一个指针变量只能指向同一类型的变量。 B:指针变量可以赋任意整数，但不能赋浮点数。 C:只有同一类型变量的地址才能存放在指向该类型变量的指针变量之中。 D:一个变量的地址称为该变量的指针。
A:102233 B:10.022.0 33.0 C:10.0,22.0,33.0 D:10 22 33
A:类A的成员函数可以访问类B的对象的任何成员 B:类A一定是类C的友元 C:类C的成员函数可以访问类B的对象的任何成员 D:类C一定是类A的友元
A:b,b B:b,c C:a,c D:a,b
A:12 B:不确定 C:10 D:11
AI参考:执行完上面的语句段后，i的值是（D:11）。在这个语句段中，首先将变量i的值设为10，然后将p指向i的地址，接着将p指向的值（即i的值）加1，得到新的值11。因此，执行完这段代码后，i的值是11。'
A:不一定 B:相同 C:低 D:高
AI参考:正确选项是D：高。赋值运算符的优先级比算术运算符高。在表达式中，如果存在多个运算符，先考虑赋值运算符，然后再考虑算术运算符。例如，在“a = b * c + d”这个表达式中，首先将d的值赋给a，然后再与b和c进行运算。这样可以避免因为优先级问题导致的错误计算。'
A:仅protected B:protected和private C:public和private D:public和protected
A:1.67 B:2.0 C:1.66 D:2
AI参考:正确选项是【C:1.66】。表达式（float）（5%3）会将5除以3并向下取整，即5除以3的结果是1.66666，转换为float类型后保留两位小数得到1.66。因此，该表达式的计算结果为1.66。'
A:对 B:错
AI参考:正确答案是B：错。题目中的描述是错误的。一个类的成员函数是另一个类的友元函数，但并不能说这个成员函数为友元成员。成员函数是属于类的，而友元函数是属于类之外的，它不是类的成员。因此，这个成员函数被称为友元函数，而不是友元成员。'
A:错 B:对
A:对 B:错
A:对 B:错
A:对 B:错
AI参考:答案：B解释：题目中定义了一个字符型变量ch，并使用指针p输出ch中字符。但是printf函数只能输出指针p所指向的字符，而不能直接输出变量ch的值。所以，正确的语句应该是printf("%c", *(p));，即将*p作为printf的格式化字符串。因此，该判断题的答案是B:错。'
温馨提示支付 ￥2.20 元后可查看付费内容,请先翻页预览!
