成员函数中访问对象的私有成员问题

练习题11.1 判断题×1．C++语言和C语言都是面向对象的程序设计语言。

√2．面向对象方法具有封装性、继承性和多态性。

√3．C语言是C++语言的一个子集。

C++语言继承了C语言。

×4．C++语言程序与C语言程序一样都是函数串。

×5．C++语言支持封装性和继承性，不支持多态性。

√6．C++语言比C语言对数据类型要求更加严格了。

√7．C++语言对C语言进行了一次改进，使得编程更加方便了。

×8．C++源程序在编译时可能出现错误信息，而在连接时不会出现错误信息。

√9．编译C++源程序时，出现了警告错（Warning）也可以生成可执行文件。

√10．C++语言程序的实现也要经过编辑、编译连接和运行3个步骤。

1.2 单选题1．下列关于面向对象概念的描述中，错误的是（C ）。

A．面向对象方法比面向过程方法更加先进B．面向对象方法中使用了一些面向过程方法中没有的概念C．面向对象方法替代了结构化程序设计方法D．面向对象程序设计方法要使用面向对象的程序设计语言2．下列各种高级语言中，不是面向对象的程序设计语言是（D ）。

A．C++ B．JavaC．VB D．C3．下列关于类的描述中，错误的是（ A ）。

A．类就是C语言中的结构类型B．类是创建对象的模板C．类是抽象数据类型的实现D．类是具有共同行为的若干对象的统一描述体4．下列关于对象的描述中，错误的是（C ）。

A．对象是类的一个实例B．对象是属性和行为的封装体C．对象就是C语言中的结构变量D．对象是现实世界中客观存在的某种实体5．下列关于C++程序中使用提取符和插入符的输入/输出语句的描述中，错误的是（C ）。

A．提取符是对右移运算符（>>）重载得到的B．插入符是对左移运算符（<<）重载得到的C．提取符和插入符都是双目运算符，它们要求有两个操作数D．提取符和插入符在输入/输出语句中不可以连用1.3 填空题1．C++语言具有面向对象方法中要求的三大特性：封装性、继承性和多态性。

面向对象的程序设计语言――C++(第二版)-习题参考答案课后习题答案以及代码习题参考答案第1章1．填空题C++语言概述（1）函数说明，函数体（2）声明区，主程序区，函数定义区（3）多态性（4）namespace，using（5）std（6）cin,（7）//（8）对数据的操作2．判断题（1）对（2）错（3）错（4）错（5）错3．改错题（1）没有函数体，应改为void main() {};（2）语句没有分号，应改为using namespace myspace；（3）cout和操作符共同完成输出的功能，应改为cout“ Input your name:";（4）应改为#include iostream.h4．简答题5．编程题（略）（略）第2章1．选择题基本数据类型、运算符与表达式（1）B （2）D （3）B （4）D （5）B课后习题答案以及代码2．简答题（1）（a）、（c）（e）、（f）、（g）、（h）、（i）（2）（a）、（g）、（i）、（j）（3）（a）5.5（b）0（c）20（d）0，0（e）1（f）1，2（g）3（h）－40（i）2（j）3（k）s1='0's1='9'（l）N!=03．读程序写结果（1）0，15（2）（1、1、1），（－1、－1、－1）（3）（a）a*a+2*a*b+b*b（b）4.0/3.0*3.__-__R*R*R（c）5.0/9.0*(F-32)（d）b=ab=c（4）364143（5）x=14．编程题（略）第3章1．选择题（1）B （2）A （3）A （4）C2．判断题（1）错（2）对（3）对（4）错3．读程序写结果（1）C++的控制语句5）A 5）错（（课后习题答案以及代码12 23 3 34 4 4 45 5 5 5 5（2）11 2 11 2 3 2 11 2 3 4 3 2 11 2 3 4 5 4 3 2 1（3）j的值为0；i的值为2；4．编程题（略）第4章1．填空题函数（1）void（2）静态全局变量，static（3）函数重载（4）inline（5）递归函数（6）宏定义命令，文件包含命令，条件编译命令2．判断题（1）错（2）错（3）错（4）错（5）错（6）对（7）错（8）错（9）对（10）对3．读程序写结果（1）x=7,y=4x=9,y=5（2）34.56101（3）162228（4）12 15 18 21 24课后习题答案以及代码（5）2,1,4,1,3,2,1,4．简答题5．编程题（略）（略）第5章1．选择题构造数据类型（1）C （2）D （3）A （4）B （5）C 2．判断题（1）错（2）对（3）对（4）错（5）错3．读程序写结果（1）153（2）422 5 6 8 10（3）__，21（4）419（5）6904（6）43214．编程题（略）第6章1．填空题（1）类，对象，类（2）数据成员，成员函数（3）不能（4）private，protected，public，private （5）成员函数类和对象课后习题答案以及代码（6）friend（7）类名，作用域运算符（8）对象名.成员名，指针变量名-成员名，(*指针变量名).成员名（9）构造，析构，构造，析构（10）常量数据，引用数据（11）全局，数据类型，所属的类（12）常成员，只读（13）成员，友元（14）类数据成员，类成员函数（15）this（16）浅拷贝2．选择题（1）C （2）C （3）B （4）C （5）B（6）C （7）D （8）B （9）C （10）D（11）A （12）C （13）D （14）D （15）B3．改错题（1）man1.salary=1000.00; 不能在类外访问类的私有成员（2）float r=0;和float c=0; 类本身是抽象的，不能在类的定义体中给其数据成员赋值}后缺少分号“；”（3）成员函数void setdata(float x1,float y1,float r);没有实现（4）构造函数名point()应与类名同名，为Point没有头文件包含#include iostream.h4．读程序写结果题（1）x=0,y=0x=100,y=200（2）x=100,y=200x=1000,y=2022年t=3.14（3）Sta::fun2()=10s.fun2()=11r.a=20（4）Constructor1 called!x=0Constructor2 called!x=100Destructor called!Destructor called!（5）课后习题答案以及代码575．简答题6．编程题（略）（略）第7章1．填空题（1）继承（2）基类，派生类（3）private，protected，public，private （4）不可访问，保护，公有（5）私有（6）单（一），多（重）（7）赋值兼容规则（8）静态，动态（9）抽象类2．选择题继承和派生（1）B （2）A （3）B （4）C （5）B （6）A （7）D （8）B （9）B （10）B（11）D （12）B3．改错题（1）本题的错误主要是数据成员的访问权限问题：基类的私有成员在派生类中不可访问，如fb()函数中的a3=30;语句；类的私有和保护成员在类外不能访问，如main函数中的x.a2 =20;.a3=30; ，y.a2=200; ，y.a3=300; ，y.b2=2022年;和y.b3=3000;语句。

