C++学习笔记问题大全【整理】

声明：以下大多问题都是网上找的，有部分答案根据自己个人的理解作出了修改，仅供参考

_______________

整理笔记：

关于C++语言概述 如基本符号、词汇、基本框架

问： 面向对象的程序设计思想是什么？
答：面向对象的程序设计思想简称OOP思想，是当今主流的程序设计范型，面向对象的程序是由对象组成的，每个对象包含对用户公开的特定功能部分和隐藏的实现部分。万物皆对象的概念，由具有共同特征和行为的对象抽象的模型称之为“类”。
面向对象程序设计，是程序设计时把数据结构和对数据结构进行操作的方法封装形成一个个独立而又互相调用的对象的思想。
问：什么是类？
答：万物皆对象的概念，我们把一些具有共同特征和行为的对象抽象归类后形成一个集合的模型，称之为“类”。

问： 对象都具有的二方面特征是什么？分别是什么含义？
答：对象都具有的特征是：静态特征和动态特征。
　　静态特征是指能描述对象的一些属性；动态特征是指对象表现出来的行为 。
问：C++有哪些性质（面向对象特点）
封装，继承和多态。
问：面向对象的三个基本特征（即同上题）是什么？并简单叙述之？
（1）. 封装：将客观事物抽象成类，每个类对自身的数据和方法实行protection(private, protected,public)
（2） 继承：广义的继承有三种实现形式：实现继承（指使用基类的属性和方法而无需额外编码的能力）、可视继承（子窗体使用父窗体的外观和实现代码）、接口继承（仅使用属性和方法，实现滞后到子类实现）。前两种（类继承）和后一种（对象组合=>接口继承以及纯虚函数）构成了功能复用的两种方式。
（3）多态：是将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。

问：为什么要封装，如何解释他的用意。
在面向对象程序设计语言中，封装是利用可重用成分构造软件系统的特性，它不仅支持系统的可重用性，而且还有利于提高系统的可扩充性；消息传递可以实现发送一个通用的消息而调用不同的方法；封装是实现信息隐蔽的一种技术，其目的是使类的定义和实现分离。
问：C++程序的基本框架

（1）结构程序设计框架

在C++的结构化程序设计框架中，函数是程序的基本组成单元，是程序中完成一定功能的模块。使用结构化程序设计方法编写出的C++程序包括一个主函数和若干个用户定义的函数。函数与函数之间是相对独立的并且是并行的，函数之间可以互相调用。同一个函数可以被一个或多个函数调用多次。主函数由系统调用，在主函数中调用其他函数。

（2）面向对象程序设计框架

面向对象的程序设计有三个主要的特征：封装、继承和多态。

封装：是对象和类概念的主要特征。封装是指把方法和数据装起来，对数据的访问只能通过已定义的接口。封装使得对象的内部实现与外部接口分离开来，对象的内部实现的改变并不影响使用这个对象的其他对象或应用。

继承：在面向对象的程序设计中，继承是指一个子类继承父类（或成为基类）的特征（数据结构和方法）。继承带来的好处是软件的复用，使用继承可以在已有软件的基础上构造新的软件，从而提高软件的生产率并保证软件的质量。

多态：在面向对象程序设计中主要是指变量多态和方法多态；变量多态是指同一个变量在运行时刻标识（表示）不同类型的对象，而方法多态主要是指同一方法做不一样的动作。多态使得消息发送者能给一组具有公共接口的对象发送相同的消息，接受者做出相应的动作。变量多态是方法多态的基础。

问：C和C++有什么不同?
从机制上：c是面向过程的（但c也可以编写面向对象的程序）；c++是面向对象的，提供了类。但是，c++编写面向对象的程序比c容易
从适用的方向：c适合要求代码体积小的，效率高的场合，如嵌入式；c++适合更上层的，复杂的； llinux核心大部分是c写的，因为它是系统软件，效率要求极高。
从名称上也可以看出，c++比c多了+，说明c++是c的超集；那为什么不叫c+而叫c++呢，是因为c++比c来说扩充的东西太多了，所以就在c后面放上两个+；于是就成了c++
C语言是结构化编程语言，C++是面向对象编程语言。
C++侧重于对象而不是过程，侧重于类的设计而不是逻辑的设计。
问： #if!defined(AFX_…_HADE_H)
#define(AFX_…_HADE_H)
……
#endif作用？
防止该头文件被重复引用。
问：h头文件中的ifndef/define/endif 的作用？
答：防止该头文件被重复引用。
问：头文件的作用是什么?
答：（1）通过头文件来调用库功能。在很多场合，源代码不便（或不准）向用户公布，只要向用户提供头文件和二进制的库即可。用户只需要按照头文件中的接口声明来调用库功能，而不必关心接口怎么实现的。编译器会从库中提取相应的代码。
（2）头文件能加强类型安全检查。如果某个接口被实现或被使用时，其方式与头文件中的声明不一致，编译器就会指出错误，这一简单的规则能大大减轻程序员调试、改错的负担。

