提示:内容已经过期谨慎付费，点击上方查看最新答案
面向对象程序设计（C++）
- 假设有语句：void func(int* m, long& n); int a; long b; 则下列调用合法的是（ ）。
- student类中定义拷贝构造函数的正确写法为（ ）。
- C++中设置this指针是为了（ ）。
- 公有派生时，下列关于派生类对象和基类对象的描述不正确的是（ ）。
- 下列关于new运算符的描述错误的是（ ）。
- 关于类和对象的关系，不正确的是（ ）。
- 使用派生类的主要原因是（ ）。
- 基类中将函数area声明为纯虚函数的正确写法为（ ）。
- 从现有类中构建其子类可以通过 C++语言中的（ ）机制实现。
- 若要将类B的成员函数func声明为类A的友元，则应该（ ）。
- 在下列运算符中,不能重载的是（ ）。
- 函数模板template<class T>中的T可看作是（ ）。
- cin和cout是I/O流库预定义的（ ）。
- 下列函数原型中，满足函数重载规则的是（ ）。
- 基类中声明的虚函数，在派生类中（ ）。
- 若一个类中包含至少一个纯虚函数，那么该类就是（ ）。
- C++中预处理命令在程序中以（ ）开头。
- C++语言中的封装性可以（ ）。
- 一个可正常运行的C＋＋源程序（ ）。
- 若对后置单目运算符“++”进行重载，相当于进行如下哪项函数调用（ ）。
- 重载的运算符<<是一个用于输出的友元函数。（ ）
- C++中引入的友元机制没有破坏封装性。（ ）
- 构造函数可以指定返回类型，而析构函数不能指定任何返回类型。（ ）
- 若派生类的成员函数不能直接访问基类继承过来的某个成员，则该成员一定是基类中的私有成员。（ ）
- 以下类的声明不存在语法问题。
class Time
{public:
Time(){h=10; m=50; s=0; }
Time(int hour=10; int min=50; int sec=0){h=hour; m=min; s=sec; }
private:
int h,m,s;
}; （ ） - C++会在编译阶段针对每个程序单元生成一个目标文件。（ ）
- 静态成员函数可以被声明为虚函数。（ ）
- 抽象类中可以没有纯虚函数，但至少要包含一个虚函数。（ ）
- 动态多态性可通过模板和虚函数实现。（ ）
- 常成员函数只能被常对象调用，而不能被普通对象调用。（ ）
- 单目运算符作为类成员函数重载时可以不包含形参。（ ）
- 对象数组的元素可以是不同类的对象。（ ）
- 私有继承时，基类中只有公有成员在派生类中可见。（ ）
- 友元成员函数在类内只能被public控制符修饰。（ ）
- 使用输出文件流对象的open函数打开文件，失败时返回0。（ ）
- 当一个类的某个函数被virtual修饰后，在后续派生类中与该函数同名的函数都成为虚函数。（ ）
- 若表达式x*y中“*”是作为友元函数重载的运算符，则operator*有2个参数。（ ）
- 使用open函数打开文件之前，需要首先定义流类对象。（ ）
- 使用类模版可以减少重复编码，提升编程效率。（ ）
- C++中打开一个文件就是将该文件与一个流建立关联。（ ）
- 以下可以被public修饰的是（ ）。
- 假如类A的对象a的公有成员函数为x，指向类A的指针为p，则访问该函数的方法有（ ）。
- 实现运行时多态要满足的条件有（ ）。
- 派生层次中可以被继承的有（ ）。
- 以下属于类的成员函数的是（ ）。
- 一个类的友元函数可以访问该类的（ ）。
- 以下关于对象的说法正确的是（ ）。
- 派生类中定义的虚函数必须与基类中相同的部分是（ ）。
- 关于类的说法正确的是（ ）。
- 以下关于对象数组的描述正确的是（ ）。
A:func (a, b) B:func (a, &b) C:func (&a, b) D:func (&a, &b)
答案:f3(b[1]);AI参考:正确答案是B:func (a, &b)。在C++中，函数调用需要满足以下条件：1. 参数类型和数量必须与函数定义中声明的一致；2. 如果是指针或引用类型，必须保证参数能够被正确传递；3. 如果涉及到对象的引用，需要确保对象的生命周期不被提前结束。选项A中，参数类型不匹配，不能调用；选项C中，第一个参数是a的地址，但是func函数定义中并没有声明接受指针类型的参数；选项D中，第一个参数是a的地址，第二个参数是b的引用，但是func函数定义中声明的是int* m和long& n，两者不匹配。只有选项B中，第一个参数是a的副本，第二个参数是b的引用，满足调用要求。因此，选项B是正确的调用方式。'
A:student::student(student stu) B:student::student(const student stu) C:student::student(student* stu) D:student::student(student& stu)
AI参考:正确选项是B:student::student(const student& stu)。拷贝构造函数通常用于创建一个新的对象，其内容与给定的对象相同。在这种情况下，我们需要确保新对象不改变原始对象的状态。因此，使用const关键字可以确保我们不会意外地修改原始对象。所以，正确的拷贝构造函数声明应该是：student::student(const student& stu)。'
A:保证基类私有成员在子类中可以被访问 B:保证基类保护成员在子类中可以被访问 C:保证基类公用成员在子类中可以被访问 D:区分不同对象拥有的数据成员，但共享这些处理数据成员的代码
答案:创建对象后,将指向该对象AI参考:在C++中，this指针的主要作用是用来指向当前对象的。它主要用于在子类中访问基类的成员。当一个成员函数被调用时，它会自动传入当前对象的指针，这个指针就被称为this指针。对于选项A和B，这两个选项描述的是基类的私有和保护成员在子类中的访问问题，但是C++中的访问修饰符私有和保护是用来限制成员的可访问性的，不会影响基类的成员在子类中的可见性，因此这两个选项不正确。对于选项D，虽然this指针的确可以用来区分不同对象拥有的数据成员，但是这个功能并不是设置this指针的初衷，因为基类的成员在子类中都是可见的，没有必要通过this指针来区分数据成员。所以选项C“保证基类公用成员在子类中可以被访问”是正确答案。这是因为公用成员在C++中是可以被子类继承并修改的，设置this指针可以让子类中的成员函数更方便地访问和操作这些公用成员。'
A:派生类对象可以初始化基类的引用 B:派生类类内可以访问基类中的成员 C:派生类对象的地址可以赋值给指向基类的指针 D:派生类对象可以给基类对象赋值
答案:派生类的对象可以直接访问基类的成员AI参考:"单选题"关于派生类对象和基类对象的描述不正确的是：D:派生类对象可以给基类对象赋值。解释：D选项描述错误，因为派生类对象和基类对象是两种不同的对象，它们之间没有赋值关系。派生类对象包含了基类的成员和自己的成员，而基类对象只包含自己的成员。因此，派生类对象不能直接赋值给基类对象。其他选项都是正确的描述，派生类对象可以初始化基类的引用，派生类类内可以访问基类中的成员，派生类对象的地址可以赋值给指向基类的指针。'
A:使用它创建对象数组时必须指定初始值 B:使用它创建的对象可以使用运算符delete删除 C:它可以用来动态创建对象数组 D:使用它创建对象时要调用构造函数
答案:使用运算符new创建对象数组时必须定义初始值
A:一个对象只能属于一个类 B:类本身是不占用内存空间的 C:一个类只能有一个对象 D:类和对象的关系就是一种数据类型与变量的关系
答案:同一类的不同对象，其具有的操作可不同，具体的操作也不同
A:实现数据的隐藏 B:加强类的封装性 C:提升软件代码的可重用性 D:提升程序的执行效率
A:virtual float area(){ }; B:float area()=0； C:virtual float area()=0{ }； D:virtual float area()=0；
AI参考:正确选项为B:float area()=0；在C++中，纯虚函数必须定义在基类中，但没有具体实现。纯虚函数的声明必须以“=0”结尾，并且返回值类型必须为浮点数。所以选项B是正确的写法。选项A中的返回类型应该为float，但没有写明是纯虚函数；选项C和D中的括号内多了一个花括号，这是错误的。因此，正确选项为B。'
A:继承 B:多态 C:封装 D:抽象
A:在类A中加入语句friend void A::func(); B:在类B中加入语句friend void A::func(); C:在类B中加入语句friend void B::func(); D:在类A中加入语句friend void B::func();
AI参考:正确答案是B:在类B中加入语句friend void A::func();。在C++中，友元函数和友元类都是用于增强类之间的交互，但是他们的使用方式和规则是不同的。对于成员函数的友元，需要明确指定是哪个类的成员函数，所以应该是在类B中加入语句friend void A::func();。这样，类A的成员函数func就可以访问类B的私有和受保护成员了。而选项A和D都是错误的，因为他们没有明确指定是哪个类的成员函数。选项C也是错误的，因为友元函数不能直接访问另一个类的成员变量，只能访问成员函数。'
A:！ B:new C:sizeof D:delete
AI参考:正确答案是B:new。在C++中，运算符重载需要满足以下条件：运算符必须是对类的成员运算符；运算符必须具有一个参数；运算符重载的参数类型必须与运算符的参数类型一致；运算符重载不能改变运算符的语义。new和delete是C++中用于内存分配和释放的关键字，不能被重载。因此，答案为B选项。'
A:函数形参 B:函数实参 C:模板形参 D:模板实参
AI参考:正确选项是C：模板形参。在函数模板中，template
A:对象 B:头文件 C:类 D:函数
A:float func (float a, int y); void func (float b) B:float func(float a); void func (float b) C:float func (float a); float func (float b) D:float func (float a); void func (float b)
AI参考:正确答案是 B:float func(float a); void func (float b)。函数重载是指在同一作用域内，可以有多个同名函数，它们的参数列表（参数个数或参数类型）应不同。根据题目给出的选项，只有B选项符合这个规则，因为第一个函数是只有一个float类型的参数，而第二个函数有两个float类型的参数。其他选项中的函数原型都不满足函数重载规则。'
A:无法继承该虚函数 B:只有重新加virtual定义才是虚函数 C:即使不加virtual声明，也会自动继承该虚函数 D:若没有重新定义，则不是虚函数
AI参考:正确选项是C:即使不加virtual声明，也会自动继承该虚函数。在C++中，基类中的虚函数如果没有被派生类继承，那么在派生类中这个函数就会消失。但是，如果基类中的虚函数被派生类继承了，那么派生类中的这个函数就是基类中的虚函数的等价物。即使在派生类中没有重新定义这个函数，它仍然是虚函数。因此，选项C是正确的。选项A和B都是错误的，因为虚函数的定义必须使用virtual关键字。选项D也是错误的，因为即使没有重新定义，如果基类中的虚函数被派生类继承了，那么它仍然是虚函数。'
A:具体类 B:其余选项都不对 C:抽象类 D:派生类
AI参考:正确选项是C：抽象类。一个类中包含至少一个纯虚函数，就表示该类是一个抽象类，不能被实例化，只能被继承。因此，选项C是正确答案。选项A、B、D都不符合题意。'
A:# B:// C:& D:*
AI参考:正确答案是A：#。在C++中，预处理命令通常以“#”开头。预处理命令在程序编译之前进行一些处理，例如包含头文件、宏定义等。B、C、D选项中的“//”、“&”和“*”都不是预处理命令的常见开头字符。'
A:实现数据共享 B:避免模块之间数据的非法访问 C:实现数据的规范化 D:保护数据不被丢失
AI参考:在C++语言中，封装性可以用于实现数据的保密性，即避免模块之间数据的非法访问。封装是面向对象编程中的一个重要概念，它将数据（属性）和操作数据的函数（方法）捆绑在一起，形成一个独立的单元。通过封装，我们可以控制对数据的访问，防止未经授权的访问和修改，从而保护数据的安全。因此，答案为B：避免模块之间数据的非法访问。'
A:仅能包含一个主函数 B:可以不包含普通函数仅由一个主函数构成 C:可以由一个或多个主函数构成 D:必须由一个主函数和一个以上的普通函数构成
AI参考:正确答案是A:仅能包含一个主函数。一个可正常运行的C++源程序必须仅包含一个主函数，且主函数必须作为程序的入口点。其他选项都与C++语言的规定不符。B选项和C选项都包含错误，D选项则包含一个以上普通函数，这也不符合C++语言的规定。因此，正确答案是A。'
A:a.operator++() B:operator++() C:a.operator++(a, 0) D:operator++(a, 0)
AI参考:正确答案是 D:operator++(a, 0)。后置单目运算符“++”在重载时需要两个参数，第一个参数是一个引用，用于修改原对象的状态；第二个参数是零，用于实现前置自增的功能。选项中只有D符合要求。其他选项都不完整。所以正确答案为D。'
A:对 B:错
AI参考:答案：B：错。重载的运算符<<并不是一个用于输出的友元函数，它通常用于输出流中，是一个输出运算符的重载。因此，该判断题是错误的。'
A:错 B:对
AI参考:答案是B：对。在C++中，友元是一种特殊的成员函数或类型，它可以在类内部或者类外部被访问，没有破坏封装性。封装性是面向对象编程中的一个重要概念，它保证了类内部的数据和行为被封装起来，只能通过类的成员函数进行访问和操作。引入友元机制不会破坏封装性，因为它仍然在类的内部进行访问和控制。因此，该判断题是正确的，选项B为正确答案。'
A:对 B:错
AI参考:答案：B:错。析构函数可以指定任何返回类型，因为它不需要执行任何计算或操作，只需要完成清理工作并返回。而构造函数通常用于初始化对象，因此不能指定返回类型。'
A:对 B:错
A:错 B:对
AI参考:这个类的声明在语法上是正确的，所以答案是B：对。这个类名为"Time"，有三个私有成员变量h、m和s，以及两个公有构造函数，一个接受无参构造函数，另一个接受三个参数的构造函数，用于初始化h、m和s的值。此外，构造函数中的初始化列表中的分号是必须的，否则会导致语法错误。所以这个类的声明是正确的。'
A:错 B:对
AI参考:正确答案是B：对。C++会在编译阶段针对每个程序单元生成一个目标文件，也就是说每个源代码文件都会被编译成一个单独的目标文件。这是C++编译器的常规操作，有助于提高编译速度和代码的可维护性。因此，这个判断题的答案是B，即“对”。'
A:对 B:错
A:错 B:对
AI参考:答案：B:对。抽象类中可以没有纯虚函数，但至少要包含一个虚函数。这是面向对象编程中的一个基本概念。在抽象类中，纯虚函数是一种特殊的虚函数，它没有实现任何功能，只用来定义一个接口。而虚函数是抽象类中的一种常见成员函数，用于实现抽象类中的一些基本功能。因此，选项B是正确的。'
A:对 B:错
A:对 B:错
AI参考:答案是B：错。常成员函数可以在普通对象和非常对象之间调用，因为它可以在声明时使用关键字"const"修饰成员函数，表示该成员函数不会修改类的任何成员变量。但是，如果常成员函数被声明为const成员函数，则只能被常对象调用，不能被普通对象调用。因此，这个说法是错误的。'
A:对 B:错
AI参考:单目运算符作为类成员函数重载时可以不包含形参，所以这个说法是正确的。答案为选项A：“对”。当在类中重载单目运算符时，它可以是成员函数或者友元函数，并且通常不包含任何参数。这些运算符主要用于操作对象的值，而不是传递额外的参数。成员函数可以对类的实例进行操作，而无需通过类外部传递任何额外的信息。因此，对于单目运算符的重载，可以不需要包含任何形参。'
A:对 B:错
A:对 B:错
A:对 B:错
AI参考:答案：B：错在C++中，友元成员函数在类内可以被public、protected或private控制符修饰。所以这个说法是错误的。'
A:错 B:对
AI参考:答案是B：对。使用输出文件流对象的open函数打开文件时，如果成功打开文件，则返回一个非零值（通常是文件流的指针）；如果打开文件失败，则返回0。因此，该判断题是正确的。'
A:错 B:对
AI参考:正确答案是：A：错。一个类的某个函数被virtual修饰后，在后续派生类中与该函数同名的函数不一定成为虚函数。只有在基类中的函数是虚函数，在派生类中重新定义了这个函数并使用了virtual关键字，该函数才成为虚函数。所以该判断题错误。'
A:错 B:对
AI参考:答案是B：对。在C++中，如果运算符被重载为友元函数，那么运算符的重载版本将会接受额外的参数。对于表达式x*y，如果“*”是作为友元函数重载的运算符，那么operator*应该有2个参数，即除了两个操作数x和y之外，还额外接受一个额外的参数表示运算符本身。因此，这个判断题是正确的。'
A:对 B:错
AI参考:答案是B:错。在使用open函数打开文件之前，不需要首先定义流类对象。open函数是一个用于打开文件的内置函数，它不需要任何参数就可以直接打开文件。在使用open函数打开文件后，可以使用流类对象（如fstream）来对文件进行读写操作。因此，这个判断题的答案是B:错。'
A:错 B:对
AI参考:答案是B：对。使用类模板可以减少重复编码，提高编程效率。类模板是一种特殊的模板，它允许程序员创建可重复使用的代码块，这些代码块可以用于创建具有相同结构的不同对象。使用类模板可以减少重复编码的工作量，提高编程效率。因此，这个判断题的答案是B：对。'
A:对 B:错
A:类外函数 B:数据成员 C:静态成员函数 D:成员函数
AI参考:正确选项是【D:成员函数】。public是Java中的一个访问修饰符，它表示该成员可以被任何其他类访问。因此，只有成员函数可以被public修饰，因为它属于类的成员。类外函数、数据成员和静态成员函数都不能被public修饰，因为它们属于类的内部结构，只能被同一个类或同一个包中的其他类访问。因此，答案为D：成员函数。'
A:(*p).x() B:p->x() C:(*p)->x() D:a.x()
AI参考:正确选项是【B:p->x()】题目要求访问类A的对象a的公有成员函数x，使用指向类A的指针p进行访问。选项A使用了指针的解引用运算符（*），但由于指针已经被定义，不需要再进行解引用操作，所以A选项错误。选项C在调用成员函数时使用->操作符是正确的，但前面加上解引用运算符（*）就变成了访问指针成员函数的方式，所以C选项也错误。选项D直接使用对象a调用公有成员函数x，虽然语法上正确，但不符合题目要求使用指向类A的指针p进行访问。只有选项B正确使用了指针的->操作符来访问成员函数x。所以正确答案是B：p->x()。'
A:在派生类中对虚函数进行了重新定义 B:要有一个继承层次 C:在基类中定义了虚函数 D:要通过基类的指针或引用来调用虚函数
AI参考:实现运行时多态要满足的条件有（ ）。选项C和D是正确的。实现运行时多态需要满足以下两个条件：1. 在基类中定义了虚函数（virtual function）：这是实现运行时多态的基本要求。虚函数是一种在基类中声明但在派生类中可以重新定义的函数，它允许在运行时根据对象的实际类型来调用不同的函数实现。2. 要通过基类的指针或引用来调用虚函数（through base pointer/reference）：这是实现运行时多态的另一个关键条件。通过基类的指针或引用来调用虚函数时，编译器会根据实际对象的类型来决定调用哪个函数实现，从而实现运行时的多态性。因此，选项C和D都是正确的。选项A和B虽然也是实现运行时多态的条件，但它们不是必要的条件。因此，正确选项是：C:在基类中定义了虚函数 和 D:要通过基类的指针或引用来调用虚函数。'
A:转换函数 B:静态成员函数 C:构造函数 D:虚函数
AI参考:正确选项为：B、C、D。在C++中，构造函数和虚函数可以被派生类继承，静态成员函数不能被继承。转换函数一般不被认为是派生类可以继承的函数，因为转换函数的主要目的是进行类型转换，通常不由派生类决定。因此，正确选项为B、C、D。'
A:静态成员函数 B:析构函数 C:友元函数 D:构造函数
AI参考:正确选项为：D: 构造函数。构造函数是类的成员函数，用于初始化对象的数据成员。静态成员函数属于类的非成员函数，不能直接访问类的数据成员；析构函数是类的成员函数，但不是成员函数的一种类型；友元函数是类的非成员函数，可以访问类的私有和保护成员。因此，只有D选项是类的成员函数。'
A:公有成员 B:私有成员 C:保护成员 D:都不能访问
AI参考:正确选项为【B:私有成员和保护成员】。私有成员和保护成员是类的内部实现细节，只能由该类的成员函数和友元函数访问，因此友元函数可以访问私有成员和保护成员。而公有成员则是类的外部可见性，可以被类的外部函数和友元函数访问。因此，选项A和D是错误的。因此，答案为B、C、D。'
A:对象之间不能相互赋值 B:对象可以作为数组元素 C:对象可用作函数参数 D:对象可以作为类中的成员
AI参考:正确答案是：B:对象可以作为数组元素，C:对象可用作函数参数，D:对象可以作为类中的成员。对象不可以作为函数参数(函数参数的类型一般可以是变量，如数组元素等)，对象不可以互相赋值。故答案为BCD。选项A不正确。故本题正确答案为BCD。'
A:参数个数 B:函数体 C:函数名称 D:参数类型
AI参考:正确选项是【参数类型和参数个数】。虚函数是在基类中声明的一个函数，它可以在派生类中被重新定义或者重写。在派生类中定义的虚函数必须与基类中的函数名称相同，并且必须具有相同的参数类型和参数个数。函数体可以在派生类中被重新定义，也可以保持与基类中相同的函数体。因此，选项B和C是正确的。选项A和D是不正确的，因为虚函数的参数类型和参数个数是派生类中必须与基类保持一致的部分。'
A:若类中成员没有访问权限说明，则成员可被类外访问 B:类是一种自定义的数据类型 C:类是一种抽象的数据类型 D:只有类的成员函数或友元函数才能访问类的私有成员
A:对象数组的数组名是一个常量指针 B:对象数组在创建时可以同时初始化 C:对象数组中的每一个元素都是同类或派生层次中类的对象 D:对象数组的下标都是从0开始的
AI参考:关于对象数组的描述，以下选项正确的是：B:对象数组在创建时可以同时初始化；C:对象数组中的每一个元素都是同类或派生层次中类的对象。A选项中，对象数组的数组名是一个常量指针，这个描述是正确的，但这不是关于对象数组的描述，而是关于数组本身的描述。D选项中，对象数组的下标不是从0开始的，这个描述也是正确的，但也不是关于对象数组的描述。对于B选项，对象数组在创建时可以同时初始化。这个描述是正确的，因为对象数组在创建时，可以直接将所有元素都初始化。对于C选项，对象数组中的每一个元素都是同类或派生层次中类的对象。这个描述也是正确的，因为对象数组中的元素必须具有相同的类型或者是在同一个继承层次中的类型。因此，正确答案是B和C。'
温馨提示支付 ￥1.30 元后可查看付费内容,请先翻页预览!