继承练习1.在派生类对基类继承的传递性中，C 是错误的。

(2分)A 在公有继承方式下，直接派生类对象可以直接调用基类中的公有成员函数，去访问基类的私有数据成员B 在公有继承方式下，间接派生类对象可以直接调用基类中的公有成员函数，去访问基类的私有数据成员C 在私有继承方式下，间接派生类对象可以直接调用基类中的公有成员函数，去访问基类的私有数据成员D 不管是私有继承还是公有继承，基类中的私有成员在派生类的作用域内都是不可能见的。

2.下列有关继承和派生的叙述中，正确的是：C (2分)A 派生类不能访问通过私有继承的基类的保护成员B 多继承的虚基类不能够实例化C如果基类没有默认构造函数，派生类就应当定义带形参的构造函数D 类的的析构函数和虚函数都不能够被继承，需要在派生类中重新实现第一次上机课3.设x和y均为bool量，则x&&y为真的条件是（A）。

(2分)A它们均为真B其中一个为真C它们均为假D其中一个为假4.设int x；，则经过（C）后，语句*px=0；可将x值置为0。

(2分)A int * px；B int const * px=&x；C int * const px=&x；D const int * px=&x；第三次上机课2-1在以下哪种情形，复制构造函数会被调用。

（ B ）(2分)A当一个对象采用引用方式，作为参数传递给一个函数B当一个函数采用值方式，返回一个对象C当一个对象赋值给另一个对象D以上答案都不对2-2对于以下关于友元的说法（D）(2分)A如果函数fun被声明为类A的友元函数，则该函数成为A的成员函数B如果函数fun被声明为类A的友元函数，则该函数能访问A的保护成员，但不能访问私C如果函数fun被声明为类A的友元函数，则fun的形参类型不能是A。

D以上答案都不对2-3对于类之间的友元关系：（D）(2分)A如果类A是类B的友元，则B的成员函数可以访问A的私有成员B如果类A是类B的友元，则B也是A的友元。

C++友元函数和友元类（C++friend）详解私有成员只能在类的成员函数内部访问，如果想在别处访问对象的私有成员，只能通过类提供的接⼝（成员函数）间接地进⾏。

这固然能够带来数据隐藏的好处，利于将来程序的扩充，但也会增加程序书写的⿇烦。

是从结构化的C语⾔发展⽽来的，需要照顾结构化设计程序员的习惯，所以在对私有成员可访问范围的问题上不可限制太死。

C++ 设计者认为，如果有的程序员真的⾮常怕⿇烦，就是想在类的成员函数外部直接访问对象的私有成员，那还是做⼀点妥协以满⾜他们的愿望为好，这也算是眼前利益和长远利益的折中。

因此，C++ 就有了友元（friend）的概念。

打个⽐⽅，这相当于是说：朋友是值得信任的，所以可以对他们公开⼀些⾃⼰的隐私。

友元分为两种：友元函数和友元类。

友元函数在定义⼀个类的时候，可以把⼀些函数（包括全局函数和其他类的成员函数）声明为“友元”，这样那些函数就成为该类的友元函数，在友元函数内部就可以访问该类对象的私有成员了。

将全局函数声明为友元的写法如下：friend 返回值类型函数名(参数表);将其他类的成员函数声明为友元的写法如下：friend 返回值类型其他类的类名::成员函数名(参数表);但是，不能把其他类的私有成员函数声明为友元。

关于友元，看下⾯的程序⽰例。

1. #include<iostream>2. ug namespace std;3. class CCar; //提前声明CCar类，以便后⾯的CDriver类使⽤4. class CDriver5. {6. public:7. void ModifyCar(CCar* pCar); //改装汽车8. };9. class CCar10. {11. private:12. int price;13. friend int MostExpensiveCar(CCar cars[], int total); //声明友元14. friend void CDriver::ModifyCar(CCar* pCar); //声明友元15. };16. void CDriver::ModifyCar(CCar* pCar)17. {18. pCar->price += 1000; //汽车改装后价值增加19. }20. int MostExpensiveCar(CCar cars[], int total) //求最贵⽓车的价格21. {22. int tmpMax = -1;23. for (int i = 0; i<total; ++i)24. if (cars[i].price > tmpMax)25. tmpMax = cars[i].price;26. return tmpMax;27. }28. int main()29. {30. return 0;31. }这个程序只是为了展⽰友元的⽤法，所以 main 函数什么也不做。