问： 在头文件中进行类的声明，在对应的实现文件中进行类的定义有什么意义？
答：1这样可以提高编译效率，因为分开的话只需要编译一次生成对应的.obj文件后，再次应用该类的地方，这个类就不会被再次编译，从而大大提高了效率。
        2隐藏了代码。

问：#include <filename.h> 和 #include “filename.h” 有什么区别？
答：对于#include <filename.h> ，编译器从标准库（Standard Library）路径开始搜索 filename.h
对于#include “filename.h” ，编译器从用户的工作路径开始搜索 filename.h
问：＃i nclude<file.h> 与 ＃i nclude "file.h"的区别？（同上一题）
答：前者是从Standard Library的路径寻找和引用file.h，而后者是从当前工作路径搜寻并引用file.h。
问：#define DOUBLE(x) x+x ，i = 5*DOUBLE(5)； i 是多少？
答案：i 为30。  
问：C++是不是类型安全的？
答案：不是。两个不同类型的指针之间可以强制转换（用reinterpret cast) .C#是类型安全的。
问：如何判断一段程序是由C 编译程序还是由C++编译程序编译的？
答案：
#ifdef __cplusplus
　　cout<<"c++";
#else
　　cout<<"c";
#endif
注意，后面很多代码啊。代码不看也罢。

问：main 函数执行以前，还会执行什么代码？
答案：全局对象的构造函数会在main 函数之前执行，为malloc分配必要的资源，等等。

问：C++里面是不是所有的动作都是main()引起的？如果不是，请举例。

答:当然不是的.并不是所有的动作都是由main（）引起的，只是编译器是由main()开始执行的
静态变量和全局变量的初始化和内存分配早在main之前完成
而内联，模板，宏的扩展等更是编译期行为，也不是main()完成的
注:C++和main()逻辑上没有必然的联系。

问：main 主函数执行完毕后，是否可能会再执行一段代码，给出说明？
答案：可以，可以用_onexit 注册一个函数，它会在main 之后执行intfn1(void), fn2(void), fn3(void),fn4 (void);
void main( void )
{
　　String str("zhanglin");
　　_onexit( fn1 );
　　_onexit( fn2 );
　　_onexit( fn3 );
　　_onexit( fn4 );
　　printf( "This is executed first.\n" );
}
int fn1()
{
　　printf( "next.\n" );
return0;
}
int fn2()
{
　　printf( "executed " );
return0;
}
int fn3()
{
　　printf( "is " );
return0;
}
int fn4()
{
　　printf( "This " );
return0;
}
The _onexit function is passedthe address of a function (func) to be called whenthe program terminatesnormally. Successive calls to _onexit create a registerof functions that areexecuted in LIFO (last-in-first-out) order. The functionspassed to _onexitcannot take parameters.

_______________

_______________

整理笔记：

关于C++数据类型 表达式 基本运算

问： 简述枚举类型？
枚举方便一次定义一组常量，使用起来很方便；

问：C++中的0和1，假和真？
 c/c++ 里面一般是 0 为 false， 非 0 为真。
布尔型的取值为true或者false。布尔型变量的应用，例如bool   flag;则布尔型数据的变量flag取值：只有 false 和 true 两个值，即分别是0和1。
问：比较C++中的4种类型转换方式？
重点是static_cast, dynamic_cast和reinterpret_cast的区别和应用。
dynamic_casts在帮助你浏览继承层次上是有限制的。它不能被用于缺乏虚函数的类型上，它被用于安全地沿着类的继承关系向下进行类型转换。如你想在没有继承关系的类型中进行转换，你可能想到static_cast

