提示:内容已经过期谨慎付费，点击上方查看最新答案
计算机编程
- 类的成员函数也和普通函数一样，都可以有返回值和参数列表。
- 继承方式包括: public(公用的),private(私有的)和protected(受保护的)，此项是可选的，如果不写此项，则默认为public (私有的)。
- 在类内部，无论成员变量或成员函数被声明为private、public或者protected属性，均是可以互相访问的，无访问权限限制。
- 在保护继承中，对于垂直访问(比如派生类成员函数访问基类成员)同于公有继承，而对于水平访问同于私有继承。
- 在公有继承中，基类中的公有成员和私有成员在派生类中都可以被派生类中的成员函数引用。
- 动态多态性是通过基类指针指向派生类对象和虚函数(virtual function)实现的。
- 构造函数可以在类内部定义，也可以在类外部定义。
- C++根据文件内容的数据格式可分为文本文件和二进制文件，它们存取最小信息单位为字节。
- 计算机语言（比如C++）所指的多态，是指不同的对象对同一消息会作出不同的响应，分别执行不同的操作，并且是在系统编译时就能决定调用哪个函数而产生的。
- 类和对象的关系，就像是模板与成品之间的关系，类就像是一个模板，用来制作该模板相似的产品（对象）。
- 下列运算符中，在C++中不能重载是（ ）。
- 运行程序，程序运行结果是（ ）
#include
using namespace std;
struct student { char name[10]; int score[50]; float average; }stud1;
int main()
{ cout<
} - 执行完下面一段程序后x的值是（ ）
int a=1,b=2,c=4,d=3,x;
if (a
if (a
else x=4;
else x=5;
cout< - 当定义一个结构体变量时，系统为它分配的内存空间是（ ）
- 下列说法不正确的是（ ）
- 运行程序，程序输出结果是（ ）
#include
using namespace std;
int main()
{char str[100]="program",*p=str;
cout<<*(p++)<
} - 以下能对一维数组a进行正确初始化的语句是（ ）
- 以下C++程序执行结果为（ ）。
………
cout.fill(‘#’);
cout.width(10);
cout< - 读文件最后一个字节（字符）的语句为（ ）。
- 在C++语言中，以下关于类型转换函数的描述，错误的是（ ）。
- （ ）的主要功能是对对象进行初始化。
- C++语言中类类型声明中默认的访问权限是( )。
- C++语言程序中，当函数调用时( )
- 一个函数返回值的类型是由（ ）决定的
- 下面结构体的定义语句中错误的是（ ）
- 下列关于异常处理的叙述，正确的是（ ）。
- 运行程序，程序运行结果是（ ）
#include
using namespace std;
int main()
{struct date
{int year;
int month;
int day;
};
struct s
{date birthday;
char name[20]; } x[4]={{2008,10,1, "guangzhou"},{2009,12,25,"Tianjin"}};
cout<< x[0].name<<","<
} - 有以下函数定义：
void fun(int n,double x) {…}
若以下选项中的变量都已经正确定义且赋值，则对函数fun的正确调用语句是
( ) - 执行下列语句序列，不可能出现的情况是（ ）。
int n;
cin>>n;
switch(n){
case 1:
case 2: cout<<'X';
case 3:
case 4: cout<<'Y'; break;
default:cout<<'Z';
} - 在ios中提供控制格式的标志位中，转换为八进制形式的标志位是（ ）。
- 己知int a[10]={3,7,9,15},*p=a;则不能表示a数组中元素的选项是( )
- C++类体系中，不能被派生类继承的有（ ）。
- 下列关于运算符重载的描述中，错误的是（ ）。
- 下列运算符中，可以重载为类的友元函数的运算符是（ ）。
- 以下类中说明了“+=”运算符重载函数的原型。
class TA
{
public:
.. .. ..
friend TA operator +=(TA &);
};
有语句TA c,d; 编译器把表达式”c+=d”解释为：( )。 - 运行程序，程序运行结果是（ ）
#include
using namespace std;
struct KeyWord
{ char Key[20]; int ID; }kw[]={"void",1,"char",2,"int",3,"float",4,"double",5};
int main()
{ cout< - 如果在一个函数的复合语句中定义了一个变量，则该变量（ ）
- 以下对一维数组a的正确定义是( )
- 关于return语句，下列正确的说法是（ ）
- 若有初始化 char a[ ]="BASIC"；则cout<<&a[3];的输出结果是（ ）
- 下列说法中错误的是（ ）。
- 运行程序，程序输出结果是（ ）
#include
using namespace std;
int main()
{int fun(char *s);
char y[]="abcd";
cout<
}
int fun(char *s)
{char *t=s;
while (*t) t++;
return (t-s);
} - 定义以下结构体类型，运行程序的输出结果是（ ）
#include
using namespace std;
int main()
{struct s{int a;double b;};
cout<
} - 执行语句int n, *p=&n；输出指针p的地址值的语句是（ ）。
- 磁盘文件操作中，打开磁盘文件的访问方式常量中，以追加方式打开文件的是（ ）。
- 现需要将Vector类对象使用的关系运算符“！=”重载为成员函数，用于判断两个对象是否不相等，以下正确且合理的函数声明是（ ）。
- 在一个源程序文件中定义的全局变量的有效范围是( )
- 运行程序，程序输出结果是（ ）
#include
using namespace std;
int main()
{ struct stud
{ char num [5];
int s[4];
double ave;
} a;
cout< - 设己定义浮点型变量 data,以二进制方式把 data 的值写入输出文件流对象 outfile, 正确的语句是( )。
- 若有定义语句int c[5],*p=c;则以下对数组c第1个元素地址的正确引用是（ ）
- 已知int a=1,b=2,c=3; 以下语句执行后a,b,c的值是（ ）
if(a>b)
c=a; a=b; b=c; - read 函数的功能是从输入流中读取( )。
以下描述正确的是（ ）
- 在C++语言中，我们可以先声明一个类，然后创建多个对象；也可以先声明一个类，通过（ ）关系，派生出多个新的类。
- 执行语句char *str = "C++"; cout<<*str;输出结果是（ ）。
- 设void f1(int *m,long &n);
int a; long b;
则以下调用合法的是（ ）。 - 若运算符重载函数的形参表中没有参数，则不可能的情况是（ ）。
- 有下列结构体声明语句
struct student{int num; char name[20]; float score[3]; };
student s[3]={123,"Li Fang",67,89,90};
要对第1个学生的成绩输出总分，下列表达式正确的是（ ） - 以下程序段的输出结果是（ ）
int x=5;
if(x++>5)
cout<
cout< - 以下程序的输出结果是（ ）
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:错 B:对
答案:对
A:对 B:错
答案:对
A:错 B:对
AI参考:答案：A。在类内部，成员变量和成员函数可以被同类的其他成员函数和对象访问，但无法被类的外部访问。因此，答案是“错”。'
A:错 B:对
答案:正确AI参考:**正确选项：B.对**。\r\r在C++中，保护继承（protected inheritance）指的是基类的公有成员和保护成员在派生类中既可以被公有访问也可以被保护访问。对于垂直访问（比如派生类成员函数访问基类成员），保护继承等同于公有继承；对于水平访问（比如基类成员函数访问派生类成员），保护继承等同于私有继承。因此，这个判断题是正确的。'
A:对 B:错
答案:错误
A:对 B:错
答案:对
A:错 B:对
A:错 B:对
A:对 B:错
AI参考:正确答案是A。多态是面向对象编程中的一个重要概念，指的是不同的对象对同一消息会作出不同的响应，分别执行不同的操作，这是在系统编译时就能决定调用哪个函数而产生的。计算机语言如C++是实现多态的一种方式。所以这个表述是正确的。'
A:错 B:对
A:? : B:+= C:-- D:++
A:64 B:256 C:216 D:128
A:1 B:4 C:2 D:3
AI参考:正确选项是【D:3】。程序逻辑分析如下：1. 先判断a
A:结构中第一个成员所需的内存容量 B:结构体中占内存容量最大者所需的容量 C:结构中各成员所需内存容量之和 D:结构中一个成员所需的内存容量
A:主函数main中定义的变量在整个文件或程序中有效 B:在一个函数内部，可以在复合语句中定义变量，这些变量只在本复合语句中有效 C:形式参数是局部变量 D:不同函数中，可以使用相同名字的变量
A:pro B:rogram C:r D:p
AI参考:正确选项是 B: `program`。 程序中首先定义了一个字符数组 `str`，并初始化为 `program`。然后通过指针 `p` 指向该数组的首地址。在输出时，使用 `cout` 输出指针 `p` 指向的字符，即 `program` 的第一个字符 `r`，然后使用 `p++` 将指针向后移动一位，即将指向第二个字符 `o`。因此，输出结果为 `r`，而选项 B 中的字符是 `program` 的首字母，也是正确的选项。"
A:int a[10]={}; B:int a[10]=(1,2,3,4,5); C:int a[]={0}; D:int n;cin>>n;int a[n]={10};
A:123.456000 B:123.456 C:123.456*** D:***123.456
A:myfile.seekp(ios::end,0); c=myfile.get(); B:myfileseekp(ios::end,1); c=myfile.get(); C:myfile.seekg(1,ios::end); c=myfile.get(); D:myfile.seekg(-1,ios::end); c=myfile.get();
A:只能作为成员函数 B:用关键字operator开头 C:函数名前面不能指定函数类型 D:函数可以有若干参数
AI参考:在C++语言中，关于类型转换函数的描述，错误的是选项A：只能作为成员函数。类型转换函数在C++中是一种特殊的函数，用于将一种数据类型转换为另一种数据类型。它们通常不是作为类的成员函数，而是作为独立的函数存在。它们通常用关键字`operator`开头，函数名前面可以指定函数类型，并且可以接受若干个参数。因此，选项A描述错误。'
A:构造函数 B:静态成员函数 C:数据成员 D:析构函数
AI参考:正确选项是A：构造函数。构造函数的主要功能是对对象进行初始化。在创建对象时，构造函数会被自动调用，用于设置对象的初始状态，包括分配内存、设置默认值等。静态成员函数是用于操作静态数据成员的函数，与对象的初始化无关。数据成员是对象的一部分，但初始化不是构造函数的职责。析构函数是用于释放对象所占用的资源，如内存、文件句柄等，与对象的初始化也无关。因此，只有构造函数符合题意，能够实现对对象进行初始化的功能。'
A:default B:private C:public D:protected
AI参考:正确选项是C:public。在C++中，类类型声明中默认的访问权限是public，这意味着类中的成员可以在同一文件的其他类中访问，也可以在类的外部访问。private和protected用于指定成员的访问权限，分别表示只能在本类和同一文件的其他类中访问，而protected用于表示成员既可以被同一文件的其他类访问，也可以被派生类访问。default是C++98中的旧名称，现在已经废弃不用，用于表示public的默认访问权限。因此，答案是C：public。'
A:计算机系统自动确定是否共用存储单元 B:实参和形参各占一个独立的存储单元 C:实参和形参共用一个存储单元 D:可以由用户指定是否共用存储单元
A:在调用函数时临时指定 B:定义函数时指定的函数类型 C:调用该函数的主调函数的类型 D:return语句中表达式的类型
A:struct st{int num,char name[20];} ;st a; B:struct st{int num,char name[20];} st a; C:struct {int num,char name[20];} a; D:struct st{int num,char name[20];} a;
AI参考:正确选项是C:struct {int num,char name[20];} a;在C语言中，结构体定义需要使用struct关键字，并且需要使用大括号{}来定义结构体的各个成员。选项A和B都是正确的结构体定义语句，选项D也是正确的，因为结构体名和成员名都使用了小写字母。选项C中，虽然使用了大括号{}来定义结构体的成员，但是结构体名没有使用小写字母，这是不正确的。正确的结构体名应该与成员名相同，并且使用小写字母。因此，选项C是错误的结构体定义语句。'
A:如果异常类型说明是一个省略号（⋯），说明catch 子句只能处理缺省类型的异常 B:C++的异常处理可以包含try(检查)和throw(抛出)，没有catch(捕获)部分。 C:如果某段程序发现了自己不能处理的异常，就可以使用throw 表达式抛掷这个异常，将它抛掷给操作系统。 D:异常处理方法优点在于把异常触发和处理机制分离
A:Tianjin,2009 B:guangzhou,2009 C:Tianjin,2008 D:guangzhou,2008
AI参考:正确选项是【C:Tianjin,2008】。程序运行结果是：Tianjin，2008。在程序中定义了一个结构体数组x，并初始化了两个结构体实例，分别是“guangzhou”和“Tianjin”，然后使用cout打印了第一个结构体实例的name（即"Tianjin"），并打印了第二个结构体实例的birthday.year（即2008）。因此，答案为C选项。'
A:k=fun(10,12.5); B:fun(int y,double m); C:void fun(n,x); D:fun(x,n);
A:显示：X B:显示：Y C:显示：XY D:显示：Z
AI参考:根据提供的语句序列，执行的结果应该是根据用户输入的变量 `n` 的值进行相应的输出。在 `switch` 语句中，当 `n` 的值等于 `1` 或 `2` 时，会输出字符 `X`；当 `n` 的值等于 `3` 或 `4` 时，会输出字符 `Y`；而当 `n` 的值不等于 `1`、`2`、`3` 或 `4` 时，会输出字符 `Z`。所以，选项 D: 显示：Z 是不可能出现的，因为它表示没有匹配的 `case` 而跳过了 `switch` 语句。 因此，正确答案是 D: 显示：Z。"
A:right B:oct C:hex D:dec
A:a[p-a］ B:*p C:a D:*a
A:构造函数 B:赋值操作函数 C:静态成员函数 D:虚函数
A:在C++语言中不可以通过运算符重载创造出新的运算符 B:运算符函数的调用必须使用关键字operator C:运算符重载不能改变操作数的个数、优先级、结合性和运算符的语法结构 D:所有的运算符都可以重载
A:= B:-> C: D:[]
AI参考:正确答案是 D:[]。[]运算符可以重载为类的友元函数，用于访问类的成员变量或成员函数。其他选项A、B、C不能重载为类的友元函数。因此，答案为D。'
A:operator+=(c,d) B:c.operator+=(d) C:c=operator+=(d) D:d.operator+=(c)
A:i,3 B:l,4 C:f,4 D:n,3
A:只在该复合语句中有效，在该复合语句外无效 B:在本程序的源文件范围内均有效 C:此定义方法错误，其变量为非法变量 D:在该函数中任何位置都有效
A:const int N=9; int a[N]; B:int a(9); C:int n=9, a[n];
AI参考:正确选项是【A:const int N=9; int a[N];】。在C/C++中，数组必须在使用前被声明，否则编译器会报错。A选项正确地定义了一维数组a，const int N=9; int a[N];中，const修饰符保证了数组在声明时就被确定大小，不会被改变，这是一个良好的编程习惯。而B选项中没有给出数组的大小就定义了数组a是不正确的，因为C++数组大小必须在使用前确定。C选项中的n只是一个变量名，不是一个数值大小，也不是对数组的正确声明。所以正确的选项是A:const int N=9; int a[N];。'
A:在主函数和其他函数中均要出现 B:只能在除主函数之外的函数中出现一次 C:可以在同一个函数中出现多次 D:必须在每个函数中出现
AI参考:关于return语句，下列正确的说法是（C:可以在同一个函数中出现多次）。return语句用于从当前函数返回调用该函数的程序中的控制。在同一个函数中多次使用return语句是允许的，但应注意合理性和可读性。A选项中，主函数和其他函数中均要出现和D选项必须在每个函数中出现，这两个说法过于绝对，不正确。B选项只能在除主函数之外的函数中出现一次也不完全正确，因为某些函数内部可能会出现多次使用return语句的情况。'
A:公有继承时基类中的public成员在派生类中仍是public的 B:保护继承时基类中的public成员在派生类中是protected的 C:公有继承时基类中的private成员在派生类中仍是private的 D:私有继承时基类中的public成员在派生类中是private的
A:6 B:0 C:5 D:4
A:16 B:14 C:18 D:12
A:cout B:cout C:cout D:cout
A:ios::ate B:ios::in C:ios::out D:ios::app
A:Vector& operator != (const Vector &v); B:bool& operator != (const Vector &v); C:Vector operator != (const Vector &v); D:bool operator != (const Vector &v);
AI参考:正确答案是 D:bool operator != (const Vector &v)。在这里，我们希望重载关系运算符“！”为成员函数，返回一个布尔值以表示两个Vector对象是否不相等。因此，我们需要将返回类型设置为bool，并且函数名应为operator!=。此外，由于我们正在重载一个关系运算符，因此我们需要将参数类型设置为const Vector&，这样我们就可以在比较时保持Vector对象的原始状态不变。因此，选项D是最符合要求的。'
A:一个C程序的所有源程序文件 B:从定义变量的位置开始到源程序文件结束 C:本源程序文件的全部范围 D:函数内全部范围
A:30 B:31 C:32 D:29
AI参考:正确选项是 C:32。程序中定义了一个结构体 stud，包含了字符数组 num、整型数组 s 和双精度浮点数 ave。结构体的大小等于所有成员的大小之和，加上结构体头部的对齐填充和结束标志。在这个程序中，字符数组 num 的大小是 5，整型数组 s 的大小是 4，加上双精度浮点数 ave 的大小，总共是 5 + 4 * 4 + 8 = 31，但由于在结构体开头进行了对齐填充，最终的大小是 32。因此程序输出的结果是32。'
A:outfile.write((double*)&data, sizeof (double)); B:outfile.write((double*)&data, data); C:outfile.write((char*)&data, sizeof (double)); D:outfile.write((char*)&data, data);
A:&c[0] B:c++ C:&c+1 D:p+5
A:a=2, b=3, c=1 B:a=2, b=3, c=3 C:a=2, b=3, c=2 D:a=1, b=2, c=3
A:指定若干字节 B:当前字符 C:一个字符 D:一行字符
A:函数调用可以作为一个函数的形参 B:函数调用可以出现在执行语句或表达式中 C:函数调用不能作为一个函数的实参 D:都不正确
AI参考:选项B是正确的。函数调用可以出现在执行语句或表达式中，它是一个常见的编程实践，允许我们动态地创建和调用函数。同时，函数调用也可以作为另一个函数的实参，参与函数间的参数传递。而选项A、C和D都不完全正确。选项A描述过于绝对，函数调用有时确实可以作为一个函数的形参，但在某些情况下可能也会作为实际参数传递。选项C描述错误，函数调用不仅可以作为一个函数的实参，而且在很多情况下是必需的。选项D则显然否定了选项B和C的正确性。'
A:复用 B:多继承 C:单继承 D:继承
AI参考:答案：B解析：在C++中，可以通过多继承关系派生出多个新的类。也就是说，可以首先声明一个基类，然后通过多个继承关系派生出多个新的类。因此，选项B是正确的。复用和继承是面向对象编程中的两个概念，与题干描述不符。单继承是一种继承方式，只能有一个基类，与题干描述也不符。'
A:str的地址 B:输出乱码或错误 C:C D:C++
A:f1(&a,&b); B:f1(&a,b); C:f1(a,b); D:f1(a,&b);
A:运算符函数是类的友元函数 B:该运算符是一个单目运算符。 C:运算符函数是类的成员函数 D:运算符函数有一个隐含的this指针。
AI参考:正确答案是D：运算符函数有一个隐含的this指针。如果运算符重载函数的形参表中没有参数，那么它必须是类的成员函数，因为成员函数有一个隐含的this指针。而友元函数和单目运算符不需要形参，因此选项A和B是可能的。选项C也是可能的，因为成员函数也可以是运算符函数。因此，选项D是不可能的，因为它要求运算符函数有一个隐含的this指针，而没有参数的函数不会有this指针。'
A:cout B:cout C:cout D:cout
A:5 B:6 C:7 D:4
A:24 B:25 C:20 D:15
AI参考:程序的输出结果是选项【B】25。程序中，f()函数是一个递归函数，每次调用时都会将静态变量i加1，同时将s与i相加。由于每次调用f()时i都会自增，因此最终输出的结果为5次调用f()后的总和。在main()函数中，使用了一个for循环来调用f()函数并将结果累加到变量a中。由于f()函数的最后一次调用返回的是i的当前值（假设此时i的值已经是3），因此a最终的结果为5个值（分别为2,3,4,5,5）的和，即25。所以正确答案为B。'
温馨提示支付 ￥2.20 元后可查看付费内容,请先翻页预览!