int elems[100],PC;
};
int S::IsMemberOf(int n)
{
for(int i=0;i<PC;i++)
if(elems[i]==n)
return 1;
return 0;
}
int S::Add(int n)
{
if(IsMemberOf(n))
return 1;
else if(PC==100)
√24．友元类中的所有成员函数都是友元函数。
√25．类型转换函数是一种特殊的成员函数，定义时不加类型说明，无函数参数。
√26．单参数的构造函数具有类型转换的作用。
6.2单选题
1．下列关于类的定义格式的描述中，错误的是（C）。
A．类中成员有3种访问权限
B．类的定义可分说明部分和实现部分
C．类中成员函数都是公有的，数据成员都是私有的
答：编程如下：
#include <iostream.h>
class ASMD
{
public:
ASMD(double a,double b)
{ x=a; y=b; }
void Addition()
{ cout<<x+y<<endl; }
void Subtration()
{ cout<<x-y<<endl; }
a.Print();
b.Print();
}
答：Default constructor called.
Constructor called.
a1=0,a2=0
a1=5,a2=8
Destructor called.

c++访问私有private成员变量的常⽤⽅法⽬录下⾯是其它⽹友的补充访问C++类对象中私有成员变量的⽅法类的对象不能直接访问类声明的私有成员变量，否则破坏了信息隐藏的⽬的。

在C++中，为了防⽌某些数据成员或成员函数从外部被直接访问，可以将它们声明为private，这样编译器会阻⽌任何来⾃外部⾮友元的直接访问。

私有成员变量的常⽤访问⽅法如下：(1)通过公共函数为私有成员赋值#include <iostream>using namespace std;class Test{private:int x, y;public:void setX(int a){x=a;}void setY(int b){y=b;}void print(void){cout<<"x="<<x<<'\t'<<"y="<<y<<endl;}} ;int main(){Test p1;p1.setX(1);p1.setY(9);p1.print( );return 0;}(2)利⽤指针访问私有数据成员#include <iostream>using namespace std;class Test{private:int x,y;public:void setX(int a){x=a;}void setY(int b){y=b;}void getXY(int *px, int *py){*px=x; //提取x,y值*py=y;}};int main(){Test p1;p1.setX(1);p1.setY(9);int a,b;p1.getXY(&a,&b); //将 a=x, b=ycout<<a<<'\t'<<b<<endl;return 0;}(3)利⽤函数访问私有数据成员#include <iostream>using namespace std;class Test{private:int x,y;public:void setX(int a){x=a;}void setY(int b){y=b;}int getX(void){return x; //返回x值}int getY(void){return y; //返回y值}};int main(){Test p1;p1.setX(1);p1.setY(9);int a,b;a=p1.getX( );b=p1.getY();cout<<a<<'\t'<<b<<endl;return 0;}(4)利⽤引⽤访问私有数据成员#include <iostream>using namespace std;class Test{private:int x,y;public:void setX(int a){x=a;}void setY(int b){y=b;}void getXY(int &px, int &py) //引⽤ {px=x; //提取x,y值py=y;}};int main(){Test p1,p2;p1.setX(1);p1.setY(9);int a,b;p1.getXY(a, b); //将 a=x, b=ycout<<a<<'\t'<<b<<endl;return 0;}下⾯是其它⽹友的补充访问C++类对象中私有成员变量的⽅法原则上，C++类中私有变量不允许在类之外的其他任何地⽅访问，⼀般来说功能完善的类都会提供get,set⽅法来操作类属性值，但如果没有get、set⽅法都没有提供，⽐如使⽤的是第三⽅提供的.o（或者动态库）来进⾏开发的，并且实际应⽤中我们确确实实需要改变其中某个对象的⼀个私有参数，有没有什么办法呢？我们知道，⼀个进程有程序段和数据段，如果我们知道了对象的数据空间，那么得到该对象的成员变量值也就很简单了，⽽实际上，对象数据段的⾸地址其实就是对象地址，以例⼦说明：class A{public:int i;bool setJ(int _j){j = _j;};int getJ() const {return j;};private:int j;};int main(){A a;printf("a's address is %u.n",&a); // 打印对象a的地址printf("a.i's address is %u.n",(&(a.i))); // 打印对象a的成员变量i的地址}执⾏上⾯程序，可以看到结果，两个值时⼀样的，也就是说明对象地址就是第⼀个成员变量的地址。

一、选择题(40)1.C++对C语言作了很多改进，下列描述中（D）使得C语言发生了质变，从面向过程变成了面向对象。

A、增加了一些新的运算符；B、允许函数重载，并允许设置缺省参数；C、规定函数说明必须用原型；D、引进了类和对象的概念；2.下列描述中，（C）是错误的。

A、内联函数主要解决程序的运行效率问题；B、内联函数的定义必须出现在内联函数第一次被调用之前；C、内联函数中可以包括各种语句；D、对内联函数不可以进行异常接口声明；3.在C++中，关于下列设置缺省参数值的描述中，（B）是正确的。

A、不允许设置缺省参数值；B、在指定了缺省值的参数右边，不能出现没有指定缺省值的参数；C、只能在函数的定义性声明中指定参数的缺省值；D、设置缺省参数值时，必须全部都设置；4.（D）不是构造函数的特征。

A、构造函数的函数名与类名相同；B、构造函数可以重载；C、构造函数可以设置缺省参数；D、构造函数必须指定类型说明。

5.（D）是析构函数的特征。

A、析构函数可以有一个或多个参数；B、析构函数名与类名不同；C、析构函数的定义只能在类体内；D、一个类中只能定义一个析构函数；6.关于成员函数特征的下列描述中，（A）是错误的。

A、成员函数一定是内联函数；B、成员函数可以重载；C、成员函数可以设置缺省参数值；D、成员函数可以是静态的；7.下列静态数据成员的特性中，（C）是错误的。

A、说明静态数据成员时前边要加修饰符static；B、静态数据成员要在类体外进行初始化；C、静态数据成员不是所有对象所共用的；D、引用静态数据成员时，要在其名称前加<类名>和作用域运算符；8.友元的作用是（A）。

A、提高程序的运用效率；B、加强类的封装性；C、实现数据的隐藏性；D、增加成员函数的种类；9.关于new运算符的下列描述中，（D）是错误的。

A、它可以用来动态创建对象和对象数组；B、使用它创建的对象或对象数组可以使用运算符delete删除；C、使用它创建对象时要调用构造函数；D、使用它创建对象数组时必须指定初始值；10.关于delete运算符的下列描述中，（C）是错误的。

cout<<"int"<<max(a1,b1)<<endl;
cout<<"long"<<max(a2,b2)<<endl;
cout<<"double"<<max(a3,b3)<<endl;//使用相同的函数名求不同类型数据的绝对值
return 0;
}
int max(int a,int b)
{int c;
一个类的内部数据结构和其所有成员函数的定义部分称为类的实现。
2.3公用public成员和私有private成员有何区别？
【解答】
私有private成员只能被该类中的其他成员访问，而程序中的其它代码是不能直接访问这些变量的。
公用public成员既可以被该类的其他成员访问，也可以被程序中的其它代码访问。类中的公用成员对外部代码是开放的，通常情况下，程序中的其它代码通过类的公用成员函数来访问类的私有成员。
方法：面向对象程序设计中的术语“方法”对应于对象的行为（能力），即它是实现对象所具有的功能操作的代码段。在C++程序中，方法即是类中定义的成员函数，它是该类对象所能执行的操作的算法实现。
消息：在面向对象的程序中，一个对象向另一个对象发出的请求称为消息。消息是要求某个对象执行其中某个功能操作的规格说明。程序中的所有对象通过消息传递实现相互协作，完成一些特定的任务。
{ Rectangle Rect(10,15);
cout<<"Area is:"<<Rect.area()<<endl;
}
第
3.1解释下列名词：

MFC中的This的用法一、This指针的定义在MFC中，This指针是一个特殊的指针，它指向当前对象实例。

在类的成员函数中，可以通过"this"关键字访问This指针。

This指针主要用于在类的成员函数中引用当前对象，以便访问对象的属性和方法。

二、This指针的用途1. 访问对象的成员变量：通过This指针，可以在类的成员函数中访问对象的成员变量。

例如，在一个类的成员函数中，可以使用"this->变量名"的形式来访问对象的成员变量。

2. 调用对象的方法：通过This指针，可以在类的成员函数中调用对象的其他方法。

例如，在一个类的成员函数中，可以使用"this->方法名()"的形式来调用对象的其他方法。

3. 判断对象自身：在某些情况下，我们需要在类的成员函数中判断调用该方法的对象是否为当前对象实例。

这时可以使用This指针进行判断。

例如，在MFC中的消息处理函数中，可以使用"this == this"的形式来判断是否是同一对象实例。

三、This指针的使用场景1. 在类的成员函数中使用：在类的成员函数中，可以通过This指针访问当前对象的成员变量和方法。

2. 在回调函数中使用：在某些情况下，我们需要将类的成员函数作为回调函数传递给其他函数或线程。

这时可以使用This指针来访问当前对象实例。

3. 在多重继承中使用：在多重继承中，可以使用This指针来确定调用方法的对象的实际类型。

四、This指针与MFC框架的关系MFC框架是微软提供的一套用于Windows应用程序开发的C++类库，它基于C++编程语言。

在MFC框架中，类的成员函数通常都会使用This指针来引用当前对象实例。

通过使用This指针，MFC框架能够方便地实现面向对象编程的各种特性，如封装、继承和多态等。

同时，MFC框架也充分利用了C++的特性，如动态内存分配和异常处理等，使得Windows 应用程序的开发更加高效和可靠。

第一章测试1.下列说法错误的是（）。

A:每一个C++程序都必须有一个main函数B:一般编译系统给出的错误信息有两种，一种是错误，一种是警告C:“#include”，这是C++中的语句D:若一行中出现“//”，则从它开始到本行末尾的全部内容都作为注释答案:C2.若要建立良好的程序设计风格，下面描述正确的是（）。

A:程序应简单、清晰、可读性好B:充分考虑程序的执行效率C:符号名的命名只要符合语法就可以D:必要的注释答案:ABD3.编写C++程序一般需经过的几个步骤依次是编辑、编译、连接、调试。

（）A:错B:对答案:B4.C++对C语言进行了改进，不仅对C的功能进行了扩充，还增加了面向对象的机制。

（）A:对B:错答案:A5.C++只在编译阶段给出错误信息，而在连接阶段不会。

（）A:对B:错答案:B第二章测试1.作用域运算符的功能是（）。

A:给出的范围B:标识某个成员属于哪一个类C:标识作用域的级别D:指出的大小答案:B2.为了使类中的某个成员不能被类的对象通过成员操作符访问，则不能把该成员的访问权限定义为（）。

A:publicB:staticC:protected答案:A3.下面关于类的描述中错误的是（）。

A:类是具有共同行为的若干对象的统一描述体B:类是抽象数据类型的实现C:类数据成员必须声明为私有D:类是创建对象的样板答案:C4.在C++的面向对象程序设计中，类与类之间的独立性是通过封装实现的。

（）A:对B:错答案:A5.如果class类中的所有成员在定义时都没有使用关键字pubilc，private和protected，则所有成员缺省定义为public。

（）A:对B:错答案:B第三章测试1.（）的功能是对对象进行初始化。

A:构造函数B:析构函数C:数据成员D:静态成员函数答案:A2.下面对构造函数和析构函数的写法形式上正确的是（）。

A:max::max (参数), max::~ max (参数)B:max::max (参数), max::~ max ()C:void max:: max (参数), void max::~ max (参数)D:void max::max(), void max::~ max ()答案:B3.假设getData()函数是一个类的常成员函数，且没有返回值，则应表示为（）。

第06章类和对象1.填空题（1）类和对象是面向对象程序设计的两个最本概念，＿＿表示抽象的概念，而＿＿则是＿＿的实例化。

（2）类的成员包括＿＿和＿＿两类。

（3）类的数据成员＿＿在类的定义时进行初始化。

（能/不能）（4）类成员的访问方式包括＿＿、＿＿和＿＿3种，默认的访问方式是＿＿。

（5）类的＿＿是为类的所有对象所共有的。

（6）类中声明友元的关键是＿＿。

（7）在类的外部定义成员函数时应在函数的前面加上＿＿和＿＿。

（8）访问对象的成员有＿＿、＿＿和＿＿3种格式。

（9）＿＿函数和＿＿函数是类的两种特殊的成员函数。

＿＿函数负责完成对象的创建和初始化工作，＿＿函数负责完成对象消失时的内存清理工作。

（10）类的＿＿成员和＿＿成员需要初始化表的方式提供初值。

（11）类的静态数据成员的初始化应该写在＿＿区域上，而且要指明＿＿和＿＿。

（12）常对象只能调用类中的＿＿函数，该函数为类的＿＿函数。

（13）类的私有成员和保护成员只能被该类的＿＿函数和＿＿函数访问。

（14）C++中的类的成员指针有＿＿指针和＿＿指针。

（15）类的每一个成员函数都有一个隐含定义的指针，称为＿＿指针，它的类型是成员函数所属类的类型。

（16）对象之间成员级的拷贝，称为＿＿，可以采用默认的拷贝的构造函数。

2.选择题（1）下列关于和对象的描述上，不正确的是（）。

（A）一个对象只能属于一个类。

（B）对象是类的一个实例。

（C）一个类只能有一个对象。

（D）类和对象的关系与数据类型和变量的关系类似。

（2）若有如下类声明：class A{int a;}则A类的成员a是（）。

（A）公有数据成员（B）公有的成员函数（C）私有数据成员（D）私有成员函数（3）下列关于成员函数的描述中，不正确的是（）。

（A）成员函数可以重载。

（B）成员函数一定是内联函数（C）成员函数可以是静态的（D）成员函数可以设置参数的默认值（4）在类外定义成员函数时，需要在函数名前加上（）。

（A）对象名（B）类名（C）类名和作用域运算符（D）作用域运算符（5）下列关于this指针的描述中，正确的是（）。

新《C++程序设计》自考必备题库(含答案)一、单选题1、类A将每其它类对象作为成员，则建立A类对象时，下列描述正确的是()A、A类构造函数先执行B、成员构造函数先执行C、两者并行执行D、不能确定正确答案：B2、列描述错误的是()A、在创建对象前，静态成员不存在B、静态成员是类的成员C、静态成员不能是虚函数D、静态成员函数不能直接访问非静态成员正确答案：A3、关多态性说法不正确的是()A、C++语言的多态性分为编译时的多态性和运行时的多态性B、编译时的多态性可通过函数重载实现C、运行时的多态性可通过模板和虚函数实现D、实现运行时多态性的机制称为动态多态性正确答案：C4、编译指令中，宏定义使用哪个指令()A、ttincludeB、#defineC、#ifD、#else正确答案：B5、于对象概念的描述中，说法错误的是()A、对象就是C语言中的结构体B、对象代表着正在创建的系统中的一个实体C、对象是类的一个变量D、对象之间的信息传递是通过消息进行的正确答案：A6、没有使用private关键字定义类的数据成员，则默认为()A、privateB、publicC、protectedD、friend正确答案：A7、符型数据在内存中的二进制编码方式是()A、补码B、原码C、ASCII码D、反码正确答案：C8、++语言是从早期的C语言逐渐发展演变而来的与C语言相比，它在求解问题方法上进行的最大改进是：（）A、面向过程B、面向对象C、安全性D、复用性正确答案：B9、符串“ABC”在内存占用的字节数是（）A、3B、4C、6D、8正确答案：B10、创建派生类对象时，构造函数的执行顺序是（）A、对象成员构造函数、基类构造函数、派生类本身的构造函数B、派生类本身的构造函数、基类构造函数、对象成员构造函数C、基类构造函数、派生类本身的构造函数、对象成员构造函数D、基类构造函数、对象成员构造函数、派生类本身的构造函数正确答案：D11、中定义的成员默认访问属性为（）A、publicB、privateC、protectedD、friend正确答案：B12、求通过函数来实现一种不太复杂的功能，并且要求加快执行速度,选用()A、内联函数B、重载函数C、内部函数D、函数模板正确答案：A13、面正确的字符常量是()A、“c”B、'\\''C、，W<D、''正确答案：C14、有说明语句：chare二‘\72‘；则变量c()A、包含1个字符B、包含2个字符C、包含3个字符D、说明不合法，c值不确定正确答案：A15、inta二5,使b不为2的表达式是()A、b=6一(---a)B、b=a%2C、b=a/2D、b=a>3? 2：1正确答案：B16、C++语言中用于注释的标识符是()A、&B、//C、*D、/正确答案：B17、数型数据在内存中的二进制编码方式是()A、补码B、原码C、ASCII码D、反码正确答案：A18、his指针存在的目的是()A、保证基类公有成员在子类中可以被访问B、保证每个对象拥有自己的数据成员，但共享处理这些数据成员的代码C、保证基类保护成员在子类中可以被访问D、保证基类私有成员在子类中可以被访问正确答案：B19、哪种派生方式中，派生类可以访问基类中的protected成员()A、public和privateB、public和protectedC、protected和privateD、仅protected正确答案：B20、行x二(6*7%8+9)/5；后，x的值为()A、1B、2C、3D、4正确答案：B21、类中声明的变量，下列描述中正确的是()A、属于全局变量B、只属于该类C、属于该类，某些情况下也可被该类不同实例所共享D、任何情况下都可被该类所有实例共享正确答案：C22、列说明中constchar^ptr；其中ptr应该是：()A、指向字符常量的指针B、指向字符的常量指针C、指向字符串常量的指针D、指向字符串的常量指针正确答案：C23、变量a是整型，f是实型，i是双精度型，则表达式10+'a，+i*f 值的数据类型是()A、intB、folatC、doubleD、不确定正确答案：C24、于类和对象不正确的说法是()A、类是一种类型，它封装了数据和操作B、对象是类的实例C、一个类的对象只有一个D、一个对象必属于某个类正确答案：C*q[5]；等价的定义语句是()25、下与intA、intq[5]；B、int*qC、int(q[5])D、int(*q)[5]正确答案：D26、izeof(float)是()A、一个双精度型表达式B、一个整型表达式C、一种函数调用D、一个不合法的表达式正确答案：B27、ntFunc(int,int)；不可与下列哪个函数构成重载()A、intFHnc(int,int,int)；B、doubleFunc(int,int)；C、doubleFunc(double,double)；D、doubleFunc(int,double)；正确答案：B28、列哪个类型函数不适合声明为内联函数()A、函数体语句较多B、函数体语句较少C、函数执行时间较短D、函数执行时间过长正确答案：A29、列有关重载函数的说法中正确的是()A、重载函数必须具有不同的返回值类型B、重载函数参数个数必须相同C、重载函数必须有不同的形参列表D、重载函数名可以不同正确答案：C30、行语句x=(a二3,b=a---)后，x,a,b的值依次为()B=3A=2X=3A、3,2,3B、2,3,2C、3,3,2D、3,2,2正确答案：A31、有代数式3ae/bc,则不正确的c语言表达式是()A、a/b/c*e3B、3*a e/b/c*cC、3a e/bD、a e/c/c*3正确答案：C32、用值传递方式将实参传给形参，下列说法正确的是0A、形参是实参的备份B、实参是形参的备份C、形参和实参是同一对象D、形参和实参无联系正确答案：A33、果没有为一个类定义任何构造函数的情况下，下列描述正确的是0A、编译器总是自动创建一个不带参数的构造函数B、这个类没有构造函数C、这个类不需要构造函数D、该类不能通过编译正确答案：A34、有定义inta[10],*p=a；,则p+5表示（）A、元素a[5]的地址B、元素a[5]的值C、元素a[6]的地址D、元素a[6]的值正确答案：A35、a=-3；执行（a〉0）?a：-a；后，a的值为（）A、3B、1C、0D、一3正确答案：D36、使用关键字new所开辟的动态存储空间，释放时必须使用()A、fIreeB、createC、deleteD、cfile正确答案：C37、存在函数intmax(int,int)返回两参数中较大值，若求22,59, 70三者中最大值，下列表达式不正确的是()A、intm=max(22,max(59,70))；B、intm=max(max(22,59),70)；C、intm=max(22,59,70)；D、intm=max(59,max(22,70))；正确答案：C38、于类模板的说法正确的是()A、类模板的主要作用是生成抽象类B、类模板实例化时，编译器将根据给出的模板实参生成一个类C、在类模板中的数据成员具有同样类型D、类模板中的成员函数没有返回值正确答案：B39、于友元描述正确的是()A、友元是本类的成员函数B、友元不是本类的成员函数C、友元不是函数D、友元不能访问本类私有成员正确答案：B40、PC机中，"在内存占用的字节数是（）A、1B、2C、3D、4正确答案：A41、有语句inta二3；,则执行了语句a+二a-二a*后，变量a的值是（）A、3B、0C、9D、-12正确答案：D42、列正确的标识符是（）A、hot_doB、a+bC、test!D、%y正确答案：A43、的私有成员可在何处访问0A、通过子类的对象访问B、本类及子类的成员函数中C、通过该类对象访问D、本类的成员函数中正确答案：D44、C语言中，合法的长整型常数是()A、0LB、4962710C、0.054838743D、 2.1869el0正确答案：A45、C++语言和C语言的兼容性，描述正确的是()A、C++兼容CB、C++部分兼容CC、C++不兼容D、C兼容C++正确答案：A46、写C++程序一般需经过的几个步骤依次是()A、编辑、调试、编译、连接B、编译、调试、编辑、连接C、编译、编辑、连接、运行D、编辑、编译、连接、运行正确答案：D47、贝构造函数的参数是()A、某个对象名B、某个对象的成员名C、某个对象的引用名D、某个对象的指针名正确答案：C48、C++中使用流进行输入输出，其中用于屏幕输出的对象是()A、cerrB、cinC、coutD、cfile正确答案：C49、所有变量均为整型，则表达式(a二2,b二5,b++,a+b)的值为()A、7B、8C、9D、2正确答案：A50、C语言中，要求运算数必须是整型的运算符是()A、/B、++D、%正确答案：D51、列关于类的权限的描述错误的是0A、类本身的成员函数只能访问自身的私有成员B、类的对象只能访问该类的公有成员C、普通函数不能直接访问类的公有成员，必须通过对象访问D、一个类可以将另一个类的对象作为成员正确答案：A52、x二8,执行语句y二x++,则y等于()A、6B、7C、8D、9正确答案：C53、intk二32767；执行k=k+l；后k值为()A、32768B、—32768C、0D、-1正确答案：A54、个类可包含析构函数的个数是()B、1个C、至少一个D、0个或多个正确答案：B55、于虚函数的描述中，()是正确的。

C++测试题C++测试题一、填空题（30空* 1分）1．在C++中，函数的参数有两种传递方式，它们是值传递和________。

2．当一个成员函数被调用时，该成员函数的__this对象指针_____指向调用它的对象。

3．在基类和派生类中，派生类可以定义其基类中不具备的数据和操作。

对两个有相同名字的数据成员进行访问时，如果没有____________，对此数据成员的访问将出现歧义。

4．拷贝构造函数使用___引用_____作为参数初始化创建中的对象。

5．在公有继承的情况下，基类数据成员在派生类中的访问权限_不变_________。

6. 建立一个有成员对象的多态派生类对象时，各构造函数体的执行顺序为_先基类按继承顺序，再成员对象按声明顺序，最后派生类本身_________________7．用new申请某一个类的动态对象数组时，在该类中必须能够匹配到_____默认___________构造函数，否则应用程序会产生一个编译错误。

8．静态数据成员在类外进行初始化，且静态数据成员被类的所有对象__共享______。

9．为了避免可能出现的歧义，C++对if…else语句配对规则规定为：else总是___与之前最近的if_____________配对。

10．设"int a=3,b=4,c=5;"，表达式"(a+b)>c&&b==c"的值是_0___。

11．面向对象的程序设计有四大特征，它们是抽象、封装、_继承_____ 、_多态_______。

12．定义重载函数时，应至少使重载函数的参数个数或参数类型__不同_____；在基类和派生类中，成员函数的覆盖是指__________________________________________________。

13．构造函数与析构函数除功能不同外，在定义形式上，它们的区别还包括构造函数名与类名相同，而析构函数名是在类名前加一个~、但析构函数没有__重载___________, 但可以定义为_____虚函数____________14．动态联编要满足两个条件，它们是____多态_________________,____赋值兼容原则______________ 。

C++（面向对象的程序设计）考前必背的名词解释和简答题1. 封装封装是将数据和代码捆绑到一起，避免了外界的干扰和不确定性。

例如C++中的类，它定义了该集合中每个对象所共有的属性和方法。

2. 继承继承是让某个类型的对象获得另一个类型的对象的特征。

例如：C++中子类对父类的继承，子类具有父类的特性，同时还可以拥有自己的新特性。

3. 多态多态是指不同类型的对象接收相同的消息时产生不同的行为。

多态机制使具有不同内部结构的对象可以共享相同的外部接口，通过这种方式减小代码的复杂度。

例如函数的重载。

4. 什么是this 指针？为什么要用this 指针？this 指针是类中的一个特殊指针，当类实例化时，this 指针指向对象自己；而在类的声明时，指向类本身。

通过它不仅可以提升成员函数操作的效率，而且能简化运算符重载代码。

5. 叙述公有、私有、保护成员在类中、类外和对象中的访问权限。

类中的关键字public, private, protected 声明了类中的成员与类外之间的关系，称为访问权限。

对于public 成员来说，他们是公有的，可以在类外和对象中访问。

对于private 成员来说，他们是私有的，不能在类外和对象中访问，数据成员只能由类中的函数使用，成员函数只允许在类中调用。

对于protected 成员来说，他们是受保护的，具有半公开性质，可以在类中与子类中访问。

6. 构造函数和析构函数的作用是什么？构造函数的功能是在创建对象时，给数据成员赋初值，即给对象初始化。

析构函数的功能是释放一个对象，在对象删除前，用来做一些内存释放等清理工作。

7. 什么是类的继承和派生？继承是指一个事物可以继承其父辈全部或部分的特性，同时本身还有自己的特性。

当一个新类从一个已定义的类中派生后，新类不仅继承了原有类的属性和方法，并且还拥有自己新的属性和方法，称为类的继承和派生。

8. 派生类public 继承方式有那些特点？（1）在派生类中，基类的公有成员、保护成员和私有成员的访问属性保持不变。

私有成员的名词解释私有成员（Private Member）是面向对象编程中的一个概念，指的是只能在类内部访问和使用的成员变量和成员函数。

私有成员在类外部是不可见的，即其他类或对象无法直接访问私有成员。

一、私有成员的定义和特点在面向对象编程中，一个对象是由其属性（成员变量）和方法（成员函数）组成的。

为了保护对象的数据完整性和安全性，可以将一些敏感的成员属性和方法定义为私有成员。

私有成员的定义方式是在类的内部，将其名字前面添加"private"关键字。

例如，下面是一个Person类的定义，其中有两个私有成员num和name：```class Person {private:int num;string name;public:void printInfo(); // 公有成员函数};```私有成员的特点如下：1. 只能在类的内部被访问和使用：私有成员只对类内部的其他成员可见，外部无法直接访问。

这样可以实现对数据的保护，只允许类内部的成员函数对其进行操作。

2. 不能被继承的子类访问：子类无法直接访问父类的私有成员。

如果子类需要访问父类的私有成员，可以通过父类的公有成员函数间接地进行访问。

3. 保护对象的状态完整性：通过将一些关键的属性和方法定义为私有成员，可以避免外部对内部实现的干扰，确保对象内部的状态完整性和正确性。

二、私有成员的使用场景私有成员的存在与使用有以下几个常见的场景。

1. 封装数据：通过将成员属性定义为私有成员，可以将数据隐藏在类的内部，只能通过类的公有成员函数来访问和修改数据。

这样可以有效地控制对数据的访问权限，提高代码的安全性和可维护性。

2. 隐藏实现细节：将一些与外界无关的实现细节定义为私有成员，可以隐藏这些细节对其他类或对象的影响。

这样可以降低不同类之间的耦合度，提高代码的模块化和可复用性。

3. 访问控制：在一个类中，可能有一些成员变量或成员函数是对外部不可见的，只允许内部特定的成员函数进行访问和调用。

c++私有成员的访问（1）友元函数代码：略（2）同⼀个类的实例之间可以通过函数来访问。

class A {private:int value;public:A(int a) { value = a; }void printA(A O){cout << O.value << endl;cout << value << endl;}};int main(){A a(10);A b(11);b.printA(a);system("pause");return0;}这⾥实例对象b就可以通过成员函数来访问实例对象a的私有成员反例：class A {private:int value;public:A(int a) { value = a; }void printA(A O){cout << O.value << endl;cout << value << endl;}};class B {public:void printB(A a) {cout << a.value << endl;//编译不通过}};int main(){A a(10);B b;b.printB(a);system("pause");return0;}（3）⼦类通过继承可以访问⽗类的私有成员⽅法1：⼦类继承的公有成员函数SetValue对⽗类的私有成员进⾏了访问⽅法2：通过改变⼦类对象的指针来访问，因为继承的时候把⽗类的私有成员继承下来了，但是隐藏掉了，所以不能通过编译器直接访问，可以以指针的形式来访问。

#include <iostream>class Base{private:int x;public:int y;void init_Base();};void Base::init_Base(){std::cout<<"x ="<<this->x<<std::endl; }class Sub:public Base{public:int a;int b;};void main(){Sub sub;int* pr = (int*)&sub;*pr = (int)9;sub.init_Base();}。

对象可以访问类的私有成员（转）+⾃我理解⼀个奇怪的发现：对象可以访问类的私有成员class String{public:String& operator= (const String&str){//为什么在这⾥可以直接访问str对象的私有成员呢??size = str.size;}private:int size;}；****************************************************⽹上答案：1。

封装性是对类（不是对象）外的操作来说的。

所以在类内操作本类的⼀个对象来说，这个类可以访问类的所有成员变量。

因为类知道，他现在处理就是他⾃⼰的⼀个对象。

2。

相同类的对象在类的内部可以调⽤private成员3.这个函数是在 class String 类体⾥⾯的，所以被认为是在同⼀个域⾥，也就是类域。

所以这个时候 str 是允许访问 size 的。

但如果你在 main ⾥str.size 就不⾏了，不在⼀个域。

4.Standard C++ 98 has mentioned:"A member of a class can be--private; its name can be used only by menbers and friends of the class in which it is declared."----------------------------------------------------------------------------------------------------------以下是风筝的⾃⼰理解。

1public class A {2private double _price = 2.0;34public A(){5 }67public A(A a){8this._price = a._price;9 }1011public void dis(A a){12 System.out.println(a._price);//正确！因为“⾃家⼈（a）在家⾥”13 }14public static void main(String[] args){15//A._price = 3.0; 错误！因为“⾃家⼈（A）在外地（main）”16 A a = new A();17 A b = new A(a);18 a.dis(b);19 }20 }输出结果：2.01、编程语⾔中的访问控制符如public、protected和private等等是针对此类外的类型、对象来说的。