问：在Win32下 char, int, float, double各占多少位？
(1)        Char         占用8位
(2)        Int 占用32位
(3)        Float 占用32位
(4)        Double 占用64位

问：unsigned short A = 10;
printf("~A = %u/n", ~A);

char c=128;
printf("c=%d/n",c);
这两题分别输出多少？并分析过程
第一题，

A=10,为无符号型，转换为二进制为0000 0000 0000 0000 0000 0000 0000 1010
所以~A的二进制位1111 1111 1111 1111 1111 1111 1111 0101即0xFFFFFFF5，～A ＝0xfffffff5。

0xFFFFFFF5，如果转换为符号整型的话则为-11，因为输出的是无符号整型，无符号整型的范围为0~4294967295，而0xFFFFFFF5转换为无符号十进制整型为4294967285

int值 为－11，但输出的是uint。所以输出4294967285

第二题，c＝0x10,输出的是int，最高位为1，是负数，所以它的值就是0x00的补码就是128，所以输出－128。
这两道题都是在考察二进制向int或uint转换时的最高位处理。

问：关于位操作（Bit manipulation）

下面的代码输出是什么，为什么？
 void foo(void)

{
unsigned int a = 6;
int b = -20;
(a+b > 6)? puts("> 6") : puts("<= 6");
}
这个问题测试你是否懂得C语言中的整数自动转换原则，我发现有些开发者懂得极少这些东西。不管如何，这无符号整型问题的答案是输出是“>6”。原因是当表达式中存在有符号类型和无符号类型时所有的操作数都自动转换为无符号类型。因此-20变成了一个非常大的正整数，所以该表达式计算出的结果大于6。这一点对于应当频繁用到无符号数据类型的嵌入式系统来说是丰常重要的。如果你答错了这个问题，你也就到了得不到这份工作的边缘。

问：不能做switch()的参数类型是：
答 、switch的参数不能为实型。

问：请说出static和const关键字尽可能多的作用
解答：static关键字至少有下列n个作用：
　　（1）函数体内static变量的作用范围为该函数体，不同于auto变量，该变量的内存只被分配一次，因此其值在下次调用时仍维持上次的值；
　　（2）在模块内的static全局变量可以被模块内所用函数访问，但不能被模块外其它函数访问；
　　（3）在模块内的static函数只可被这一模块内的其它函数调用，这个函数的使用范围被限制在声明它的模块内；
　　（4）在类中的static成员变量属于整个类所拥有，对类的所有对象只有一份拷贝；
　　（5）在类中的static成员函数属于整个类所拥有，这个函数不接收this指针，因而只能访问类的static成员变量。
　　总结const的应用和作用？至少有下列n个作用：定义常量、常指针、指向常变量的指针、修饰函数参数（函数的常参数）、类的常成员函数、const对象、修饰函数返回值
　　（1）常量：欲阻止一个变量被改变，可以使用const关键字。在定义该const变量时，通常需要对它进行初始化，因为以后就没有机会再去改变它了；
　　（2）常量指针和指向常量的指针：对指针来说，可以指定指针本身为const，也可以指定指针所指的数据为const，或二者同时指定为const；
　　（3）函数的常参数：在一个函数声明中，const可以修饰形参，表明它是一个输入参数，在函数内部不能改变其值；
　　（4）类的常成员函数：对于类的成员函数，若指定其为const类型，则表明其是一个常函数，不能修改类的成员变量；
　　（5）对于类的成员函数，有时候必须指定其返回值为const类型，以使得其返回值不为“左值”。例如：
const classA operator*(const classA& a1,const classA& a2);
　　operator*的返回结果必须是一个const对象。如果不是，这样的变态代码也不会编译出错：
classA a, b, c;
(a * b) = c; // 对a*b的结果赋值
　　操作(a * b) = c显然不符合编程者的初衷，也没有任何意义。
剖析：
　　惊讶吗？小小的static和const居然有这么多功能，我们能回答几个？如果只能回答1~2个，那还真得闭关再好好修炼修炼。
　　这个题可以考查面试者对程序设计知识的掌握程度是初级、中级还是比较深入，没有一定的知识广度和深度，不可能对这个问题给出全面的解答。大多数人只能回答出static和const关键字的部分功能。

问：慧通公司，关于const的问题：

char * const p;
char const * p
const char *p
上述三个有什么区别？
char * const p; //常量指针，p的值不可以修改
char const * p；//指向常量的指针，指向的常量值不可以改
const char *p； //和char const *p是是一个意思。都是p所指向的变量的值不能改变

问：char *const p 与 char const * p const char * p的区别，并举例说明。（跟上一个是同一问题）
const char * p 和 char const * p 是一个意思，都是p所指向的变量的值不能改变，例如：
const char ch = 'a';
const char* p = &ch;
*p = 'b';   //这样是错的

char* const p，意思是p所指向的地址是不能改变的，例如：
char* const p = &ch1;
p = &ch2;  //这样是错的

问：const char *p,char *  const p;的区别。（跟上一个是同一问题）
如果const位于星号的左侧，则const就是用来修饰指针所指向的变量，即指针指向为常量；
如果const位于星号的右侧，const就是修饰指针本身，即指针本身是常量。

问：以下代码输出结果是什么？
char str1[] = "abc";
char str2[] = "abc";
const char str3[] = "abc";
const char str4[] = "abc";
const char *str5 = "abc";
const char *str6 = "abc";
char *str7 = "abc";
char *str8 = "abc";
cout << ( str1 == str2 ) << endl;
cout << ( str3 == str4 ) << endl;
cout << ( str5 == str6 ) << endl;
cout << ( str7 == str8 ) << endl;
结果是：0 0 1 1
解答：str1,str2,str3,str4是数组变量，它们有各自的内存空间；
而str5,str6,str7,str8是指针，它们指向相同的常量区域。

问：请说出const与#define 相比，有何优点？
答案：
Const作用：定义常量、修饰函数参数、修饰函数返回值、常指针、指向常变量的指针。被Const修饰的东西都受到强制保护，可以预防意外的变动，能提高程序的健壮性。
1） const 常量有数据类型，而宏常量没有数据类型。编译器可以对前者进行类型安全检查。而对后者只进行字符替换，没有类型安全检查，并且在字符替换可能会产生意料不到的错误。
2） 有些集成化的调试工具可以对const 常量进行调试，但是不能对宏常量进行调试。
问：关键字const有什么含意？
表示不可以修改的变量。
我只要一听到被面试者说："const意味着常数"，我就知道我正在和一个业余者打交道。去年Dan Saks已经在他的文章里完全概括了const的所有用法，因此ESP(译者：Embedded Systems Programming)的每一位读者应该非常熟悉const能做什么和不能做什么.如果你从没有读到那篇文章，只要能说出const意味着"只读"就可以了。尽管这个答案不是完全的答案，但我接受它作为一个正确的答案。（如果你想知道更详细的答案，仔细读一下Saks的文章吧。）
如果应试者能正确回答这个问题，我将问他一个附加的问题：
下面的声明都是什么意思？
const int a;
int const a;
const int *a;
int * const a;
int const * a const;
/******/
前两个的作用是一样，a是一个常整型数。第三个意味着a是一个指向常整型数的指针（也就是，整型数是不可修改的，但指针可以）。第四个意思a是一个指向整型数的常指针（也就是说，指针指向的整型数是可以修改的，但指针是不可修改的）。最后一个意味着a是一个指向常整型数的常指针（也就是说，指针指向的整型数是不可修改的，同时指针也是不可修改的）。如果应试者能正确回答这些问题，那么他就给我留下了一个好印象。顺带提一句，也许你可能会问，即使不用关键字 const，也还是能很容易写出功能正确的程序，那么我为什么还要如此看重关键字const呢？我也如下的几下理由：
1) 关键字const的作用是为给读你代码的人传达非常有用的信息，实际上，声明一个参数为常量是为了告诉了用户这个参数的应用目的。如果你曾花很多时间清理其它人留下的垃圾，你就会很快学会感谢这点多余的信息。（当然，懂得用const的程序员很少会留下的垃圾让别人来清理的。）
2) 通过给优化器一些附加的信息，使用关键字const也许能产生更紧凑的代码。
3) 合理地使用关键字const可以使编译器很自然地保护那些不希望被改变的参数，防止其被无意的代码修改。简而言之，这样可以减少bug的出现。

问：关键字const是什么