本文详细介绍了C++编程的多个核心知识点，包括头文件的使用、泛型编程、函数重载、类型转换、内存管理、常量与引用、异常处理、内联函数、类与对象的构造与析构、函数参数默认值、模板、数据结构以及编译器优化等方面，旨在帮助读者深入理解和掌握C++编程的关键概念和技术。
-------------------------------------------------------------------------------
可以通过查找功能找到相关的知识点。
-------------------------------------------------------------------------------
1、c++中使用c语言的头文件要注意什么?
答、库名要加c,且不能有.h,且要加using namespace std;例如#include<cstring>。
2、int arr[10]={1,2,3,4,5,6},cout<<3[arr];这个代码能打印吗?这能说明什么？
答、可以，和cout<<arr[3]相同，本质是3[arr]会被解释成*(3+arr);arr[3]也会被解释成*(arr+3).
3、C++泛型编程的含义？
答、用c++的模板编程。
4、程序调用系统函数，这种程序的移植性是怎样的？
答、很差。
5、C++标准头文件需要加.h吗？
答、不需要。
6、C++标准头文件引入后能直接使用吗？为什么
答、不能，需要加上using namespace std；C++有为标准库存储的命令空间，std，所有标准头文件都会存储在里面，这说明c++标准头文件不是公开的，
使用时需要使用using namespace std；打开命令空间。
7、标准输出设备是什么？
答、屏幕。
8、endl的作用是什么？
答、回车换行，刷新缓冲区。它的本质是一个函数。
9、什么时候缓冲区才会刷新？
答、换行，缓冲区满了，或者强制手动刷新缓冲区。
10、c++中结构体与c语言中结构体有什么区别？
答、c++中用结构体定义变量不需要加struct，而且，可以在结构体内定义函数。
11、c++和c语言的类型转换的区别？
答、c++中要求严格的类型转换。
12、C++中三目运算符返回的是值还是内存（内存内存储了这个值）？C语言呢？
答、C++中是内存(变量本身)，C语言中是值.
14、觅食。
16、vs比较卡怎么办？
答、360深度清理。
17、如何增加程序的健壮性？
答、合理使用const。
18、C++中的const是默认static(内部链接),但是使用extern可以让其外部链接，C语言中const是extern类型(全局作用)?
答、对。
19、C++中在main函数外定义的const 变量放在什么地方？
答、常量区，一旦初始化，不能修改。
20、C++中const局部变量放在什么地方？
答、栈区，可通过地址修改。
21、
const int a=10；
int *p=(int *)&a;
*p=100;
cout<<"a="<<a<<endl;
cout <<"*p="<<*p<<endl;
问输出什么，为什么？
答、a=10;
*p=100;
因为a会被优化，直接使用a时会用10取代a；但是a变量的内存空间的值会变成100；
22、如何防止上题中的编译器进行优化？
答、用volatile const int a=10；这样打印结果是a=100；*p=100；
23、
int b=100；
const int a=b；
int *p=（int *）&a;
*p=200;
cout<<"a="<<a<<endl;
问会不会对变量a进行优化?
答、不会，打印200；而不是100；
24、const int b=100；
const int a=b；
int *p=（int *）&a;
*p=200;
cout<<"a="<<a<<endl;
问会不会对变量a进行优化?
答、会，a=100；
25、引用的优点？
答、比指针更有效率，代码更简洁，能达到指针的功能。
26、引用的本质？
答、
27、引用引入的初衷是为了什么？
答、运算符重载。
28、引用的返回要求是什么？
答、必须是合法的内存空间。如果空间返回后就释放了，会出错。
29、int doit()
{
static int a=10;
return a;
}
int main()
{
doit()=100;
return 0;
}
问有什么问题？
答、a返回的是一个字面值，显然不能作为左值。
可以改成
int &doit()
{
static int a=10;
return a;
}
int main()
{
doit()=100;
return 0;
}
30、问引用作为函数返回的时候，用一个非引用变量来接，和用一个引用变量来接所有什么区别？
答、用非引用来接，引用返回的是值，用引用来接，返回的是内存空间。
31、C++中默认参数的设置有什么要求？
答、默认参数后面的变量，也必须是默认的，例如
int func(int a,int b=0,int c);
这种定义是错误的，改为int c=0；即可。
32、函数参数顺序不同，能不能被重载？
答、可以。
33、函数的返回值类型，能不能作为重载的条件？
答、不能。
34、void func（）
{
}
void func(double a)
{
}
void func(int a）
{
}
int main()
{
func(10);
}
问函数调用什么？如果func(int a)被删掉，函数调用什么？
答、未删调用func(int a);删掉调用func(double a);
35、函数重载是怎么实现的？
答、通过编译时对函数名进行修饰来实现，区分。
36、为了让c语言编写的程序能够被c++编译器指定按照c语言的方式编译，要采用什么方式？原理是什么？为什么要这样改变？
答、使用extern "c"，原理是告诉c++编译器在extern “c”作用范围内的代码(一般是函数)要用c语言的方式编译。
原理是在对这段代码中的函数进行编译时，按照c语言的编译方式。如果没有extern “c”形式语法，会按照c++的方式编译函数例如 int ptr(int a）；
ptr会被编译修饰成ptr_int。这是因为c++是支持函数重载，必须这样编译。而c语言不会。所以c++编译后的函数名找不到本该由c语言定义的函数名。
总的来说，最主要的原因是c语言不支持函数重载，c++支持函数重载，它们对函数的编译和查找链接函数是不一样的。
注意到底是按什么方式编译通常是由文件名决定，例如.c或.cpp。
37、const int constA = 10;
int *p = (int *)&constA;
*p = 300;
cout << "\n%d\n" << constA << endl;
cout << "%d\n" << *p << endl;
问，在c++中会优化吗？加const变量优化的含义，如果const int constA=10在函数外也会优化吗？如果不想const修饰的变量constA被优化，可以怎么做？
答、会，输出结果是10,300；这个在c语言中是相同的，而且改变cout为printf输出结果也是相同的，如果在函数外就不存在优不优化问题，因为默认变量存储在只读常量区，
是不能修改变量的值的。而且变量在只读数据段有对应的存储空间。只是它是写保护的。如果不想constA
38、const int constA = 10;
int main(){
int* p = (int*)&constA;
*p = 200;
}
问这段代码能不能在c++中编译通过？能运行吗？
答、可以编译通过，但是不能运行。运行提示错误：引发了异常: 写入访问权限冲突。这个现象与c语言中相同。
39、volatile什么含义？
答、不稳定的。
40、如何不让const修饰的变量发生编译器优化现象？
答、在const前面加volatile。
41、说说const编译器优化？
答、①、const修饰的变量，是局部变量，初始赋值时是一个字面值例如 const int a=19；或一个非常量变量，
例如 int b=20；const int a=b；如果使用指针改变其内存空间的数据，当直接使用变量名时，会将变量名替
换成const初始化的值。而不是改变后的值。
②、const修饰的变量，是局部变量，初始赋值时是一个常量例如 const int b=20；const int a=b；则编译器会优化。
③、加volatile，编译器不会发生优化。
42、注意c++是对c语言扩展以及改进的好处？
答、按照这个思想，要对与c中有相同的语法的细节性属性进行思考，注意这些语法的功能往往比c语言更加人性化，更合理。
注意词语：增强、兼容c、拓展、实现c不能实现的、严格。
43、06 请说出以下代码是否会发生编译错误，如果发生是哪一行代码会发生？并说明原因
int add(int a,int b)
{
return a + b;
}
double add(double a,double b)
{
return a + b;
}
void test()
{
int a = 10;
int b = 20;
double c = 7.5;
double d = 9.2;
cout << add(a, b) << endl;
cout << add(c, d) << endl;
cout << add(a, c) << endl;
}
答、cout << add(a, c) << endl;会报错，因为没有对应的重载函数
问这种表述正确吗？
答、不正确，因为不能正常工作的原因是存在多个版本的函数都能匹配函数调用。如果把第一个add函数
int add(int a,int b)的定义删除，发现都可以编译。int 和double之间可以转换的。
44、05 请描述内联函数的作用?以及内联函数和宏函数的区别？
答、预处理时宏函数虽然可以在调用函数时直接找到函数的定义，提高效率，但是宏函数会带来难以发现的错误，而且c++中的类成员，是不允许使用宏函数。
为了即能达到宏函数的功能，又可以避免宏函数的缺点，c++中引入了内联函数，内联函数没有函数调用时开销，内联函数可以像普通函数那样，进行参数、
返回值类型的安全检查，而且可以作为成员函数。
问哪里有错？
答、"预处理时宏函数虽然可以在调用函数时直接找到函数的定义"这种描述是不正确的，应该是在预处理阶段函数体替换到函数调用的地方。
45、在C++中，关于下列函数参数的描述中，（ ）是正确的。 (得分 0/ 20分)
A 、 C++语言中，实参是按照自左至右的顺序求值的；
B 、 若一个参数设置了默认值，则其右边的所有参数都应该具有默认值；
C 、 函数参数的默认值不允许是表达式；
D 、 设置参数默认值时，应该全部参数都设置；
问选什么？
答、B，注意函数参数的默认值可以允许是表达式。注意1+3也是表达式。
46、内联函数的内联对编译器来说，只是一个建议，编译器在什么情况下不会将函数进行内联编译？
答、1、不能存在任何形式的循环语句、不能存在过多的条件判断语句、函数体不能过于庞大、不能对函数进行取址操作。
47、struct 和 class有什么区别？
答、①、struct 中不指定成员类型，默认是public，class中默认是private。②、struct中不加继承权限控制时，默认是公有继承，class中默认是private继承。
48、int &&n=3；int &&n=a；问那个可以编译运行成功？
答、int &&n=3可以，但是int &&n=a不可以。
49、问sizeof(e)的大小是什么？
答、引用的变量的大小。
50、问const和#define之间的区别是什么？
答、两个方面1、const 有类型，编译器必须要对其进行安全检查；而#define无类型，不会对其进行安全检查。2、#define的作用域，
默认从定义处到文件结尾，或到宏卸载指令处(而const是有作用域的概念的，如果定义的常量有作用域的要求，#define就不可以使用。
51、如何提高结构体、类的数据的封装性？
答、可以通过函数返回成员数据。避免用户直接使用变量名，若以后数据有修改，改动麻烦。
52、接口最好放在什么文件？
答、头文件。
53、封装的特点？
答、将数据和函数封装在一起；对封装的成员进行访问控制。
54、类的成员权限是怎么区分的？
答、在类的内部，成员没有public、private、protected权限之分；在类的外部才会严格区分权限，即对象会有访问权限设定。
55、类的成员访问权限设计到几个主体？
答、类、子类、对象三个。
56、private权限是什么概念？
答、只能由该类访问，子类和对象都不能访问。
57、protected权限是什么概念？
答、只能由该类和子类访问。
58、public权限是什么概念？
答、可以有本类、子类、对象访问。
59、对象的本质是什么？
答、类数据类型的变量。
60、标识命名的潜在规定（潜规则）？
答、m_name、G_a、P_a;分别标识成员、全局、指针变量。
61、问std在c++什么文件中？
答、std在c++系统文件iostream中。
62、为什么类对象初始化和销毁要提供构造函数和析构函数？？？？
答、因为类对象中存在函数，函数的调用与数据不同，会用到堆栈，所以要引入构造函数和析构函数。
63、简述类对象创建和销毁的过程？
答、对象创建时，先分配内存，再调用构造函数；对象销毁时，先调用析构函数再归还内存。
64、析构函数返回值可以是void吗？
答、不可以。析构函数也没有返回值。
65、析构函数的参数可以设置吗？
答、不可以。
66、构造函数被调用了意味什么？
答、对象一定会产生，对象的内存一定被分配了。一定有一个新的对象产生。
67、一个对象能调用多个构造函数吗？
答、不能。
68、构造函数和析构函数能被重载吗？
答、构造函数可以，析构函数不可以。
69、什么情况下必须要写类的析构函数？
答、只要类的内部使用了指针，而且指针指向了堆内存空间，就必须要写析构函数，并在析构函数中释放堆内存。
70、无参构造函数可称为什么？
答、默认构造函数。
71、有参构造函数可以使用默认构造函数吗？
答、可以。
72、拷贝构造函数的模板是怎样的？拷贝构造函数的参数必须是引用吗，可以是指针吗？
答、Person(const Person &person)
{
}
必须是引用，不能是指针。
73、问
Person person1=Person(10,20);这种写法对吗？
答、对为对象赋值。调用拷贝构造函数
74、问Person person05=10;等价于什么？
答、Person person05=Person（10）；注意必须要有与参数类型对应的构造函数。
75、c++头文件<string>中的string是什么？
答、类。
76、类对象如何是匿名的，它有什么特点？如何创建？
答、匿名对象只活在当前行。直接写构造函数就会创建匿名对象。
77、问Person person01；
Person(person01);会报错吗？？？？
答、会，因为第二句不是产生匿名对象，而是创建对象person01，所以会报错。
78、构造函数必须是公有的吗？
答、对。如果是私有的，是不能在类外访问的。所以如果是struct定义类，默认是public，不需要加，如果是class必须要加public。才能写构造函数。
79、问Person p=person；
和Person p；
p=person;有什么区别？
答、第一句是调用拷贝构造函数创建对象；第二句是赋值行为，对象已经创建好了，但等号不是以拷贝的方式赋值，
而是等号赋值的方式。
80、Person CreatePerson()
{
Person person;
cout<<"person:"<<(int)&person<<endl;
return person;
}
void test()
{
Person p=CreatePerson();
}
问这段代码用debug模式和releas(发行)模式编译有什么区别？
答、debug模式会调用拷贝构造函数，p和函数返回的对象是不一样的，拷贝过后，就会释放返回的对象、
release模式不会调用拷贝构造函数，p和函数返回的对象是一样的。
81、编译器优化是什么含义？
答、编译器编译的时候会修改用户代码，进行优化。
82、构造函数如果没写，会不会有构造函数？
答、有，编译器会自动添加。
83、c++编译器至少会默认添加几个函数？
答、默认构造函数、析构函数、拷贝构造函数、赋值函数。但是如果手动添加了拷贝构造函数，编译器就不会
提供默认无参构造函数，也不会提供默认拷贝函数。
如果手添加了非拷贝构造函数，编译器也不会提供默认无参构造函数，但是会提供拷贝构造函数。
84、默认的构造函数特点？默认的析构函数特点？默认的拷贝构造函数的特点？
答、构造和析构什么也不做，但是拷贝构造函数只会进行简单值拷贝(如果有变量指向堆空间，堆空间不拷贝，
会造成浅拷贝问题）。
85、如果类内有堆空间申请，要注意什么？
答、析构函数必须有，且要通过析构函数释放堆空间。
86、默认的类拷贝构造函数是简单的值拷贝，为了解决浅拷贝和深拷贝问题，要如何解决？
答、手动编写深拷贝构造函数。
87、编写类类型的技巧？
答、只要类中出现指针变量，并且指向堆空间，就手动编写析构函数释放堆空间，和拷贝构造函数。
88、类RichPerosn，内有定义类成员bus、car，问定义类RichPrson对象时，构造函数和析构函数是怎样的
(注意此时默认调用对象无参构造函数，不存在有参构造函数)？
答、先调用对象成员bus、car的构造函数，再调用对象RichPerson的构造函数，析构函数与构造函数相反。
89、如果上述bus类定义了有参构造函数，不做处理会不会报错？如何处理？
答、会。在RichPerson类的构造函数编写初始化列表。没有初始化列表，成员类对象调用无参构造函数，如果没有就报错。
90、在c++中int 类型、double类型是不是类？
答、是，可以通过int a（10）;double b(23.3)初始化变量。
91、异常的作用？
答、最明显的一点是异常返回的类型比较丰富，如果一个函数需要返回指针类型或int 类型，但是函数返回值是一种类型，
使用异常机制就可以返回这两种类型。
92、问为什么内联函数不能进行异常接口声明？
答、因为异常中异常会往上一个函数抛、如果没有处理还会往再上一个函数抛，如果进行内联，就会影响异常接口的效率。
93、
class A
{
public:
A(int a,int b):_b(b),_a(_b)
{}
void show()
{
cout << "a = " << this->_a << " b = " << this->_b << endl;
}
private:
int _a;
int _b;
};
int main(void)
{
A a(3, 4);
a.show();
return 0;
}则输出结果正确的是（ C ）。
(20分)
A 、 a = 4 b = 4
B 、 a = 3 b = 4
C 、 a的结果为随机值，b = 4
D 、 a 和 b 的结果都为随机值
94、
错误 C2679 二进制“<<”: 没有找到接受“std::string”类型的右操作数的运算符(或没有可接受的转换) CheckTest g:\vscode\checktest\checktest\test.cpp 156
问什么原因？
答、没有包含string的系统文件。反而错误地使用了string.h文件。
95、已知Person是一个类,person1是其一个对象，问Person person=person1有没有调用拷贝函数？
答、有调用。可能是默认的（没写的情况下，编译器自动添加），可能是自定义的拷贝构造函数(程序有写)
96、class RichPerson//定义富人类
{
public:
RichPerson(int a, int b) : mBus(b),mCar(a)
{
cout << "RichPerson构造函数" << endl;
}
RichPerson() :mCar(0), mBus(0)
{
cout << "RichPerson 构造函数" << endl;
}
~RichPerson()
{
cout << "RichPerson析构函数" << endl;
}
public:
Bus mBus;
Car mCar;
};
问，RichPerson person(10, 20);构造函数构造过程，析构函数析构过程是怎样的？
答、构造函数先根据public:中成员顺序，即先Bus、后Car确定初始化对象的顺序，再根据构造函数初始化列表进行初始化过程。
析构函数调用顺序是构造函数的逆顺序。
97、什么回调函数？
答、一个函数的参数是函数，这个函数就称为回调函数。
98、vs可不可以设置每次编译时的虚拟地址相同？
答、可以。
99、数据结构的本质是什么？
答、数据间关系的框架。
100、void *称为什么指针？
答、泛型指针。
101、命名空间的作用？
答、主要是防止重名问题。
102、const在c语言和c++中常用用法是什么？
答、在c语言中配合指针作为函数的参数；在c++中配合引用作为函数的参数。
103、const在c++中使用会优化，该功能与define很类似，那么有什么好处？
答、可以进行类型检查，但是define是在预编译时处理，不会进行类型检查。
104、内联函数和宏函数在什么时候调用展开？
答、内联函数是在编译阶段；宏函数是在预处理阶段。
105、c++编译器能自动释放堆内存空间吗？
答、不能。必须手动释放。
106、如果类中有成员指向堆空间，要注意什么？
答、拷贝构造必须手写，赋值构造必须手写，析构函数必须手写，且要考虑堆空间。
107、explicit关键字只能用在什么地方？
答、构造函数。
108、析构函数能不能手动调用？
答、不能。但是构造函数可以。
109、动态对象是什么？
答、在堆中分配对象。
110、用malloc系列函数分配动态对象有什么缺点？如何解决？
答、需要手动调用构造函数，而且成员也不会自动调用构造函数。可以用new功能代替malloc功能，
new关键字分配的动态对象会由编译器代替我们做很多事，包括避免malloc分配的缺点。
111、问malloc创建的动态对象，能不能用delete释放？
答、不一定可以运行。但是编译可以通过。如果涉及到指针，malloc的对象有指针成员分配堆空间，就不能用delete。
因为delete会自动调用析构函数，如果没有申请堆空间(malloc申请对象，需要自己设置构造函数)，delete就会执行失败。
112、用new创建的对象有什么特点？
答、分配了内存，并进行了初始化。
113、student *stud=new student[10];
student stu(100);
stud[0]=stu;
问第三句使用了拷贝构造函数还是赋值构造函数？
答、赋值构造函数。
114、void *p=new stduent;
delete p;
问能够执行析构函数吗？
答、不会，delete根据指针类型执行，p的类型是void *，所以析构函数不会执行。
115、问类的静态成员变量和非静态成员变量的区别？
答、静态成员变量是类所有对象公有的。
116、c、c++写的程序和java程序哪个保密性更强？
答、c、c++。
117、生成解决方案错误的分类？
答、编译器、链接器、预编译器
118、class person
{
public:
int mA;
static int sB;
}
问有什么问题？
答、类的静态成员变量必须在类内声明，在类外定义(可不初始化)。可改为
class person
{
public:
int mA;
static int sB;
}
int person:: sB=100;
119、静态成员变量两种访问方式？
答、对象，或类名加::
120、静态成员函数的作用？
答、为了封装静态成员变量(访问、赋值)等，但是不能访问非静态成员变量(因为没有this指针)。
121、非静态成员函数能访问静态成员变量吗？
答、可以。
122、类的静态成员变量一般在哪初始化最好？
答、在类外，类内只声明。
123、类中的静态成员变量如果加上了const修饰(在只读区存放),应该在哪初始化最好？
答、类中，声明的时候就初始化。
124、通过定义函数指针类型，比直接定义函数指针有什么优势？
答、效率更高。
125、为什么有时候需要使得一个类只能实例化一个对象？如何实现？
答、例如点击窗口，希望每次点击都是同一个窗口（任务栏管理器、垃圾箱等），因为c++是一切皆对象，而对象又是类的实例，
所以必须通过限制类的方式实现这种需求，可以通过static实现。
126、能不能用malloc创建对象？
答、可以，比较麻烦。
127、构造函数私有能直接创建对象吗?
答、不能。
128、
class config
{
private:
config(){}
public:
static config *pconfig;
};
config *config::pconfig=new config;
问语法有什么问题？
答、没有问题，规定在main函数外依然属于类的内部。该代码可以保证一个类创建一个对象。如何优化代码。
129、调用静态函数需要使用对象调用吗？
答、不需要。
130、单例有什么好处？
答、限制类创建对象的个数。
131、单例程序为什么不能用new一个对象？
答、因为构造函数、拷贝函数是私有的。本质是通过语法限制，实现了一个功能，就是一个类只保证创建一个对象。
(这个对象实际上在main函数外已经被创建).
132、类的对象包括什么数据？
答、只包含非静态成员变量，即函数(无论静态还是非静态)、静态成员变量都不在对象的空间中。
133、
class person
{
void show()
{
cout<<"mA:"<<mA<<endl;
}
int mA;
}
问编译器执行show函数时要怎么做？
答、person p1；
p1.show();编译器会进行优化，将this指针的运行机制添加进去。
134、问const person p1;的含义？
答、p1内存储空间的数据不能改变。
135、
class Student
{
public:
Student()
{
mA=0;
}
void func()//const
{
//this->mA=100;
mC=100;
}
public:
int mA;
int mB;
mutable int mC;
}
void test02()
{
const Student stduent;
student.func();
}
问会不会报错？
答、会。因为student对象不能调用一个非const函数。可以改为void func()const;其中const修饰this指针
指向的内存空间。但是this指针不占大小。
136、
Teacher *teacher=NULL;
问
sizeof(Teacher）大小是多少？
答、1.
137、
class student
{
public:
void func()
{
cout<<"hello world"<<endl;
}
}
问
student *s1=NULL；
s1->func();
能不能执行？
答、可以，执行过程会优化成func(s1)，即this指针的值是s1的值，但是func中没有使用到对this的访问，所以任旧可以
调用这个函数，但是如果cout<<"hello world!"<<mA<<endl;却不能执行，因为会优化成this->mA,但是this的值是0.
所以一般要在函数中添加判断this指针是否为空的语句。if(NULL==this){return;};
138、
class Person{
public:
Person(char* name, int age){
pName = (char*)malloc(strlen(name));
strcpy(pName,name);
mAge = age;
}
~Person(){
if (pName != NULL){
delete pName;
}
}
public:
char* pName;
int mAge;
};
void test(){
void* person = new Person("john",20);
delete person;
}
问有什么问题？
答、待验证,不能delete成功，因为delete根据person的类型来释放，可以通过强制类型转换将person变成(Person *)person.
139、问题：malloc、free和new、delete可以混搭使用吗？也就是说malloc分配的内存，可以调用delete吗？通过new创建的对象，可以调用free来释放吗？
答、可以，可以。
140、问person *p1=new person；
delete []person,
有什么问题？
答、new时没有使用[]，delete时也不应使用。
141、静态变量在什么时候分配存储空间？
答、在对象创建以前就分配存储空间。
142、什么是类外？什么是类外不能访问？
答、类外是main函数等函数以外，类定义以后的空间，类外不能访问是即使使用类名作用域也不能访问。
143、单例的本质是什么？
答、特殊的类。
144、class Printer
{
private:
static Printer *pPrinter;
}
Printer *Printer::pPrinter=new Printer;
问该指针指向的对象有什么特点？
答、在main函数执行之前就被创建。
145、问每一个非内联成员函数(non-inline member function)只会诞生一份函数实例.的含义？
答、类中的所有成员函数都是以内联的方式。那么static修饰的函数也是内联吗？
146、c++类对象中的变量和函数的存储特点？
答、分开存储。
147、什么是非内联成员函数？
答、
148、常对象可调用非const成员函数吗？常对象还有什么特点？
答、不能。可以访问const或非const数据成员，但是不能修改，除非成员用mutable修饰。
149、问explicit的作用？
答、class MString
{
public:
explicit MString(int n)
{
cout<<"kkk"<<endl;
}
}
int main()
{
MString str1=1;//因为有explicit使得这种用法不能执行
MString str1(1);
}
150、QT常用快捷键有哪些？
答、F1 查看帮助
F2 跳转到函数定义（和Ctrl+鼠标左键一样的效果）
Shift+F2 声明和定义之间切换
F4 头文件和源文件之间切换
Ctrl+1 欢迎模式
Ctrl+2 编辑模式
Ctrl+3 调试模式
Ctrl+4 项目设置模式
Ctrl+5 帮助模式
Ctrl+6 输出模式
Alt+0 显示或者隐藏侧边条，编辑模式下起作用（有时写的函数太长，屏幕不够大，就用这个）
Ctrl+Space 自动补全（貌似会和输入法的切换冲突）
ESc 切换到编辑模式
Alt+1 创建细节窗口
Alt+2 搜索结果窗口
Alt+3 程序输出窗口
Alt+4 编译输出窗口
Ctrl+B 编译工程
Ctrl+R 运行工程
Ctrl+I 自动对齐
Ctrl+/ 注释行，取消注释行
Ctrl+Shift+< 折叠代码块
Ctrl+Shift+> 展开代码块
Ctrl+[ 跳到代码块的头部
Ctrl+] 跳到代码块的尾部
Ctrl+L 跳到某一行
Ctrl+F 查找替换当前选中的内容，按下Ctrl+F，会列出所有和你选的内容一样的语句
Ctrl+Shift+F 查找内容
F5 开始调试
Shift+F5 停止调试
F9 设置和取消断点
F10 单步前进
F11 单步进入函数
Shift + F11 单步跳出函数
151、静态对象的特点？
答、首先必须在类定义完全以后才会被定义。
152、单例模式中为什么类的静态成员指针指向的对象不能在类中被初始化，而是在类中有声明，在类外被定义？
答、因为在类中被初始化指向对象时，该类还没有被定义完全。
153、问要不要关心单例对象的释放问题？
答、不需要。
154、问int a=10;int &b=a;
cout<<&b<<endl;
cout<<&a<<endl;
打印结果是否相同？
答、相同。
155、下列关于this指针说法中，错误的是（ ）。(20分)
A 、 this指针在成员函数开始执行前创建，在成员的执行结束后清除，生命周期与函数参数相同。
B 、 this指针是通过函数参数的首参数来传递的，它代表当前对象的地址。
C 、 this可以在成员函数定义后，也可以在全局函数和静态函数中使用。
D 、 当一个对象创建后，整个程序运行期间只能有一个this指针。
答、C。
156、写出常成员函数的定义
答、void print()const;
157、静态数据成员只能在类的外部进行初始化？
答、是，在类中声明。
158、什么时候this指针被创建？
答、当一个对象被创建后。
159、问double *a=new double();
问这种写法对不对？
答、对。在c++中所有基本类型都是类，所以此处相当于调用了无参的构造函数，创建对象，并用指针指向它。
160、问饿汉式单例和懒汉式单例哪个好？
答、饿汉式(首先创建指针指向的对象）；懒汉式是线程不安全的。要在静态成员函数中初始化指针指向对象。
161、问单例的三个条件?
答、1、私有化构造、析构、拷贝；2、公有静态成员函数；3、私有静态指针成员(对象在类定义外，
main函数外被创建(饿汉式);对象在公有静态成员函数（懒汉式）；
162、 Person person3[]={Person("John",20),Person("Smith",22)};
这是什么形式？
答、这是在栈上用"聚合初始化"的方式初始化数组。注意在堆上用指针创建对象数组，并用聚合初始化的方式初始化
对不同的编译器而言是不一定能通过的。
163、cout<<"Person::sOther"<<Personx::sOther<<endl;
问如果sOther是静态成员变量，且是私有成员，能够在main函数中调用吗？
答、不能。
164、静态成员变量在c++中一般被用来做什么？
答、单例设计。
165、友元的作用？
答、在类外(main函数中,另一个类的对象)访问类内的私有成员。
166、c++中封装string类的头文件在哪？
答、#include<string>.
167、友元类的作用？
答、①、在友元类的函数中定义另一个对象，并在函数中通过这个对象访问其成员；
②、在友元类中定义另一个类的对象作为这个友元类的私有成员。
168、前置声明的作用？
答、提醒编译该声明位置后的所有代码都能看到声明，不会报错。
169、为了使得类内的友元函数内定义的类对象能够访问对象的成员，要注意什么？
答、只在类内部实现声明；但是定义放在类定义的外面，特别要注意该函数的定义内的所有数据必须都被定义。
170、问pa.operator+(pb)这种类型是什么函数？operator+(pa,pb)是什么类型函数？
答、前者是成员函数，后者是全局函数。
171、重载运算符两种类型？
答、全局函数、成员函数。
172、问pa+pb是如何经过编译器处理的？
答、先去类内部找operator+函数，如果成员函数没有，会去全局函数范围内找operator+。
173、问括号能不能重载？惊叹号能不能重载？
答、能。能。
174、问运算符重载本质是什么？
答、为了语法上的方便，本质是另一种函数调用的方式。还是函数。
175、Person operator-(Person &p1)
{
Person newperson(this->mA - p1.mA, this->mB - p1.mB);
return newperson;
}
问函数内创建了新对象，为什么函数参数还是引用？
答、为了提高效率，直接拷贝对象值会降低效率。
176、问匿名对象能不能作为左值？
答、不能，因为找不到地址，不知道存放在哪。
177、Person operator-(Person &p1,Student &s1)
{
Person newperson(p1.mA - s1.mAge, p1.mB - s1.mAge);
return newperson;
}
Person ret = p1-s1-s1;
问，p1-s1在什么地方？
答、p1-s1是匿名对象，有存储空间但是找不到地址，所以不能当左值。
178、c++中cout是什么？
答、ostream类的对象名。
179、ostream对象能被拷贝吗?
答、不能。所以
void operator<<(ostream &os,Person &person);第一个参数不能去掉&。如果需要返回值不能是void，
最好是ostream &。
180、为什么cout<<a<<"abcd"<<endl;能够运行？
答、cout是ostream类的对象，cout<<a首先执行，是调用了系统文件ostream类中的成员函数operator<<；
181、cin是什么？
答、istream类的对象。
182、输出是<<还是>>，输入是<<还是>>？
答、输出是<<;输入是>>
183、如何使重载运算符函数访问类的私有成员？
答、声明该重载运算符函数为友元函数。
184、重载运算函数的特点？
答、operator@作为函数的标识符，其中@为按规定的运算符。cout是ostream类的对象，一般用对象调用成员
使用对象名加.号形式，但是重载运算符函数不一样，通过对象名直接加上运算符再加上实参就能调用。而普
通函数是a.func(b);重载运算符函数是a+b;
185、重载等于号运算符函数要注意什么？
答、要注意深拷贝和浅拷贝问题。否则可能造成内存泄漏和内存释放异常。
186、引用作为函数返回参数的情况下，能进行参数合法性判断吗？
答、不能。只能返回引用，不能返回NULL等用来进行参数合法性判断的数据。但是可以用异常判断。
187、void print(int &a);
print(100);
问有没有错误？
答、有，int &a必须引用一个存储空间的数据，所以100作为右值不能引用。可以改成
void print(const int &a);
188、友元函数有私有或公有性质吗？
答、友元函数不属于函数中涉及到的类的函数，可能是类的成员函
数。
189、友元函数或友元类在什么地方被声明？
答、在要通过函数或类访问的类中被声明，即友元函数中出现的类。
190、解释重载[]运算符的函数 int &operator[](int index);arr[3]的运行方式？其中arr是对象。
答、首先arr是对象，该函数是类的成员函数，3会传递给index，其中[]指示要调用重载[]函数。
191、在分析友元函数时要先注意什么？
答、友元函数是全局函数，还是成员函数。
192、class Building;
//友元类
class MyFriend{
public:
//友元成员函数
void LookAtBedRoom(Building& building);
void PlayInBedRoom(Building& building);
};
问class Building是什么？
答、前置声明。
193、前置加加和后置加加的区别是什么？
答、前置加加是++号在前面；后置加加是++号在后面。
194、问operator++（）
{};
operator++(int)
{
};
哪个是前置加加，哪个是后置加加？
答、第一个是前置加加++a，后一个是后置加加a++;
195、vim中如何快速移动光标到行首？
答、shift+^;
196、vim中如何从光标处剪切指定行数的数据？剪切后如何复制？
答、d3；然后按enter键或d键，剪切后按小写p可复制。
197、vim如何往回缩进多行代码？
答、命令行模式下，shift+v选择行，可以按下键选择下面的多行，然后按=号进行往回缩进。按shift >向右缩进。
198、deprecated？
答、不赞成的。
199、=操作符的结合性是怎样的？
答、从右到左，即a=b=c，先算b=c，再算a=b.
200、问linux关机命令？
答、shutdown -h now。
201、运算符重载一般在什么地方比较常见？
答、库。
202、多继承经常被使用吗？
答、不会。
203、运算符重载时()运算符的作用是什么？
答、例如person是类，p1是类的对象，则p1()并不表示函数，而是调用了运算符()的重载函数。可以作为回调函数。
204、哪些运算符只能通过成员函数重载？
答、=、（）、[]、->
205、内联函数编译的时候就能确定函数的定义，而非内联函数编译时只存储了要调用的函数的地址。所以效率较低。
答、对。
206、函数对象本质是什么？（重载括号运算符），效率怎么样？在哪里应用广泛
？
答、是一个类对象，效率比非内联函数高，在STL中引用广泛。
207、友元功能产生的原因？
答、在类外访问类的私有成员。
208、问operator++（）；和operator++（int）的区别，以及int的作用？
答、前者是前置加加，函数返回类名引用，后者是后置加加，返回是一个类类型，int是为了方便编译器区分是前置加加
还是后置加加。
209、标识符命名技巧？
答、重复，例如testtest
210、匿名对象又叫什么？
答、临时对象、一般会被当成右值，生命周期只存活在当前行的值都被视为右值。
211、gcc中匿名对象如何被处理？
答、会被当做右值，但在vs中会被当做既有左值、又有右值。
212、在gcc中为了引用匿名对象，要做如何处理？
答、通过添加const，例如const person p1=person(10);就不会报错。
213、靠程序员自觉减少错误，这是最不好的解决方案？
答、对。
214、已知类SmartPoint中有：public:Person* operator->(){return pPerson;}
public:Person* pPerson;
main函数中
SmartPointer pointer(new Person(100));
问pointer->PrintPerson();如何执行？
答、先调用->重载函数，然后pointer->返回pPerson，但是编译器会对该语句优化，变成pPerson->PrintPerson();
总的来说，pointer->PrintPerson()会被优化成pointer->->PrintPerson();只是为了保证一致性，程序员不需要
手动再添加->。
215、如何把对象转换成bool类型？
答、person 类中：operator bool（）{};
main函数中，bool flag=p1；p1是person的对象，同理可以定义int型，再同理可以定义另一个类类型的重载函数
(即通过该方式可以进行隐式类型的转换)。编译器遇到bool flag=p1时，先看p1的类型是一个类，但是要转换为bool，
于是去类中找有没有隐式类型转换的函数(找有没有operator bool类型函数)，
发现有，就调用并返回。
216、c++中只是重载运算符吗？
答、不是，还能重载类类型，包括基本类型。
217、什么操作符在基类被重载
218、为什么等号只能在成员函数中进行重载？为什么中括号[]必须在成员函数中进行重载？
答、类中有默认的等号赋值，如果在全局函数中重载等号运算符，会引起歧义，而且使用类中的等号运算符函数。
而[]使用时默认需要一个对象，所以规定必须在类中重载[]。
219、if (complex1 && (complex1 += complex2)){
cout << "真!" << endl;
}
&&及+=已经被重载。
问程序执行顺序？
答、先执行complex1+=complex2;再从左到右执行，这样破坏了complex1的数据，也不符合本来&&从左到右的执行顺序。
所以不建议使用&&重载，类似||也不建议重载。
220、问a&&（a=b）;执行顺序，并与219比较？
221、问c++中：void print(char *str){};
执行print（“abcde”）;会出现string类型和char *类型不兼容，如何解决？
答、改为void print(const char *str);（重要）。
222、问strcpy是否会将'\0'拷贝到目的字符串？
答、会。
223、如果类中有字符串成员，对赋值号重载时，要注意什么？
答、先将原字符串空间释放，并清空，然后按照赋值的功能拷贝。
224、问strcat会不会自动在末尾一行添加'\0'?如果两个要被处理的字符数组都没有'\0'结尾？如果最后一个字符串有'\0'会不会自动添加(还是说会被追加)?
225、char buf[1024]={0};
cin>>buf;
问要不要担心从屏幕输入的数据超过buf缓冲区的大小？
答、不需要，理由一从屏幕输入的数据也会存入一个缓冲区，这个缓冲区满了以后，就会自动把数据输入到buf，
剩下的数据会继续存入系统的缓冲区。但是buf中已经有了数据，而且buf未溢出(一般屏幕输入的缓冲是不会超过1024的）
，而接下来的手动输入的数据一旦超过系统的缓冲区会被丢弃，未超过会留在缓冲区。
理由二手动输入超过1024个字节一般不会出现这种情况。
226、问cin>>buf,能够手动输入空格到buf缓冲区吗？如何解决？
答、不能。可以通过cin.getline(buf,1024)，将空格输入进去。
227、公司的源代码比较多，怎么办？
答、先熟悉与工作相关的接口。
228、友元、继承、重载、类中定义其它类的对象、类中私有、类中公有、类中保护的本质？
答、从数据的访问权限和操作数据的方式两个角度细化出来的概念。
229、给出protected权限的使用实例。
230、多继承都可以用单继承代替？
答、对。
231、某个类的私有成员，能够被其它类继承吗？
答、能。但是子类不能访问。即这个私有成员是其它类的成员，但不能说是私有成员，而是不能直接访问（编译器禁止访问），但是一定存在。可以通过指针偏移访问。
232、如何查看类的成员？
答、看视频，找答案。需要借助开发工具。C:\ProgramData\Microsoft\Windows\Start Menu\Programs\Visual Studio 2015\Visual Studio Tools
233、如果子类通过公有继承方式继承基类，问基类中的成员在子类中的访问权限是怎样的？
234、如果子类通过私有继承方式继承基类，问基类中的成员在子类中的访问权限是怎样的？
235、如果子类通过保护继承方式继承基类，问基类中的成员在子类中的访问权限是怎样的？
236、可以通过指针访问所有类的私有成员？
答、是。
237、问类中有其它类的对象，构造函数如何调用？
答、当创建该类对象时，先构造成员，再构造自己。？？待检验，析构函数相反。
238、问子类和基类构造函数如何调用？
答、先调用基类，再调用子类。析构顺序相反。
239、问如果父类存在有参构造，如何处理？
答、父类有有参构造函数，默认无参构造函数不会添加，需要在子类构造函数时指定初始化列表。
240、类的初始化列表的作用？
答、两个，1、初始化列表可以初始化对象成员；2、继承时，可以初始化父类的数据。
241、derive？
答、派生。
242、一个类中存在另一个类的对象，问这种模式称为什么？
答、组合。
243、如果一个子类中有其它类的对象做成员，即（继承和组合模式），那么这个子类的对象的构造顺序是什么？（常用面试题）
答、先调用基类构造函数，再调用对象成员的构造函数，最后调用该子类构造函数，析构函数相反。可以先将所有成员排个序（包括继承的），
然后根据成员顺序分析构造函数的调用情况。所有类的对象都是按照类成员的顺序进行构造。
244、问子类的函数如果和父类函数重名，编译器如何处理？
答、编译器会隐藏父类同名函数。子类对象按就近原则访问子类的同名函数，如果要访问父类的同名函数，可以通过指定作用域的方式。
245、只要子类的函数名和基类的重载版本的函数名同名，基类所有版本的重载函数都会被隐藏？
答、对，但是可以通过指定作用域方式重新调用。
246、有没有静态对象的概念？
答、待解答。
247、静态成员函数，能不能重载？
答、可以。
248、静态函数和普通函数的继承特性是一样的？
答、对。
249、问构造函数、析构函数、operator=、拷贝函数（即能够默认提供的）能不能被继承？
答、不能，都不能。
250、除了=号，其它的operator重载函数，能不能被继承？
答、可以。注意=号重载函数，和其它运算符重载函数不一样，它会被默认提供。
251、MyInteger myint(10);
cout << (++myint) << endl;
cout<<(myint++)<<endl;
cout<<myint<<endl;
cout<<"abcd"<<endl;
//myint++;
cout<<(myint++)<<endl;
cout<<(++myint)<<endl;
问这段代码有什么问题？
答、在linux上cout<<(myint++)<<endl;运行不了。
252、teststring.cpp:10:20: warning: deprecated conversion from string constant to ‘char*’ [-Wwrite-strings]
print("helloworld");
问linux上报错的原因？
答、因为函数print的形参是char *str；如果改变为const char *str；就可以消除。
253、c++中继承的最终目的是什么？
答、实现多态。
254、举一个c++中继承的例子？
答、继承的方式可以实现代码复用，例如网页的头部和尾部可以设计成一个基类，而网页的内容又分成另一个类，所有的网页都共同继承一个基类头部和一个基类尾部，
当改变网页的头部或尾部时，
只要改一个头基类或尾基类即可。
255、[]专业称呼是什么？
答、数组下标运算符。
256、问++只能用于整型变量吗？
答、不是，也可以用于浮点型。
257、匿名对象是什么？
答、有存储空间，但是这个空间的地址不能获得。
258、类中有成员函数：Person operator+(const Person &p1)
{
Person temp;
temp.age=this->age+p1.age;
return temp;
}
cout<<p1+p2<<endl;
存在全局重载运算符<<的函数：
ostream &operator<<(ostream &os,Person &p1)
{
os<<p1.age;
return os;
};
问linux上能不能运行成功？
答、不能;分析cout<<p1+p2<<endl;运行机制；
重载<<中os会引用对象cout(std命名空间中),本来p1要引用p1+p2的返回值，但是gcc是不会引用一个匿名对象的，除非加上const。
所以必须将重载<<函数的第二个参数改为const Person &p1;
如果在main函数中；Person &p1=Person(20);同样是运行不成功的，Person(20)产生的是一个匿名对象，所以必须加上const。
259、问int &&m=10;m是什么变量？
答、m是用来引用右值的变量（可以是匿名对象，字面值，字符串，）。&&右值引用是在c11中才出现。
260、如何在vim中注释指定行，取消注释呢？
答、注释：首先进入命令行模式，然后移动光标到要批量注释（插入字符）的起始行，然后按下ctrl+v键，
进入visual block模式，然后用j、k选中要批量注释的行，再按一次大写I，最后输入注释符/或要插入的符号。
取消注释：首先进入命令行模式，然后移动光标到要批量取消注释(消除字符）的起始行的首列，然后按下ctrl+v键，
进入visual block模式，然后使用l键选中要取消的符号的列，再按k，l键进行调整，选中要取消的行，
再按d键，就可以全部删除。
261、前置++重载函数，返回值是什么？
答、返回值是引用。
262、后置++重载函数，返回值是什么？
答、返回值是一个类型。
263、new运算符创建的对象返回值是什么？delete操作的对象的存储空间是什么？
答、指针。指针。
264、+=的重载运算符功能？
答、将一个类的每个成员数据分别加上某个值。
265、问person operator+（int a）;
+号是和谁结合？
答、operator。
266、问类对象a;要实现a+3的功能，应该重载成什么类型函数？
要实现3+a的功能，应该重载成什么类型函数？
答、第一个重载为成员函数；第二个重载为全局函数。
267、哪四个运算符最好重载成成员函数？
答、=、[]、（）、->;
268、哪两个操作符最好通过友元函数进行重载？
答、<<、>>;
269、哪五个操作符不能进行重载？
答、.、::、.*、？:、sizeof
270、使用vs开发人员命令，查看类的成员情况？
答、打开Developer Command Prompt for vs 2017;输入命令g:\vscode\Practice\Practice>cl /d1 reportSingleClassLayoutDerived AllOverLoad.cpp；
其中cl前为.cpp文件所在的目录，是cL(应该小写）；不是c one；其中Derived为类名。AllOverLoad.cpp为类Derived所在的文件。
271、问private和protected的区别？
答、如果没有涉及到继承和派生，private和protected权限是同等级的，外部不允许访问。
如果涉及到继承和派生，基类中的private权限变量是不可以被子类内访问的；但是protected对象是可以在子类中被访问。
对protected的理解只有通过与private比较。
272、问一般网络服务器的域名名字？
答、www
273、vs快捷键如何添加注释？如何取消注释？
答、ctrl+k ctrl+c；
取消注释是：ctrl+k ctrl +u
274、如何在记事本中实现查找功能？
答、在编辑菜单栏中存在。
275、strncpy(newname, this->name, this->name-start);
其中start是字符子针指向的是this->name字符串中某个与另一字符串使用strstr后匹配的结果。问有什么问题？
答、this->name比start地址小，所以是赋值，运行报错：0x0FAC0509 (ucrtbased.dll)处(位于 Practice.exe 中)引发的异常: 0xC0000005: 写入位置 0x01231000 时发生访问冲突。
276、程序中已经定义某个数据，为什么还会报错没有定义？
例如 类成员int a；已经定义，但是函数中对该变量访问，ide任会报错提示没有该数据，是什么原因？
答、少了}、；等。造成int a被定义到函数中去了，想想也是，说明 int a 的作用域并不是像自己所设计的那样。
277、问perons &operator+=(int age);
函数如何返回？
答、返回*this;因为person &需要返回的值必须要代表一个存储空间。
278、is >> "请输入年龄:" >> age;
is是istream类的对象，问这句代码有什么错误？
答、"请输入年龄"是字符串，不是一个变量。
279、gcc不能直接打印匿名对象？引用匿名对象要加上const？
答、是。对。例如 const Person &p1=Person();
280、问什么是匿名对象？
答、有存储空间，但是存储空间的地址对用户来说未知的量。（在这里量表示这个存储空间，实际上标识符本身就有
代表存储空间的意思）。
281、问可以通过数组下标重载成p1[p2]的形式吗？已知p1和p2是类的对象？
答、可以，虽然p2是在[]内，但是它本质上还是以实参的形式传递给函数。
282、给出重载int型（只是个例子）函数的代码？使用的代码？
答、类的成员函数
operator int()
{
return this->age;
}
Person p1(20,"张三");
int age=p1;
operator 后的类型就是要隐式转换的类型。必须与return的数据保持一致
(注意，没有返回类型，但是有return；实际上return要加是因为operator 后的类型是int；（）是不允许有参数的。
283、问类的前置声明的作用？
答、可以扩大类的作用范围，前置声明下面都可以访问。
284、
class Person
{
public:
int age;
void print();
}
print()
{
cout<<this->age<<endl;
}
问这段代码有什么问题？
答、class定义完后要加上;号，print（）函数定义时要加上Person::;
285、
class Student;
class Person
{
public:
int age;
void print()
{
Student s1;
cout<<s1.number<<endl;
}
};
class Student
{
public:
int number;
};
问这段代码犯了什么错误？
答、Student类定义在Person类后面，print（）函数中定义了一个Studnet类对象是不合法的，因为此时Student类还未定义，无法为变量s1确定内存空间，编译器会报错；
应该只在类中声明该函数成员函数，在Student定义完后再定义这个函数。
class Student;
class Person
{
public:
int age;
void print();//声明一个成员函数
};
class Student
{
public:
int number;
};
Person::void print()
{
Student s1;
cout<<s1.number<<endl;
}
286、c++中命名空间能在函数中被定义吗？
答、不能，只能全局定义(在函数外)。
287、命名空间可以嵌套定义吗？
答、可以。一个命名空间内可以定义另一个命名空间。
288、命名空间定义以后，能再次定义该命名空间，并投入标识符吗？
答、可以，但是如果是相同的数据，同一个命名空间就有多个同名标识符？？？
289、无名的命名空间相当于什么？
答、相当于让空间内所有标识符都添加了static。
290、能不能为命名空间指定别名？
答、可以。
291、命名空间中有重载函数，问如何合理调用？
答、通过using方式；例如 using A::func;就能调用所有重载了func的函数。也可以通过using namespace A；的方式。
292、直接在函数中通过using的方式使用命名空间，有什么缺点？
答、例如
void test02（）
{
using namespace A;
using namespace B;
}
可能会造成二义性，不如A::的方式好。
293、命名空间的作用怎么样？
答、很有用。
294、using namespace std的using的作用是什么？
答、using是为了打开命名空间std。
295、问const的作用？
答、限定变量为常量。
296、问c语言中如果局部定义const int arrSize=10；
int arr[arrSize];
能运行吗？
答、不能，因为编译器编译时arrSize是占用内存空间的，而编译器不知道它编译时的值是多少。如果是全局的就可以？
待检验。
在c++中待验证失败，可以运行。但是在c语言中不行，不能运行。
297、c++中所有函数外定义的const作用域是什么？
答、整个文件。但是其它文件不能访问，即不具有全局作用域(项目其它文件也能使用).这与c语言是不一样的。
298、问c++中const int a=10；a有没有被分配存储空间？
答、取决于有没有对a取地址，或extern操作，如果没有，编译器会优化成常量，不分配内存空间。试问这个时候
a存储在哪？10存储在哪？
299、问c语言中全局的const修饰变量存储在哪？c++中当有extern或者对变量取地址时，const修饰的变量存储在哪？
答、c语言中会存储在常量区，c++中也会存储在常量区，而且此时已经分配内存空间。
300、问字面值存储在哪？
301、问局部定义的变量const int constA=b;问会不会优化？
int b = 10;
const int constA = b;
int* p = (int*)&constA;
*p = 300;
cout << "constA:" << constA << endl;
cout << "*p:" << *p << endl;
这个代码输出结果是什么？
答、不会。constA:300;*p:300;
302、const int constA = 10;
int* p = (int*)&constA;
*p = 300;
cout << "constA:" << constA << endl;
cout << "*p:" << *p << endl;
问输出什么？其中constA是在局部定义？
答、constA:10;
*p:300;
303、问c++中const优化指的的什么？
答、const修饰的局部变量a，如果初始化时的值是一个字面值10、12等。①、当不对该变量a进行取址操作或extern操作，变量a不会被分配内存，仅仅是用10代替a，相当于define；
②、但对a进行取址操作，c++编译器非常智能地，会为a分配存储空间，并用*改变了a内的数据，但是cout<<a<<endl;任然不会输出a改变后的值，而是继续类似define的功能方式，
输出原值。
304、c++中const定义的局部变量，什么时候不优化？
答、当volatile修饰了const时；当用另一个会开辟内存空间的变量(非const)初始化赋值给该变量；（例如int b,类对象，结构体）
305、如何将c++中函数外定义的const修饰的变量，具有全局作用域？
答、加extern。
306、问怎样用数组下标定义变量？
答、在c99编译器中可以。但是vs2013不支持c99.
307、#define A 20;宏常量如何终止使用？
答、通过#undef A，
308、问宏常量有没有命名空间？
答、没有。namespace MySpace{
#define num 1024
}
void test(){
//cout << MySpace::NUM << endl; //错误
//int num = 100; //命名冲突
cout << num << endl;
}
这段代码错误。
309、能不能对NULL进行引用？
答、不能。
311、问引用的本质？
答、int &a=b；
int *const a=&b;
312、函数作为左值，对函数的要求？
答、函数的返回值必须是引用。
313、问预处理器能访问类的成员吗？
答、不能，所以不能在类中使用预定义的宏函数。也不能定义宏函数。
314、问预处理阶段是通过什么完成的？
答、预处理器。
315、问内联函数在什么时候会被处理？
答、在编译的时候。
316、问c++自定义类的构造函数(非拷贝构造)，问默认的拷贝构造函数还存在吗？
答、存在。
317、类的构造函数调用顺序？
答、按成员的顺序调用，最后再调用自己的。
318、问c++创建对象时的执行过程？
答、先为对象分配内存，再用构造函数来初始化。
319、问new操作符本质？
答、封装了动态分配内存的方案。
320、问Person *p=new Person[10];会调用多少个构造函数？
答、10个。
321、问delete[]操作和delete什么时候用？
答、有严格限定，当new []时，必须要用delete []，当new时，必须要用delete。
322、类的静态变量什么时候分配虚拟内存空间？
答、编译阶段，对象还没创建时。
323、编译阶段会不会分配虚拟存储空间？
答、会。
324、问静态成员函数有没有权限？
答、有。
325、问const static类成员最好在哪初始化？
答、类中。
326、单例是什么？
答、一种特殊的类的别称。
327、问单例的语法特点？
答、默认构造和拷贝构造私有；存在静态的类指针变量，并实现指向一个对象；存在静态getInstance()用来访问静态的
类指针变量。
328、如何从函数中返回对象？
答、return *this
329、问成员函数后加const修饰的是什么？
例如 void someOperatre()const{}?
答、const Person *const this。即用const修饰this又用const修饰this指向的存储空间。所以常函数内是不能改变
this所指对象的数据的。除非类的成员用mutable修饰。
330、问常对象是什么？有什么特点？
答、常对象是const修饰的对象；特点有两个：①只能调用常函数；②只能通过常对象访问(cout<<perosn.a<<endl)类的
成员，不能修改，除非类的成员用mutable修饰。
331、c++友元的种类有哪些？
答、全局友元函数、类成员友元函数、友元类。
332、设置友元机制时，友元的关键字friend使用有什么特点？
答、只在声明处开头出现。
333、友元函数如果是类的成员有this指针吗？
答、有。但没有属于要去访问的类的this指针。
334、问友元关系具有传递性吗？
答、不具有，例如类B是类A的朋友，类C是类B的朋友，但类C不一定是类A的朋友。
335、什么时候要在类的成员函数中添加this指针？
答、当有数据冲突的时候。
336、重载运算符的一个潜在要求？
答、使得重载运算符函数与运算符内在的功能相吻合。
337、问什么时候调用拷贝函数？什么时候调用赋值=函数？
答、初始化时调用的是拷贝函数，已初始化，就是调用赋值函数。
338、问重载=号赋值运算符函数有什么特点？
答、为了满足连续=号运算要求，必须返回一个对象的引用，这个对象就是this所指的对象。
同理+=、-=、*=、/=号也是如此。vector和string中遵守了这个协定。所以最好也要遵守。
339、为什么不要重载&&、||运算符？
答、因为在执行重载的&&、||函数时，不能很好地按内在的功能很好地保持一致。即可能先算了&&右边的值，
再算左边的值。
340、什么是多继承？
答、一个类有多个基类；例如class:public a,public b;
341、问子类是派生类，构造函数如何调用？
答、先调用父类构造函数，再调用对象成员构造函数，最后调用子类构造函数。
342、一般子类访问成员是什么意思？
答、通过子类的成员函数访问子类的成员。二是通过子类的对象访问成员
342、如果基类和子类存在同名的成员，问子类如何访问这个同名的成员？
答、子类的成员函数如果没有作特殊说明，访问的就是子类的成员。子类对象也是如此。除非指定作用域。
343、问什么是函数的隐藏？
答、子类如果有一个函数名与父类相同，则父类所有与该函数名相同的函数都会被隐藏，隐藏的结构是不能通过子类对
象直接访问父类的成员函数。也不能通过子类成员函数直接调用父类中被隐藏的函数。
344、面向对象编程的基本原则，试写一例？
答、对修改关闭，对扩展开放。
345、问c++中通过类对象实现封装功能，问这样做的目的是什么？
答、实现多态。
346、问如何解决多继承中出现的二义性？
答、通过作用域或virtual虚继承的方式。
347、问什么是二义性？
答、继承的基类超过一次。例如class person{};class p1:public person{};class p2:public person();
class p3:public p1,public p2{};这种就称为菱形继承。
基类person被继承超过一次。
还有一种情况就是继承的两个子类中出现了同变量的数据。造成访问冲突，这种不是菱形继承。
348、问虚继承时子类对象创建后，编译器创建的vbptr指针指向哪里？
答、vbtable（实际上是数组）。而且vbptr在子类对象中被创建。
350、问类继承时，子类对象创建后，内部所有成员有没有对所有数据按基类的类型进行区分？
答、会。并不是一视同仁。
351、问基类没有无参构造函数，但有有参构造函数，问子类要采取什么措施？
答、使用初始化参数列表。
352、问虚继承是为了解决什么问题？
答、只能解决菱形继承的二义性以及存储空间的浪费问题，不能解决非菱形继承的二义性问题。所以除了菱形继承，
其它情况不要用virtual进行虚继承。
353、问为了解决菱形继承问题，使用了虚继承，那么子类会如何初始化虚继承的基类数据成员？
答、由最后的子类初始化虚继承的基类成员数据。
354、class BigBase{
public:
BigBase(){ mParam = 0; }
void func(){ cout << "BigBase::func" << endl; }
public:
int mParam;
};
class Base1 : virtual public BigBase{};
class Base2 : virtual public BigBase{};
class Derived : public Base1, public Base2{};
问Derived类对象创建后BigBase类的成员由谁的构造函数初始化？
答、由Derived类的构造函数，而不是base1或base2初始化。
355、程序员应该如何做笔记？
答、做的笔记要保证以后查到后能编写出程序。
356、问设计模式与语法有关吗？
答、没有。
357、问c++面向对象三个基本特性有哪些？
答、数据抽象、继承、多态。
358、继承的好处？
答、扩展类的功能、类的数据、为了实现多态。
359、什么是静态多态？什么是动态多态？
答、静态多态是在编译时实现多态，函数的调用地址在编译阶段就能确定，动态多态是在运行时多态，函数的调用
地址在运行时才能确定（用虚函数、纯虚函数实现动态多态）。
360、静态多态实现方式？
答、函数重载、运算符重载。
361、问运算符重载和函数重载有什么区别？
答、运算符是对运算符进行重载，函数重载是对函数进行重载。
362、问写程序代码要考虑什么？
答、通过新增代码来扩展功能，而不是通过修改代码。
363、问基类中定义了虚函数，子类中对虚函数进行了实现，问通过基类类型的指针调用虚函数是如何工作的？
如果子类没有实现呢？
答、指向哪个对象，就调用哪个对象的虚函数实现。如果子类没有实现，调用基类虚函数。
364、问什么是向上类型转换？什么是向下类型转换？
答、子类对象向父类类型转换称为向上类型转换；把父类转换子类称为向下类型转换。
例如 Derived d；base b=d；（类derived继承了base）；
365、class base{public:func();};
class derived:public base{public:func()};
问：
derived d；
void print（base & temp）
{
temp.func();
}
print函数执行过程是怎样的，调用的是哪个func函数？
答、没有在基类中使用virtual，所以实行静态多态，调用的是base类的func，而不会去找子类func。
（联想强制类型转换）；当加virtual后，子类如果对base类的该函数重写（注意参数类型名字必须一模一样，
只是定义不一样），子类对象中的vfptr指针会指向子类编译时创建的虚函数表，但是这个虚函数表会在编译
时将该函数写成子类的，而父类的对应虚函数不会在子类中出现。运行时才会通过vfptr指针查找该表函数。
（只有虚函数才会在虚函数表中，非虚函数不在。）
366、问class base{void func（）};base a；
a占多少个字节？如果void func（）变成virtual void func（）；占几个字节
答、1个。4个。
367、问如果类中有虚函数，编译器编译这个类时有什么不同？编译这个类（包括继承）的对象时有什么不同？
答、会给当前类创建一张虚函数表(vftable)（实际上是数组）;会给对象添加vfptr指针，并指向虚函数表。
368、问变量a是指针变量；如何将a强转成函数指针？
答、(void (*)())a;
369、问虚函数实现多态会造成什么影响？
答、会造成函数调用效率降低，这也是c++比c语言效率低的原因。
370、问子类对象直接调用虚函数和非虚函数的区别？基类子针指向子类对象时调用虚函数和非虚函数的区别？
基类对象用子类对象赋值时调用虚函数和非虚函数的区别？
答、子类对象调用虚函数和非虚函数一样，没有区别，会覆盖父类的同名函数。基类子针调用虚函数是调用子类的，
调用非虚函数是？？？（需验证,结合this指针分析）。
基类对象用子类对象赋值时调用虚函数和非虚函数是一样的，都是基类，子类对象的数据会被截取，只保留基类的数据。
371、问具有纯虚函数的类能不能创建对象？
答、不能。这样的类称为抽象类。
372、问子类没有实现继承的抽象类的纯虚函数要注意什么？
答、这样的子类还是抽象类，是不能创建对象的。
373、纯虚函数的格式？
答、virtual void func（）=0;
374、问如果子类没有实现父类的纯虚函数，会造成什么后果？
答、子类不能创建对象，任旧是一个抽象类。
377、c++中接口类是什么？
答、类中的函数都是纯虚函数。
378、问如果子类中的虚函数没有写，会对程序有什么影响？
答、因为调用虚函数是通过vfptr指针，且指针必须添加，所以会降低效率。
380、问纯虚析构函数会被定义吗？纯虚析构函数和普通的虚函数有什么区别？
答、会，但必须在类外（所有函数外）。纯虚析构函数会造成类变成抽象类是不能实例化出对象的。即使它在类外也定义了。
与普通虚函数相比，唯一的不同是，纯虚析构函数必须要在类外（所有函数外）定义
381、类外有哪几种？
答、类定义的外面但在main函数外面和类定义的外面但在函数内。
382、问virtual函数在父类中已经写了，在子类中还要写该关键字吗？
答、不需要。
383、问子类隐藏父类，是如何体现隐藏作用的？
答、子类的对象直接访问父类成员，访问不了，但是可以通过作用域访问；子类中需要调用父类的数据，不能调用。
必须通过作用域。
384、问如果用基类指针指向子类对象（动态创建），基类析构函数没有设置为虚函数，
用delete释放指针，那么子类的析构函数会被调用吗？
答、不会。只会调用基类的析构函数。
385、问多态是如何分类的？
答、多态分成静态多态（通过运算符重载和函数重载的方式）和动态多态（通过虚函数的形式）。
386、动态多态必须借助指针或引用，这句话对吗？
答、对。
387、问泛型的含义？
答、与变量类型无关。
388、函数模板能自动推导类型吗？类模板呢？什么是自动推导类型？
答、函数模板能，类模板不能，自动推导类型是不指定模板的参数类型，只传递参数，函数模板会根据参数的类型，自动推导（前提是能推导）。例如
template<class T>
void mySwap(T &a,T &b)
{
}
调用：
int a;
int b;
mySwap(a,b);
mySwap<int>(a,b);
两种都可以。
389、函数模板能用typename定义模板参数类型吗？（用 typename指定一个标识符表示类型）
答、可以；template<typename T>;
390、typename除了定义模板还有其它功能吗？
答、有。
391、问template<typename T>的作用域
答、只对下面的一个函数有效。
392、类模板必须指定类型吗？
答、对。
393、模板在哪方面比较常用？
答、数据结构，STL。
394、问如何在栈中分配与字符串相同的空间存储字符串，而且不会涉及用户自己数字符串？
答、char arr[]="aaaa";
395、当某个函数模板涉及到比较时，例如排序时，比较大小int型、char型数据很容易做到，那么如果传入的是类型呢，
如何做到？
答、可以对运算符比较符号例如大于小于进行重载。
396、学c++最好要再学一个web语言，例如java或php
答、正解。
397、问模板参数可以有默认值吗？
答、可以。例如typename<class T=int>
398、问函数模板能进行自动类型转换吗？
答、不能，必须严格匹配
399、问函数模板与模板函数，哪个会被先调用（调用时类型实参与函数模板和模板函数都匹配）？
答、模板函数。但是可以通过模板参数列表指定用函数模板。例如myFunc<>(a,a)。
400、能用另一个函数模板重载原函数模板吗？
答、可以。
401、问函数模板编译机制？
答、编译器发现函数模板，首先编译一次；若含有对函数模板的调用，编译器会生成一个函数实例
（编译器偷偷为我们做了一些事）,再对这个实例进行编译（检查生成的函数是否正确）。
402、问编译器编译文件时知不知道其它文件？
答、如果没有包含，不知道。
403、问如果没有对函数模板的调用，还会生成模板函数的实例吗？
答、不会。
404、c++中标准库中的数据结构通过什么实现？
答、函数模板。
405、模板类不能自动推导类型，编程时要注意什么？
答、必须写模板参数列表；Perosn<string,int>person("aaa",10);
406、遇到有模板的程序如何分析？
答、必须要先分清是函数模板还是类模板。
407、问类模板作为父类，非模板的派生类要如何继承？为什么？
答、必须指定T的类型，不指定T的类型，派生类就不知道内存空间该分配多少，无法创建对象。
408、问派生类是模板，父类也是模板，要注意什么？
答、基类如果有有参构造函数，派生类必须用参数化列表对基类构造函数初始化；必须指定继承的父类的参数类型T，
可以用派生类的T或T1代替；例如
template<class T,class T1,typename T3>
class Derived:public Base<T3>
{}
409、问类的成员函数支不支持，类内声明，类外定义实现？
答、可以。
410、给出类外实现类的成员函数的模板的实例？
答、template<class T>
class Myvector
{
public:
Myvector(int capcity);
}
template<class T>
Myvector<T>::Myvector(int capcity)
{
}
411、问c++类模板能分文件编写吗？
答、即只在类中存放函数的声明，但是函数的定义放在另一个文件（但包含了头文件）。这种模式叫做分文件。
可是类模板是不支持分文件编译。链接器会报错。函数调用找不到具体的函数。最根本的原因是c++对模板文件
是通过独立编译和二次编译的方式。解决方案：1、常用，将类内的成员函数的模板声明和实现放在同
一文件，最好在类内实现；2、当要调用类模板时，在该文件中包含类模板头文件和cpp文件（声明的文件和调用的文件）。
412、问.hpp文件一般是什么文件？
答、文件中定义了模板的文件。
413、问在类中定义了一个普通友元函数，需要做什么处理？
答、如果不做任何处理，链接器不知道普通友元函数是不是模板的函数，所以必须要在函数标识符后添加一个<>标志，
表示友元函数是类模板的友元函数。而且要在之前添加类模板和友元函数模板的声明，这是因为链接器在处理类内
的友元函数声明时，与一般的函数声明不一样，必须严格要求模板类和函数模板提前声明。
414、问在类中定义了一个友元的模板函数，需要做什么处理？
答、不需要提前声明，按普通模式声明定义。但是注意必须在声明中包括template<class T,class TT>
415、问回调函数的两种形式？
答、函数指针、函数对象。
416、问函数对象是什么？
答、struct myShow
{
void print（）
{
cout<<endl;
}
};
myShow ab;
ab就是函数对象。
417、问__cdecl 是什么？
答、c语言的调用惯例（函数参数压栈顺序）。
418、问函数参数压栈顺序是什么？
答、默认从右向左。
419、问__stdcall是什么？
420、问匿名对象有什么用处？
答、可以向函数传递参数。
421、问
class person
{
public:
person(int a,int b)
{
this->age=a;
this->id=b;
}
public:
int age;
int id;
};
person p1;
问这个对象能不能被创建？
答、不能，因为无参构造函数没有生成，默认无参构造函数在自定义了构造函数时是不会生成的。
答、约定参数的压栈顺序，，在windows api中指定函数的压栈顺序。
420、__thiscall、__fastcall是什么？
答、同样是调用惯例，甚至可以将前两个参数压入寄存器中。
421、问在linux上默认模板参数如何使用？
答、必须在编译的时候指定-std=c++11。
422、默认模板参数的函数模板，怎样调用函数？
答、直接通过函数名调用，甚至可以不加<>。
423、问typeid在c++中是什么？
答、是操作符，不是函数。用来获得变量类型的名称。用法typeid(变量).name();
424、typeid在什么时候识别非引用类型，什么时候识别引用类型？
答、在编译时期识别非引用类型，在运行时识别引用类型。
425、问<>的作用？
答、当模板函数和函数模板都能匹配时，告诉编译器匹配函数模板。
426、
严重性 代码 说明 项目 文件 行 Suppression State
错误 C2679 二进制“<<”: 没有找到接受“std::string”类型的右操作数的运算符(或没有可接受的转换) Project2 g:\vsc++\project2\project2\源.cpp 108
错误(活动) E0349 没有与这些操作数匹配的 "<<" 运算符 Project2 g:\vsc++\Project2\Project2\源.cpp 108
问为什么错误？
答、没有找到接受“std::string”类型的右操作数的运算符，意味string头文件没有包含。
427、类内的函数一定会内联吗？
答、不一定。
428、问vs有没有分屏功能？
答、有。
429、c++中某个关键字显示错误，不能编译，可能原因是什么？
答、关键字后面所接的标识符不合法。
430、在一个类中，定义这个类的成员函数为这个类的友元函数可行吗？
答、不行，没必要，友元函数是为了访问另一个类的私有成员设计的。
431、template<class T>
class Person
{
friend std::ostream&operator<<(std::ostream &os, Person &person)
{
os << person.mAge;
return os;
}
public:
Person(int age)
{
mAge = age;
}
void showPerson()
{
cout << "Age:" << mAge << endl;
}
public:
T mAge;
};
问这种写法合理吗？
答、合理，友元函数在类中定义。
432、template<class T>
class Person
{
friend std::ostream & operator<<<>(::ostream & os, Person &person);
friend void printPerson<>(Person &person);
template<class TT>friend void lookPerson(Person &person);
public:
Person(int age);
void showPerson();
public:
T mAge;
};
//省略掉定义
问有什么错误？
答、没有对类名和函数原型进行前置声明。在类中声明的友元函数必须连同模板进行前置声明。
template<class T>class Person;
template<class T>void printPerson(Person<T>&person);
template<class T>std::ostream&operator<<(std::ostream& os, Person<T>&person);
template<class T>
class Person
{
friend std::ostream & operator<<<>(::ostream & os, Person &person);
friend void printPerson<>(Person &person);
template<class TT>friend void lookPerson(Person &person);
public:
Person(int age);
void showPerson();
public:
T mAge;
};
433、vs中""不能删除右边单引号，如何解决？
答、在""中输入空格，再删除右边。
434、问#include<string>
class Person
{
public:
int age;
string name;
};
问有什么问题？
答、string在std空间中定义；string要想有效，必须包含<iostream>
435、比较函数的函数返回值最好选择什么？
答、int型。
436、问c++中调试过程中，如何添加局部变量，得到运行过程中数据？
答、通过添加监视。
437、问iostream中有没有printf。
答、有。
438、能不能在函数中定义类。
439、问c++分文件编译的编译单元是什么？
答、文件以及文件本身扩展的文件。
440、问template<class T1=int,class T2,class T3>class Person{};问有什么错误？
答、类模板的默认参数的设置和函数模板一样，一个参数默认以后，后面的所有参数也必须默认。
441、问template<class T1=int,class T2,class T3>void print(T1 pa,T2 pb, T3 Pc){};对吗？
答、不对，模板函数不能有默认参数。
442、问类模板的默认参数能不是不同类型吗？
答、不能。template<class T1=int,class T2=double,class T3=double>class CeilDemo{}.这种用法是错误的。
443、问template<class T1,A m>class Cc{};有什么问题？
答、错误，非类型模板形参不能是对象，非类型模板形参的类型只能是对象的引用或指针。
444、问template<class T1,double a>class Cc{};有什么问题？
答、错误，非类型模板的形参不能是double类型，可以是double的引用。
445、template<class T1,A<int>m>class Cc{};问有什么问题？
答、非类型模板的形参不能是对象，可以是对象的引用或指针。这条规则对于模板形参也不例外。
446、问typeid（变量名）.name();常使用在哪？
答、和模板联合使用，用来显示模板的中变量类型。
447、问
template <class T1,int a>
class Person{
void g(){};
};
在类外定义g()时，应该如何进行？
答、template<class T1,int a>
void Person<T1,a>::g(){cout<<"class Person"<<endl;
注意两个template类型要保持一致，而且，函数定义中Person<T1,a>也要一致。
448、问template <class T1,class T2=int>
class Person{
void g(){};
};
如果定义函数
template<class T1,class T2=int>void Person<T1,T2>::g(){cout<<endl;};问有什么错误？
答、在类模板外部定义带有默认参数类型的形参时，在template的形参表中默认值应省略。
449、问int main()
{
template<class T>void h(){};
do other things;
return 0;
}
有什么错误？
答、模板的声明或定义只能在全局、命名空间或类范围内。不能在局部、函数内。
450、问int main()
{
A<2>m;
do other things;
return 0;
}
有什么错误？
答、必须指定类型。
451、问存在模板类
template<class T1,int a>class Ci
{};
const int a2=3;
Ci<int,a2>mci有什么问题？
答、没有问题，因为a2是常量。
452、问存在模板类
template<class T1,int a>class Ci
{};
int a=3;
Ci<int,a>mci有什么问题？
答、有问题，因为a是变量。
453、什么是模板的非类型形参？
答、例如template<class T,int a>class Ci{}
其中int a就是模板的非类型形参。
454、问模板的非类型形参有什么特点？
答、实参必须是一个常量表达式。可以是地址的常量表达式（地址常量），也可以是变量的常量表达式（常量）。
455、存在全局的变量int a=30;(main函数外定义)
template<class T1,int &a>class Cip{};
问Cip<int,a>mcip;有什么错误？
答、没有错误，模板的非类型形参对应的实参要求是常量表达式。
459、问int *a=&b;
*a表示什么？
答、*a表示变量b的这个存储空间。
460、问插入排序
void insertsort(int *arr, int len)
{
for (int i = 1; i < len; i++)
{
if (arr[i - 1] > arr[i])
{
int temp = arr[i];
int j = 0;
for (j = i; j > 0 && arr[j - 1] > arr[i]; j--)// arr[i] 换成temp
{
arr[j] = arr[j - 1];
}
arr[j] = temp;
}
}
}
算法有什么问题？
答、for (j = i; j > 0 && arr[j - 1] > arr[i]; j--)
{
arr[j] = arr[j - 1];
}
此句中arr[j]=arr[j-1]会覆盖调用arr[i]的值，造成arr[i]改变。应该换成temp.
461、问插入排序
void insertsort(int *arr, int len)
{
for (int i = 1; i < len; i++)
{
if (arr[i - 1] > arr[i])
{
int temp = arr[i];
int j = 0;
for (j = i; j > 0 && arr[j - 1] > arr[j]; j--)
{
arr[j] = arr[j - 1];
}
arr[j] = temp;
}
}
}
算法有什么问题？
答、插入算法的思想是外层循环从头开始遍历，内层循环从外层中的位置中向前与一个temp定值比较，并移动位置。
462、问class Person
{
public:
Person(int a, int b)
{
this->temp = a;
this->temptemp = b;
}
/*Person()
{
}*/
public:
int temp;
int temptemp;
};
class Student :public Person
{
public:
Student(int a, int b) :p1(a, b)
{
/*p1.temp = a;
p1.temptemp = b;*/
}
public:
Person p1;
};
int main()
{
Person p1(2, 3);
Student s1(2, 3);
cout << s1.p1.temp << endl;
cout << s1.p1.temptemp << endl;
system("pause");
return 0;
}
这段代码有问题吗？
答、有，应该在基类中添加默认的无参构造函数。题目情形是基类只有有参构造函数，所以默认的无参构造函数不会被编译器添加，
而子类又继承了基类，所以必须要在基类中自己定义无参构造函数。
463、问class Person
{
public:
Person(int a, int b)
{
this->temp = a;
this->temptemp = b;
}
/*Person()
{
}*/
public:
int temp;
int temptemp;
};
class Student
{
public:
Student(int a, int b) :p1(a, b)
{
/*p1.temp = a;
p1.temptemp = b;*/
}
public:
Person p1;
};
int main()
{
Person p1(2, 3);
Student s1(2, 3);
cout << s1.p1.temp << endl;
cout << s1.p1.temptemp << endl;
system("pause");
return 0;
}
这段代码有问题吗？
答、没有，这里没有继承关系，一个类中有另一个类对象做成员。
464、基类中数据是由构造函数初始化，如果子类中没有相应的初始化列表,要在基类中添加什么？
答、无参构造函数。
465、问子类的初始化列表如何即为基类分配数据，又为子类中的基类对象分配数据？
答、Student(T c, TT d,TT e) :Person(d, d), mPerson(d, e){}
466、template<typename T>
class Person
{
public:
Person(T a, T b)
{
this->a = a;
this->b = b;
}
/*Person()
{
}*/
public:
T a;
T b;
};
template<typename T, class TT>
class Student :public Person<TT>
{
public:
Student(T c, TT d,TT e) :Person(d, d), mPerson(d, e)
{
this->c = c;
this->d = d;
}
public:
T c;
TT d;
Person<TT> mPerson;
};
问为什么要加Person(d,d);
答、子类中既有基类对象，又继承基类。但是基类中没有添加无参构造函数，只有有参构造函数，所以要通过Person(d,d)为基类数据初始化。
467、c++中使用new时，如何将new出来的堆空间自动清空？
答、加上（）；例如
char *a=new char[100]();
这样new出来的空间会自动清零。
468、问如何在类中声明成员函数，但是在类外定义成员函数？
答、类内不需要加上template模板声明。在类外加上模板声明，而且必须和类的template声明相同。例如
template<typename T>
class Person
{
public:
void PrintPerson()
{
cout << a << endl;
cout << b << endl;
}
void PrintPerson1();
public:
T a;
T b;
};
template<typename T>
void Person<T>::PrintPerson1()
{
cout << typeid(a).name() << endl;
cout << typeid(b).name() << endl;
}
469、问链接器有什么作用？
答、由于c++中编译是分文件编译，所以链接器起到链接作用，将不同的文件编译后生成的.obj文件链接到一起。
470、问能在类的public域内定义一个友元函数吗？
答、经vs测试，可以。但不确定其它编译器可以。
471、问如何在类模板外定义一个友元函数？
答、需要具备三个额外的条件:类模板的前置声明;函数原型的前置的声明;在类内声明时需要在标识符后加上<>。
或需要四步：类模板的前置声明;函数原型的前置的声明;在类内声明时需要在标识符后和参数列表前加上<>;类外定义实现函数。
template<class T>class Person;
template<class T>ostream& operator<<(ostream &os, Person<T> &p1);
template<class T>
class Person
{
public:
Person(T a, T b)//定义公有成员构造函数，方便定义对象
{
this->a = a;
this->b = b;
}
//friend ostream&operator<<(ostream &os, Person & p1)//类内定义友元函数
//{
// os << p1.a << endl;
// os << p1.b << endl;
// return os;
//}
friend ostream& operator<<<>(ostream &os, Person &p1);//在类外定义运算符重载的友元函数
//friend void PrintPerson<>(Person &p1);//在类外定义全局的友元函数
//template<class T, class TT>friend void ShowPerson(Person &p1,TT a);//定义全局的模板函数，且是友元的
private:
T a;
T b;
};
template<class T>
ostream& operator<<(ostream &os, Person<T> &p1)
{
os << p1.a << endl;
os << p1.b << endl;
return os;
}
472、问如何在类模板内定义一个友元的模板函数？
答、两步；一在类模板中声明一个函数；二在类模板外定义。
template<class T>
class Person
{
public:
Person(T a, T b)//定义公有成员构造函数，方便定义对象
{
this->a = a;
this->b = b;
}
//friend ostream&operator<<(ostream &os, Person & p1)//类内定义友元函数
//{
// os << p1.a << endl;
// os << p1.b << endl;
// return os;
//}
//friend ostream& operator<<<>(ostream &os, Person &p1);//在类外定义运算符重载的友元函数
//friend void PrintPerson<>(Person &p1);//在类外定义全局的友元函数
template<class T, class TT>friend void ShowPerson(Person &p1,TT a);//定义全局的模板函数，且是友元的
private:
T a;
T b;
};
template<class T,class TT>
void ShowPerson(Person<T> &p1, TT a)
{
cout << a << endl;
printf("ShowPerson works.");
}
473、问#define MAX=10;
有什么问题？
答、不需要用=号。且不需要;号（重要）
474、问根据时间设置随机数的表达式是？
答、srand(unsigned(time(NULL)));（指定随机数生成以时间为依据）;
rand();//产生时间。
475、问快速排序的特征是什么？
答、1、每次按照同样的法则（从下标角度出发）选择一个基数；2、一次循环中包括多次小循环，小循环的目的是将所有数分成比基数大和基数小的数列；
3、小循环分成两种，一种是从左向右，找到一个比基数大的数（假设这次快速排序的目的是按照升序）；另一种是从右向左，找到一个比基数小的数；
4、每个小循环执行成功后，要将该不符合排序规律的数覆盖到相对方向的端点处，并使下标增加，让相对方向的端点向使数据范围缩小的方向移动；
5、循环体退出后，将基数放入合适的数组下标指定的位置。
476、void InsertSort(int arr[], int len)
{
int i = 0;
int j = 0;
//int temp = 0;
for (i = 1; i < len; i++)
{
int temp = arr[i];
j = i;
//if(arr[j-1]>arr[j])
//{
for ( ; j >0 && arr[j-1] > temp; j--)
{
arr[j] = arr[j-1];
}
//}
arr[j] = temp;
}
return;
}
InsertSort(arr, MAX-1);
问为什么数组的最后一个数总是无法排序？
答、因为MAX-1形参传入后，造成最后一个数据不能被访问。（注意插入排序传入的数据是MAX-1，表示下标）；MAX是数组的长度。
477、问冒泡排序算法有什么问题？
答、void BubbleSort(int arr[], int len)//升序
{
int i = 0;
int j = 0;
//设置temp变量用来交换数据
int temp;
for (i = 0; i < len; i++)
{
for (j = 0; j < len-i; j++)
{
if (arr[j] > arr[j + 1])
{
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
答、第二层for循环内，当j=len-1时若执行for语句arr[j]=arr[j+1]会造成数组越界，访问了arr[len]处的元素，而len是数组的总个数。
478、问++运算符和*运算符（间址访问）哪个优先级更高？
答、一样的，结合性从右到左；
479、问类Stuent的成员函数Person operator*(){return *PPerson;};
是如何模仿*号间指操作符的？
答、通过Student的对象s1，对s1进行间指操作，就能访问到Person对象。注意所有类成员重载函数，都是将对象与重载的运算符结合获得函数的调用。
480、问下面代码有什么不足？
Person operator*()
{
return *PPerson;
}
答、应该返回Person &;这样可以很好地运行，否则会调用拷贝构造函数，降低效率。
481、class Printer
{
public:
static Printer *Generator(const char *str = NULL)
{
if (str != NULL)
{
cout << str << endl;
PPrinter->Times++;
}
return PPrinter;
}
private:
Printer()
{
Times = 0;
}
public:
static Printer *PPrinter;
int Times;
};
Printer*Printer::PPrinter = new Printer;
问此单例程序有什么错误？
答、没有定义析构函数，释放空间。单例的所有成员都是私有的。必须定义拷贝构造函数。Generator中不应该打印。再写一个函数最好。times最好是静态的。
481、问vs总是安装不上，是什么原因？
答、不能将多版本的vs删除干净，应该进入控制面板中进行删除。
482、容器提供迭代器，算法使用容器提供的迭代器对容器的数据进行操作？
答、对。这是容器、迭代器、算法三种STL组件的关系。
482、问vector的本质？
答、动态数组。而且是单口的动态数组。
483、问数组在首部插入元素效率怎么样？
答、不高，需要移动后面所有元素。
484、容器的迭代器是指向容器的内存的，如果容器的内存重新分配，原迭代器指向的内存就失效了？
答、对。
483、问dequeue容器可以看成什么？
答、双端队列或双端数组。
482、问vector容器和其它容器的最大区别？
答、vector容器有容量capacity的性质，但是其它容器没有。意味resize只能改变数据个数，但是不能改变容量大小，容量在这里是指存放数据的内存大小。
483、问STL中的容器是函数模板还是类模板？算法呢？
答、容器都是类模板，算法都是函数模板。
484、类编写时，必须保证内部所有数据成员都有定义？
答、正确，这样才能知道分配多少内存。
485、问
#define TEST(ABC) #ABC
string abc=TEST("ABC");
std::cout<<abc<<std::endl;
结果是什么？
答."ABC"，注意不是abc
486、问就成员函数调用而言基类和派生类的角色是什么？
答、函数版本。
487、问什么是动态类型？
答、表达式或变量的内存中的对象的类型。
488、问什么是静态类型？
答、编译时的类型，变量声明时的类型或表达式生成的类型；
489、派生类的对象中含有基类对象的成分？
答、正确。
490、初始化、赋值过程都是调用类的函数？
答、正确。
491、override关键字的作用？使用位置和使用要求？
答、
①、说明派生类中的虚函数；
②、派生类、虚函数中；
492、c++primer中覆盖的含义？
答、基类指针或引用调用虚函数时，派生类的函数会覆盖掉基类。
493、c++primer中覆盖的上下文局限于虚函数？
答、正确。
494、c++primer中final的作用？
答、不允许后续的其他类覆盖f1(int);
495、问纯虚函数能不能被定义？
答、能。
496、什么是重构？
答、重构负责重新设计类的体系以便将操作和/或数据从一个类移动到另一个类中。
497、问派生类怎样访问基类中受保护的成员？
答、在派生类中，就出现的基类对象和派生类对象而言，派生类的成员和友元只能访问派生类对象中
的基类部分的受保护成员；对于普通的基类对象中的成员不具有特殊的访问权限；因为该派生类不是
基类的友元；
498、类没有写任何构造函数，什么情况下编译器也不会为类生成默认的构造函数?
答、当有类类型的成员，且这个 成员的类型没有默认构造函数。
499、问什么是默认构造函数？
答、不接受任何实参的构造函数。
500、问"Empty"字符串会被c++当做什么？
答、string临时对象。
501、常函数如果返回引用，该引用类型也应该是常引用？
答、正确。
502、内联函数不会带来任何额外的运行时开销？
答、正确。
503、问类的定义分成几步处理，是哪几部？
答、首先，编译成员的声明；直到类全部可见后才编译函数体；
504、如果一个构造函数为所有参数都提供了默认实参，则它实际上也定义了默认构造函数？
答、正确。
505、为什么类的静态数据成员只能在类内声明，在类外初始化？
答、因为类的构造函数含有this指针。
506、类的成员分成几种？
答、3种，数据、函数和类型成员；
507、问什么是c++的封装？
答、将实现部分设为private完成封装；
508、问什么是接口？
答、不包含数据成员；但是可以含有函数。
509、问拷贝构造函数定义成=delete的作用？
答、告诉编译器不要生成该拷贝构造函数。
510、问含有const成员的类，该成员不能默认构造，能使用合成的默认构造函数吗？
答、不能。
511、c++primer 5 477
关于带有引用的成员的类，赋值操作没有很好理解。
512、如何使得类定义得像指针？
答、通过shared_ptr成员。
513、内联体现调用函数和函数定义之间的关系。
514、当需要拷贝某个对象之后，该对象可以被销毁，可以考虑使用对象移动，可以提高性能。
515、什么情况下可以使用移动而不是拷贝？
答、对于IO类或unique_ptr等，都包含不能被共享的资源，因此这种类型的对象不能拷贝但是可以移动。
516、如果类包含不被共享的资源，那么可以设置这个类不能被拷贝。拷贝函数=delete;
517、c++中变量是什么？
答、表达式。
518、问move的作用？
答、告诉编译器，我们有一个左值，但我们希望像一个右值一样处理它。
519、问右值引用的作用？
答、绑定到一个将要销毁的对象。
520、问左值表达式和右值表达式表示的是什么？
答、一个对象的身份、对象的值。
521、问移动构造函数的作用？
答、窃取资源。
522、如何防止编译器会认为移动操作函数会发生异常，而做一些额外的工作？
答、在函数末尾加上noexcept；
523、问什么情况下编译器会为类合成移动构造函数或移动赋值运算符？
答、当类没有定义任何自己版本的拷贝控制成员，且类的每个非static数据成员都是可以移动的。或者
一个类的成员是类类型，且该类有对应的移动操作，编译器也能移动这个成员。
524、问函数是什么？
答、计算单元。
525、short有对应的字面值吗？
答、没有。
526、函数体内的内置类型的对象如果没有初始化，则其值未定义。
527、函数体内部，如果试图初始化一个由extern关键字标记的变量，将引发错误。
可以通过查找功能找到相关的知识点。
-------------------------------------------------------------------------------
1、c++中使用c语言的头文件要注意什么?
答、库名要加c,且不能有.h,且要加using namespace std;例如#include<cstring>。
2、int arr[10]={1,2,3,4,5,6},cout<<3[arr];这个代码能打印吗?这能说明什么？
答、可以，和cout<<arr[3]相同，本质是3[arr]会被解释成*(3+arr);arr[3]也会被解释成*(arr+3).
3、C++泛型编程的含义？
答、用c++的模板编程。
4、程序调用系统函数，这种程序的移植性是怎样的？
答、很差。
5、C++标准头文件需要加.h吗？
答、不需要。
6、C++标准头文件引入后能直接使用吗？为什么
答、不能，需要加上using namespace std；C++有为标准库存储的命令空间，std，所有标准头文件都会存储在里面，这说明c++标准头文件不是公开的，
使用时需要使用using namespace std；打开命令空间。
7、标准输出设备是什么？
答、屏幕。
8、endl的作用是什么？
答、回车换行，刷新缓冲区。它的本质是一个函数。
9、什么时候缓冲区才会刷新？
答、换行，缓冲区满了，或者强制手动刷新缓冲区。
10、c++中结构体与c语言中结构体有什么区别？
答、c++中用结构体定义变量不需要加struct，而且，可以在结构体内定义函数。
11、c++和c语言的类型转换的区别？
答、c++中要求严格的类型转换。
12、C++中三目运算符返回的是值还是内存（内存内存储了这个值）？C语言呢？
答、C++中是内存(变量本身)，C语言中是值.
14、觅食。
16、vs比较卡怎么办？
答、360深度清理。
17、如何增加程序的健壮性？
答、合理使用const。
18、C++中的const是默认static(内部链接),但是使用extern可以让其外部链接，C语言中const是extern类型(全局作用)?
答、对。
19、C++中在main函数外定义的const 变量放在什么地方？
答、常量区，一旦初始化，不能修改。
20、C++中const局部变量放在什么地方？
答、栈区，可通过地址修改。
21、
const int a=10；
int *p=(int *)&a;
*p=100;
cout<<"a="<<a<<endl;
cout <<"*p="<<*p<<endl;
问输出什么，为什么？
答、a=10;
*p=100;
因为a会被优化，直接使用a时会用10取代a；但是a变量的内存空间的值会变成100；
22、如何防止上题中的编译器进行优化？
答、用volatile const int a=10；这样打印结果是a=100；*p=100；
23、
int b=100；
const int a=b；
int *p=（int *）&a;
*p=200;
cout<<"a="<<a<<endl;
问会不会对变量a进行优化?
答、不会，打印200；而不是100；
24、const int b=100；
const int a=b；
int *p=（int *）&a;
*p=200;
cout<<"a="<<a<<endl;
问会不会对变量a进行优化?
答、会，a=100；
25、引用的优点？
答、比指针更有效率，代码更简洁，能达到指针的功能。
26、引用的本质？
答、
27、引用引入的初衷是为了什么？
答、运算符重载。
28、引用的返回要求是什么？
答、必须是合法的内存空间。如果空间返回后就释放了，会出错。
29、int doit()
{
static int a=10;
return a;
}
int main()
{
doit()=100;
return 0;
}
问有什么问题？
答、a返回的是一个字面值，显然不能作为左值。
可以改成
int &doit()
{
static int a=10;
return a;
}
int main()
{
doit()=100;
return 0;
}
30、问引用作为函数返回的时候，用一个非引用变量来接，和用一个引用变量来接所有什么区别？
答、用非引用来接，引用返回的是值，用引用来接，返回的是内存空间。
31、C++中默认参数的设置有什么要求？
答、默认参数后面的变量，也必须是默认的，例如
int func(int a,int b=0,int c);
这种定义是错误的，改为int c=0；即可。
32、函数参数顺序不同，能不能被重载？
答、可以。
33、函数的返回值类型，能不能作为重载的条件？
答、不能。
34、void func（）
{
}
void func(double a)
{
}
void func(int a）
{
}
int main()
{
func(10);
}
问函数调用什么？如果func(int a)被删掉，函数调用什么？
答、未删调用func(int a);删掉调用func(double a);
35、函数重载是怎么实现的？
答、通过编译时对函数名进行修饰来实现，区分。
36、为了让c语言编写的程序能够被c++编译器指定按照c语言的方式编译，要采用什么方式？原理是什么？为什么要这样改变？
答、使用extern "c"，原理是告诉c++编译器在extern “c”作用范围内的代码(一般是函数)要用c语言的方式编译。
原理是在对这段代码中的函数进行编译时，按照c语言的编译方式。如果没有extern “c”形式语法，会按照c++的方式编译函数例如 int ptr(int a）；
ptr会被编译修饰成ptr_int。这是因为c++是支持函数重载，必须这样编译。而c语言不会。所以c++编译后的函数名找不到本该由c语言定义的函数名。
总的来说，最主要的原因是c语言不支持函数重载，c++支持函数重载，它们对函数的编译和查找链接函数是不一样的。
注意到底是按什么方式编译通常是由文件名决定，例如.c或.cpp。
37、const int constA = 10;
int *p = (int *)&constA;
*p = 300;
cout << "\n%d\n" << constA << endl;
cout << "%d\n" << *p << endl;
问，在c++中会优化吗？加const变量优化的含义，如果const int constA=10在函数外也会优化吗？如果不想const修饰的变量constA被优化，可以怎么做？
答、会，输出结果是10,300；这个在c语言中是相同的，而且改变cout为printf输出结果也是相同的，如果在函数外就不存在优不优化问题，因为默认变量存储在只读常量区，
是不能修改变量的值的。而且变量在只读数据段有对应的存储空间。只是它是写保护的。如果不想constA
38、const int constA = 10;
int main(){
int* p = (int*)&constA;
*p = 200;
}
问这段代码能不能在c++中编译通过？能运行吗？
答、可以编译通过，但是不能运行。运行提示错误：引发了异常: 写入访问权限冲突。这个现象与c语言中相同。
39、volatile什么含义？
答、不稳定的。
40、如何不让const修饰的变量发生编译器优化现象？
答、在const前面加volatile。
41、说说const编译器优化？
答、①、const修饰的变量，是局部变量，初始赋值时是一个字面值例如 const int a=19；或一个非常量变量，
例如 int b=20；const int a=b；如果使用指针改变其内存空间的数据，当直接使用变量名时，会将变量名替
换成const初始化的值。而不是改变后的值。
②、const修饰的变量，是局部变量，初始赋值时是一个常量例如 const int b=20；const int a=b；则编译器会优化。
③、加volatile，编译器不会发生优化。
42、注意c++是对c语言扩展以及改进的好处？
答、按照这个思想，要对与c中有相同的语法的细节性属性进行思考，注意这些语法的功能往往比c语言更加人性化，更合理。
注意词语：增强、兼容c、拓展、实现c不能实现的、严格。
43、06 请说出以下代码是否会发生编译错误，如果发生是哪一行代码会发生？并说明原因
int add(int a,int b)
{
return a + b;
}
double add(double a,double b)
{
return a + b;
}
void test()
{
int a = 10;
int b = 20;
double c = 7.5;
double d = 9.2;
cout << add(a, b) << endl;
cout << add(c, d) << endl;
cout << add(a, c) << endl;
}
答、cout << add(a, c) << endl;会报错，因为没有对应的重载函数
问这种表述正确吗？
答、不正确，因为不能正常工作的原因是存在多个版本的函数都能匹配函数调用。如果把第一个add函数
int add(int a,int b)的定义删除，发现都可以编译。int 和double之间可以转换的。
44、05 请描述内联函数的作用?以及内联函数和宏函数的区别？
答、预处理时宏函数虽然可以在调用函数时直接找到函数的定义，提高效率，但是宏函数会带来难以发现的错误，而且c++中的类成员，是不允许使用宏函数。
为了即能达到宏函数的功能，又可以避免宏函数的缺点，c++中引入了内联函数，内联函数没有函数调用时开销，内联函数可以像普通函数那样，进行参数、
返回值类型的安全检查，而且可以作为成员函数。
问哪里有错？
答、"预处理时宏函数虽然可以在调用函数时直接找到函数的定义"这种描述是不正确的，应该是在预处理阶段函数体替换到函数调用的地方。
45、在C++中，关于下列函数参数的描述中，（ ）是正确的。 (得分 0/ 20分)
A 、 C++语言中，实参是按照自左至右的顺序求值的；
B 、 若一个参数设置了默认值，则其右边的所有参数都应该具有默认值；
C 、 函数参数的默认值不允许是表达式；
D 、 设置参数默认值时，应该全部参数都设置；
问选什么？
答、B，注意函数参数的默认值可以允许是表达式。注意1+3也是表达式。
46、内联函数的内联对编译器来说，只是一个建议，编译器在什么情况下不会将函数进行内联编译？
答、1、不能存在任何形式的循环语句、不能存在过多的条件判断语句、函数体不能过于庞大、不能对函数进行取址操作。
47、struct 和 class有什么区别？
答、①、struct 中不指定成员类型，默认是public，class中默认是private。②、struct中不加继承权限控制时，默认是公有继承，class中默认是private继承。
48、int &&n=3；int &&n=a；问那个可以编译运行成功？
答、int &&n=3可以，但是int &&n=a不可以。
49、问sizeof(e)的大小是什么？
答、引用的变量的大小。
50、问const和#define之间的区别是什么？
答、两个方面1、const 有类型，编译器必须要对其进行安全检查；而#define无类型，不会对其进行安全检查。2、#define的作用域，
默认从定义处到文件结尾，或到宏卸载指令处(而const是有作用域的概念的，如果定义的常量有作用域的要求，#define就不可以使用。
51、如何提高结构体、类的数据的封装性？
答、可以通过函数返回成员数据。避免用户直接使用变量名，若以后数据有修改，改动麻烦。
52、接口最好放在什么文件？
答、头文件。
53、封装的特点？
答、将数据和函数封装在一起；对封装的成员进行访问控制。
54、类的成员权限是怎么区分的？
答、在类的内部，成员没有public、private、protected权限之分；在类的外部才会严格区分权限，即对象会有访问权限设定。
55、类的成员访问权限设计到几个主体？
答、类、子类、对象三个。
56、private权限是什么概念？
答、只能由该类访问，子类和对象都不能访问。
57、protected权限是什么概念？
答、只能由该类和子类访问。
58、public权限是什么概念？
答、可以有本类、子类、对象访问。
59、对象的本质是什么？
答、类数据类型的变量。
60、标识命名的潜在规定（潜规则）？
答、m_name、G_a、P_a;分别标识成员、全局、指针变量。
61、问std在c++什么文件中？
答、std在c++系统文件iostream中。
62、为什么类对象初始化和销毁要提供构造函数和析构函数？？？？
答、因为类对象中存在函数，函数的调用与数据不同，会用到堆栈，所以要引入构造函数和析构函数。
63、简述类对象创建和销毁的过程？
答、对象创建时，先分配内存，再调用构造函数；对象销毁时，先调用析构函数再归还内存。
64、析构函数返回值可以是void吗？
答、不可以。析构函数也没有返回值。
65、析构函数的参数可以设置吗？
答、不可以。
66、构造函数被调用了意味什么？
答、对象一定会产生，对象的内存一定被分配了。一定有一个新的对象产生。
67、一个对象能调用多个构造函数吗？
答、不能。
68、构造函数和析构函数能被重载吗？
答、构造函数可以，析构函数不可以。
69、什么情况下必须要写类的析构函数？
答、只要类的内部使用了指针，而且指针指向了堆内存空间，就必须要写析构函数，并在析构函数中释放堆内存。
70、无参构造函数可称为什么？
答、默认构造函数。
71、有参构造函数可以使用默认构造函数吗？
答、可以。
72、拷贝构造函数的模板是怎样的？拷贝构造函数的参数必须是引用吗，可以是指针吗？
答、Person(const Person &person)
{
}
必须是引用，不能是指针。
73、问
Person person1=Person(10,20);这种写法对吗？
答、对为对象赋值。调用拷贝构造函数
74、问Person person05=10;等价于什么？
答、Person person05=Person（10）；注意必须要有与参数类型对应的构造函数。
75、c++头文件<string>中的string是什么？
答、类。
76、类对象如何是匿名的，它有什么特点？如何创建？
答、匿名对象只活在当前行。直接写构造函数就会创建匿名对象。
77、问Person person01；
Person(person01);会报错吗？？？？
答、会，因为第二句不是产生匿名对象，而是创建对象person01，所以会报错。
78、构造函数必须是公有的吗？
答、对。如果是私有的，是不能在类外访问的。所以如果是struct定义类，默认是public，不需要加，如果是class必须要加public。才能写构造函数。
79、问Person p=person；
和Person p；
p=person;有什么区别？
答、第一句是调用拷贝构造函数创建对象；第二句是赋值行为，对象已经创建好了，但等号不是以拷贝的方式赋值，
而是等号赋值的方式。
80、Person CreatePerson()
{
Person person;
cout<<"person:"<<(int)&person<<endl;
return person;
}
void test()
{
Person p=CreatePerson();
}
问这段代码用debug模式和releas(发行)模式编译有什么区别？
答、debug模式会调用拷贝构造函数，p和函数返回的对象是不一样的，拷贝过后，就会释放返回的对象、
release模式不会调用拷贝构造函数，p和函数返回的对象是一样的。
81、编译器优化是什么含义？
答、编译器编译的时候会修改用户代码，进行优化。
82、构造函数如果没写，会不会有构造函数？
答、有，编译器会自动添加。
83、c++编译器至少会默认添加几个函数？
答、默认构造函数、析构函数、拷贝构造函数、赋值函数。但是如果手动添加了拷贝构造函数，编译器就不会
提供默认无参构造函数，也不会提供默认拷贝函数。
如果手添加了非拷贝构造函数，编译器也不会提供默认无参构造函数，但是会提供拷贝构造函数。
84、默认的构造函数特点？默认的析构函数特点？默认的拷贝构造函数的特点？
答、构造和析构什么也不做，但是拷贝构造函数只会进行简单值拷贝(如果有变量指向堆空间，堆空间不拷贝，
会造成浅拷贝问题）。
85、如果类内有堆空间申请，要注意什么？
答、析构函数必须有，且要通过析构函数释放堆空间。
86、默认的类拷贝构造函数是简单的值拷贝，为了解决浅拷贝和深拷贝问题，要如何解决？
答、手动编写深拷贝构造函数。
87、编写类类型的技巧？
答、只要类中出现指针变量，并且指向堆空间，就手动编写析构函数释放堆空间，和拷贝构造函数。
88、类RichPerosn，内有定义类成员bus、car，问定义类RichPrson对象时，构造函数和析构函数是怎样的
(注意此时默认调用对象无参构造函数，不存在有参构造函数)？
答、先调用对象成员bus、car的构造函数，再调用对象RichPerson的构造函数，析构函数与构造函数相反。
89、如果上述bus类定义了有参构造函数，不做处理会不会报错？如何处理？
答、会。在RichPerson类的构造函数编写初始化列表。没有初始化列表，成员类对象调用无参构造函数，如果没有就报错。
90、在c++中int 类型、double类型是不是类？
答、是，可以通过int a（10）;double b(23.3)初始化变量。
91、异常的作用？
答、最明显的一点是异常返回的类型比较丰富，如果一个函数需要返回指针类型或int 类型，但是函数返回值是一种类型，
使用异常机制就可以返回这两种类型。
92、问为什么内联函数不能进行异常接口声明？
答、因为异常中异常会往上一个函数抛、如果没有处理还会往再上一个函数抛，如果进行内联，就会影响异常接口的效率。
93、
class A
{
public:
A(int a,int b):_b(b),_a(_b)
{}
void show()
{
cout << "a = " << this->_a << " b = " << this->_b << endl;
}
private:
int _a;
int _b;
};
int main(void)
{
A a(3, 4);
a.show();
return 0;
}则输出结果正确的是（ C ）。
(20分)
A 、 a = 4 b = 4
B 、 a = 3 b = 4
C 、 a的结果为随机值，b = 4
D 、 a 和 b 的结果都为随机值
94、
错误 C2679 二进制“<<”: 没有找到接受“std::string”类型的右操作数的运算符(或没有可接受的转换) CheckTest g:\vscode\checktest\checktest\test.cpp 156
问什么原因？
答、没有包含string的系统文件。反而错误地使用了string.h文件。
95、已知Person是一个类,person1是其一个对象，问Person person=person1有没有调用拷贝函数？
答、有调用。可能是默认的（没写的情况下，编译器自动添加），可能是自定义的拷贝构造函数(程序有写)
96、class RichPerson//定义富人类
{
public:
RichPerson(int a, int b) : mBus(b),mCar(a)
{
cout << "RichPerson构造函数" << endl;
}
RichPerson() :mCar(0), mBus(0)
{
cout << "RichPerson 构造函数" << endl;
}
~RichPerson()
{
cout << "RichPerson析构函数" << endl;
}
public:
Bus mBus;
Car mCar;
};
问，RichPerson person(10, 20);构造函数构造过程，析构函数析构过程是怎样的？
答、构造函数先根据public:中成员顺序，即先Bus、后Car确定初始化对象的顺序，再根据构造函数初始化列表进行初始化过程。
析构函数调用顺序是构造函数的逆顺序。
97、什么回调函数？
答、一个函数的参数是函数，这个函数就称为回调函数。
98、vs可不可以设置每次编译时的虚拟地址相同？
答、可以。
99、数据结构的本质是什么？
答、数据间关系的框架。
100、void *称为什么指针？
答、泛型指针。
101、命名空间的作用？
答、主要是防止重名问题。
102、const在c语言和c++中常用用法是什么？
答、在c语言中配合指针作为函数的参数；在c++中配合引用作为函数的参数。
103、const在c++中使用会优化，该功能与define很类似，那么有什么好处？
答、可以进行类型检查，但是define是在预编译时处理，不会进行类型检查。
104、内联函数和宏函数在什么时候调用展开？
答、内联函数是在编译阶段；宏函数是在预处理阶段。
105、c++编译器能自动释放堆内存空间吗？
答、不能。必须手动释放。
106、如果类中有成员指向堆空间，要注意什么？
答、拷贝构造必须手写，赋值构造必须手写，析构函数必须手写，且要考虑堆空间。
107、explicit关键字只能用在什么地方？
答、构造函数。
108、析构函数能不能手动调用？
答、不能。但是构造函数可以。
109、动态对象是什么？
答、在堆中分配对象。
110、用malloc系列函数分配动态对象有什么缺点？如何解决？
答、需要手动调用构造函数，而且成员也不会自动调用构造函数。可以用new功能代替malloc功能，
new关键字分配的动态对象会由编译器代替我们做很多事，包括避免malloc分配的缺点。
111、问malloc创建的动态对象，能不能用delete释放？
答、不一定可以运行。但是编译可以通过。如果涉及到指针，malloc的对象有指针成员分配堆空间，就不能用delete。
因为delete会自动调用析构函数，如果没有申请堆空间(malloc申请对象，需要自己设置构造函数)，delete就会执行失败。
112、用new创建的对象有什么特点？
答、分配了内存，并进行了初始化。
113、student *stud=new student[10];
student stu(100);
stud[0]=stu;
问第三句使用了拷贝构造函数还是赋值构造函数？
答、赋值构造函数。
114、void *p=new stduent;
delete p;
问能够执行析构函数吗？
答、不会，delete根据指针类型执行，p的类型是void *，所以析构函数不会执行。
115、问类的静态成员变量和非静态成员变量的区别？
答、静态成员变量是类所有对象公有的。
116、c、c++写的程序和java程序哪个保密性更强？
答、c、c++。
117、生成解决方案错误的分类？
答、编译器、链接器、预编译器
118、class person
{
public:
int mA;
static int sB;
}
问有什么问题？
答、类的静态成员变量必须在类内声明，在类外定义(可不初始化)。可改为
class person
{
public:
int mA;
static int sB;
}
int person:: sB=100;
119、静态成员变量两种访问方式？
答、对象，或类名加::
120、静态成员函数的作用？
答、为了封装静态成员变量(访问、赋值)等，但是不能访问非静态成员变量(因为没有this指针)。
121、非静态成员函数能访问静态成员变量吗？
答、可以。
122、类的静态成员变量一般在哪初始化最好？
答、在类外，类内只声明。
123、类中的静态成员变量如果加上了const修饰(在只读区存放),应该在哪初始化最好？
答、类中，声明的时候就初始化。
124、通过定义函数指针类型，比直接定义函数指针有什么优势？
答、效率更高。
125、为什么有时候需要使得一个类只能实例化一个对象？如何实现？
答、例如点击窗口，希望每次点击都是同一个窗口（任务栏管理器、垃圾箱等），因为c++是一切皆对象，而对象又是类的实例，
所以必须通过限制类的方式实现这种需求，可以通过static实现。
126、能不能用malloc创建对象？
答、可以，比较麻烦。
127、构造函数私有能直接创建对象吗?
答、不能。
128、
class config
{
private:
config(){}
public:
static config *pconfig;
};
config *config::pconfig=new config;
问语法有什么问题？
答、没有问题，规定在main函数外依然属于类的内部。该代码可以保证一个类创建一个对象。如何优化代码。
129、调用静态函数需要使用对象调用吗？
答、不需要。
130、单例有什么好处？
答、限制类创建对象的个数。
131、单例程序为什么不能用new一个对象？
答、因为构造函数、拷贝函数是私有的。本质是通过语法限制，实现了一个功能，就是一个类只保证创建一个对象。
(这个对象实际上在main函数外已经被创建).
132、类的对象包括什么数据？
答、只包含非静态成员变量，即函数(无论静态还是非静态)、静态成员变量都不在对象的空间中。
133、
class person
{
void show()
{
cout<<"mA:"<<mA<<endl;
}
int mA;
}
问编译器执行show函数时要怎么做？
答、person p1；
p1.show();编译器会进行优化，将this指针的运行机制添加进去。
134、问const person p1;的含义？
答、p1内存储空间的数据不能改变。
135、
class Student
{
public:
Student()
{
mA=0;
}
void func()//const
{
//this->mA=100;
mC=100;
}
public:
int mA;
int mB;
mutable int mC;
}
void test02()
{
const Student stduent;
student.func();
}
问会不会报错？
答、会。因为student对象不能调用一个非const函数。可以改为void func()const;其中const修饰this指针
指向的内存空间。但是this指针不占大小。
136、
Teacher *teacher=NULL;
问
sizeof(Teacher）大小是多少？
答、1.
137、
class student
{
public:
void func()
{
cout<<"hello world"<<endl;
}
}
问
student *s1=NULL；
s1->func();
能不能执行？
答、可以，执行过程会优化成func(s1)，即this指针的值是s1的值，但是func中没有使用到对this的访问，所以任旧可以
调用这个函数，但是如果cout<<"hello world!"<<mA<<endl;却不能执行，因为会优化成this->mA,但是this的值是0.
所以一般要在函数中添加判断this指针是否为空的语句。if(NULL==this){return;};
138、
class Person{
public:
Person(char* name, int age){
pName = (char*)malloc(strlen(name));
strcpy(pName,name);
mAge = age;
}
~Person(){
if (pName != NULL){
delete pName;
}
}
public:
char* pName;
int mAge;
};
void test(){
void* person = new Person("john",20);
delete person;
}
问有什么问题？
答、待验证,不能delete成功，因为delete根据person的类型来释放，可以通过强制类型转换将person变成(Person *)person.
139、问题：malloc、free和new、delete可以混搭使用吗？也就是说malloc分配的内存，可以调用delete吗？通过new创建的对象，可以调用free来释放吗？
答、可以，可以。
140、问person *p1=new person；
delete []person,
有什么问题？
答、new时没有使用[]，delete时也不应使用。
141、静态变量在什么时候分配存储空间？
答、在对象创建以前就分配存储空间。
142、什么是类外？什么是类外不能访问？
答、类外是main函数等函数以外，类定义以后的空间，类外不能访问是即使使用类名作用域也不能访问。
143、单例的本质是什么？
答、特殊的类。
144、class Printer
{
private:
static Printer *pPrinter;
}
Printer *Printer::pPrinter=new Printer;
问该指针指向的对象有什么特点？
答、在main函数执行之前就被创建。
145、问每一个非内联成员函数(non-inline member function)只会诞生一份函数实例.的含义？
答、类中的所有成员函数都是以内联的方式。那么static修饰的函数也是内联吗？
146、c++类对象中的变量和函数的存储特点？
答、分开存储。
147、什么是非内联成员函数？
答、
148、常对象可调用非const成员函数吗？常对象还有什么特点？
答、不能。可以访问const或非const数据成员，但是不能修改，除非成员用mutable修饰。
149、问explicit的作用？
答、class MString
{
public:
explicit MString(int n)
{
cout<<"kkk"<<endl;
}
}
int main()
{
MString str1=1;//因为有explicit使得这种用法不能执行
MString str1(1);
}
150、QT常用快捷键有哪些？
答、F1 查看帮助
F2 跳转到函数定义（和Ctrl+鼠标左键一样的效果）
Shift+F2 声明和定义之间切换
F4 头文件和源文件之间切换
Ctrl+1 欢迎模式
Ctrl+2 编辑模式
Ctrl+3 调试模式
Ctrl+4 项目设置模式
Ctrl+5 帮助模式
Ctrl+6 输出模式
Alt+0 显示或者隐藏侧边条，编辑模式下起作用（有时写的函数太长，屏幕不够大，就用这个）
Ctrl+Space 自动补全（貌似会和输入法的切换冲突）
ESc 切换到编辑模式
Alt+1 创建细节窗口
Alt+2 搜索结果窗口
Alt+3 程序输出窗口
Alt+4 编译输出窗口
Ctrl+B 编译工程
Ctrl+R 运行工程
Ctrl+I 自动对齐
Ctrl+/ 注释行，取消注释行
Ctrl+Shift+< 折叠代码块
Ctrl+Shift+> 展开代码块
Ctrl+[ 跳到代码块的头部
Ctrl+] 跳到代码块的尾部
Ctrl+L 跳到某一行
Ctrl+F 查找替换当前选中的内容，按下Ctrl+F，会列出所有和你选的内容一样的语句
Ctrl+Shift+F 查找内容
F5 开始调试
Shift+F5 停止调试
F9 设置和取消断点
F10 单步前进
F11 单步进入函数
Shift + F11 单步跳出函数
151、静态对象的特点？
答、首先必须在类定义完全以后才会被定义。
152、单例模式中为什么类的静态成员指针指向的对象不能在类中被初始化，而是在类中有声明，在类外被定义？
答、因为在类中被初始化指向对象时，该类还没有被定义完全。
153、问要不要关心单例对象的释放问题？
答、不需要。
154、问int a=10;int &b=a;
cout<<&b<<endl;
cout<<&a<<endl;
打印结果是否相同？
答、相同。
155、下列关于this指针说法中，错误的是（ ）。(20分)
A 、 this指针在成员函数开始执行前创建，在成员的执行结束后清除，生命周期与函数参数相同。
B 、 this指针是通过函数参数的首参数来传递的，它代表当前对象的地址。
C 、 this可以在成员函数定义后，也可以在全局函数和静态函数中使用。
D 、 当一个对象创建后，整个程序运行期间只能有一个this指针。
答、C。
156、写出常成员函数的定义
答、void print()const;
157、静态数据成员只能在类的外部进行初始化？
答、是，在类中声明。
158、什么时候this指针被创建？
答、当一个对象被创建后。
159、问double *a=new double();
问这种写法对不对？
答、对。在c++中所有基本类型都是类，所以此处相当于调用了无参的构造函数，创建对象，并用指针指向它。
160、问饿汉式单例和懒汉式单例哪个好？
答、饿汉式(首先创建指针指向的对象）；懒汉式是线程不安全的。要在静态成员函数中初始化指针指向对象。
161、问单例的三个条件?
答、1、私有化构造、析构、拷贝；2、公有静态成员函数；3、私有静态指针成员(对象在类定义外，
main函数外被创建(饿汉式);对象在公有静态成员函数（懒汉式）；
162、 Person person3[]={Person("John",20),Person("Smith",22)};
这是什么形式？
答、这是在栈上用"聚合初始化"的方式初始化数组。注意在堆上用指针创建对象数组，并用聚合初始化的方式初始化
对不同的编译器而言是不一定能通过的。
163、cout<<"Person::sOther"<<Personx::sOther<<endl;
问如果sOther是静态成员变量，且是私有成员，能够在main函数中调用吗？
答、不能。
164、静态成员变量在c++中一般被用来做什么？
答、单例设计。
165、友元的作用？
答、在类外(main函数中,另一个类的对象)访问类内的私有成员。
166、c++中封装string类的头文件在哪？
答、#include<string>.
167、友元类的作用？
答、①、在友元类的函数中定义另一个对象，并在函数中通过这个对象访问其成员；
②、在友元类中定义另一个类的对象作为这个友元类的私有成员。
168、前置声明的作用？
答、提醒编译该声明位置后的所有代码都能看到声明，不会报错。
169、为了使得类内的友元函数内定义的类对象能够访问对象的成员，要注意什么？
答、只在类内部实现声明；但是定义放在类定义的外面，特别要注意该函数的定义内的所有数据必须都被定义。
170、问pa.operator+(pb)这种类型是什么函数？operator+(pa,pb)是什么类型函数？
答、前者是成员函数，后者是全局函数。
171、重载运算符两种类型？
答、全局函数、成员函数。
172、问pa+pb是如何经过编译器处理的？
答、先去类内部找operator+函数，如果成员函数没有，会去全局函数范围内找operator+。
173、问括号能不能重载？惊叹号能不能重载？
答、能。能。
174、问运算符重载本质是什么？
答、为了语法上的方便，本质是另一种函数调用的方式。还是函数。
175、Person operator-(Person &p1)
{
Person newperson(this->mA - p1.mA, this->mB - p1.mB);
return newperson;
}
问函数内创建了新对象，为什么函数参数还是引用？
答、为了提高效率，直接拷贝对象值会降低效率。
176、问匿名对象能不能作为左值？
答、不能，因为找不到地址，不知道存放在哪。
177、Person operator-(Person &p1,Student &s1)
{
Person newperson(p1.mA - s1.mAge, p1.mB - s1.mAge);
return newperson;
}
Person ret = p1-s1-s1;
问，p1-s1在什么地方？
答、p1-s1是匿名对象，有存储空间但是找不到地址，所以不能当左值。
178、c++中cout是什么？
答、ostream类的对象名。
179、ostream对象能被拷贝吗?
答、不能。所以
void operator<<(ostream &os,Person &person);第一个参数不能去掉&。如果需要返回值不能是void，
最好是ostream &。
180、为什么cout<<a<<"abcd"<<endl;能够运行？
答、cout是ostream类的对象，cout<<a首先执行，是调用了系统文件ostream类中的成员函数operator<<；
181、cin是什么？
答、istream类的对象。
182、输出是<<还是>>，输入是<<还是>>？
答、输出是<<;输入是>>
183、如何使重载运算符函数访问类的私有成员？
答、声明该重载运算符函数为友元函数。
184、重载运算函数的特点？
答、operator@作为函数的标识符，其中@为按规定的运算符。cout是ostream类的对象，一般用对象调用成员
使用对象名加.号形式，但是重载运算符函数不一样，通过对象名直接加上运算符再加上实参就能调用。而普
通函数是a.func(b);重载运算符函数是a+b;
185、重载等于号运算符函数要注意什么？
答、要注意深拷贝和浅拷贝问题。否则可能造成内存泄漏和内存释放异常。
186、引用作为函数返回参数的情况下，能进行参数合法性判断吗？
答、不能。只能返回引用，不能返回NULL等用来进行参数合法性判断的数据。但是可以用异常判断。
187、void print(int &a);
print(100);
问有没有错误？
答、有，int &a必须引用一个存储空间的数据，所以100作为右值不能引用。可以改成
void print(const int &a);
188、友元函数有私有或公有性质吗？
答、友元函数不属于函数中涉及到的类的函数，可能是类的成员函
数。
189、友元函数或友元类在什么地方被声明？
答、在要通过函数或类访问的类中被声明，即友元函数中出现的类。
190、解释重载[]运算符的函数 int &operator[](int index);arr[3]的运行方式？其中arr是对象。
答、首先arr是对象，该函数是类的成员函数，3会传递给index，其中[]指示要调用重载[]函数。
191、在分析友元函数时要先注意什么？
答、友元函数是全局函数，还是成员函数。
192、class Building;
//友元类
class MyFriend{
public:
//友元成员函数
void LookAtBedRoom(Building& building);
void PlayInBedRoom(Building& building);
};
问class Building是什么？
答、前置声明。
193、前置加加和后置加加的区别是什么？
答、前置加加是++号在前面；后置加加是++号在后面。
194、问operator++（）
{};
operator++(int)
{
};
哪个是前置加加，哪个是后置加加？
答、第一个是前置加加++a，后一个是后置加加a++;
195、vim中如何快速移动光标到行首？
答、shift+^;
196、vim中如何从光标处剪切指定行数的数据？剪切后如何复制？
答、d3；然后按enter键或d键，剪切后按小写p可复制。
197、vim如何往回缩进多行代码？
答、命令行模式下，shift+v选择行，可以按下键选择下面的多行，然后按=号进行往回缩进。按shift >向右缩进。
198、deprecated？
答、不赞成的。
199、=操作符的结合性是怎样的？
答、从右到左，即a=b=c，先算b=c，再算a=b.
200、问linux关机命令？
答、shutdown -h now。
201、运算符重载一般在什么地方比较常见？
答、库。
202、多继承经常被使用吗？
答、不会。
203、运算符重载时()运算符的作用是什么？
答、例如person是类，p1是类的对象，则p1()并不表示函数，而是调用了运算符()的重载函数。可以作为回调函数。
204、哪些运算符只能通过成员函数重载？
答、=、（）、[]、->
205、内联函数编译的时候就能确定函数的定义，而非内联函数编译时只存储了要调用的函数的地址。所以效率较低。
答、对。
206、函数对象本质是什么？（重载括号运算符），效率怎么样？在哪里应用广泛
？
答、是一个类对象，效率比非内联函数高，在STL中引用广泛。
207、友元功能产生的原因？
答、在类外访问类的私有成员。
208、问operator++（）；和operator++（int）的区别，以及int的作用？
答、前者是前置加加，函数返回类名引用，后者是后置加加，返回是一个类类型，int是为了方便编译器区分是前置加加
还是后置加加。
209、标识符命名技巧？
答、重复，例如testtest
210、匿名对象又叫什么？
答、临时对象、一般会被当成右值，生命周期只存活在当前行的值都被视为右值。
211、gcc中匿名对象如何被处理？
答、会被当做右值，但在vs中会被当做既有左值、又有右值。
212、在gcc中为了引用匿名对象，要做如何处理？
答、通过添加const，例如const person p1=person(10);就不会报错。
213、靠程序员自觉减少错误，这是最不好的解决方案？
答、对。
214、已知类SmartPoint中有：public:Person* operator->(){return pPerson;}
public:Person* pPerson;
main函数中
SmartPointer pointer(new Person(100));
问pointer->PrintPerson();如何执行？
答、先调用->重载函数，然后pointer->返回pPerson，但是编译器会对该语句优化，变成pPerson->PrintPerson();
总的来说，pointer->PrintPerson()会被优化成pointer->->PrintPerson();只是为了保证一致性，程序员不需要
手动再添加->。
215、如何把对象转换成bool类型？
答、person 类中：operator bool（）{};
main函数中，bool flag=p1；p1是person的对象，同理可以定义int型，再同理可以定义另一个类类型的重载函数
(即通过该方式可以进行隐式类型的转换)。编译器遇到bool flag=p1时，先看p1的类型是一个类，但是要转换为bool，
于是去类中找有没有隐式类型转换的函数(找有没有operator bool类型函数)，
发现有，就调用并返回。
216、c++中只是重载运算符吗？
答、不是，还能重载类类型，包括基本类型。
217、什么操作符在基类被重载
218、为什么等号只能在成员函数中进行重载？为什么中括号[]必须在成员函数中进行重载？
答、类中有默认的等号赋值，如果在全局函数中重载等号运算符，会引起歧义，而且使用类中的等号运算符函数。
而[]使用时默认需要一个对象，所以规定必须在类中重载[]。
219、if (complex1 && (complex1 += complex2)){
cout << "真!" << endl;
}
&&及+=已经被重载。
问程序执行顺序？
答、先执行complex1+=complex2;再从左到右执行，这样破坏了complex1的数据，也不符合本来&&从左到右的执行顺序。
所以不建议使用&&重载，类似||也不建议重载。
220、问a&&（a=b）;执行顺序，并与219比较？
221、问c++中：void print(char *str){};
执行print（“abcde”）;会出现string类型和char *类型不兼容，如何解决？
答、改为void print(const char *str);（重要）。
222、问strcpy是否会将'\0'拷贝到目的字符串？
答、会。
223、如果类中有字符串成员，对赋值号重载时，要注意什么？
答、先将原字符串空间释放，并清空，然后按照赋值的功能拷贝。
224、问strcat会不会自动在末尾一行添加'\0'?如果两个要被处理的字符数组都没有'\0'结尾？如果最后一个字符串有'\0'会不会自动添加(还是说会被追加)?
225、char buf[1024]={0};
cin>>buf;
问要不要担心从屏幕输入的数据超过buf缓冲区的大小？
答、不需要，理由一从屏幕输入的数据也会存入一个缓冲区，这个缓冲区满了以后，就会自动把数据输入到buf，
剩下的数据会继续存入系统的缓冲区。但是buf中已经有了数据，而且buf未溢出(一般屏幕输入的缓冲是不会超过1024的）
，而接下来的手动输入的数据一旦超过系统的缓冲区会被丢弃，未超过会留在缓冲区。
理由二手动输入超过1024个字节一般不会出现这种情况。
226、问cin>>buf,能够手动输入空格到buf缓冲区吗？如何解决？
答、不能。可以通过cin.getline(buf,1024)，将空格输入进去。
227、公司的源代码比较多，怎么办？
答、先熟悉与工作相关的接口。
228、友元、继承、重载、类中定义其它类的对象、类中私有、类中公有、类中保护的本质？
答、从数据的访问权限和操作数据的方式两个角度细化出来的概念。
229、给出protected权限的使用实例。
230、多继承都可以用单继承代替？
答、对。
231、某个类的私有成员，能够被其它类继承吗？
答、能。但是子类不能访问。即这个私有成员是其它类的成员，但不能说是私有成员，而是不能直接访问（编译器禁止访问），但是一定存在。可以通过指针偏移访问。
232、如何查看类的成员？
答、看视频，找答案。需要借助开发工具。C:\ProgramData\Microsoft\Windows\Start Menu\Programs\Visual Studio 2015\Visual Studio Tools
233、如果子类通过公有继承方式继承基类，问基类中的成员在子类中的访问权限是怎样的？
234、如果子类通过私有继承方式继承基类，问基类中的成员在子类中的访问权限是怎样的？
235、如果子类通过保护继承方式继承基类，问基类中的成员在子类中的访问权限是怎样的？
236、可以通过指针访问所有类的私有成员？
答、是。
237、问类中有其它类的对象，构造函数如何调用？
答、当创建该类对象时，先构造成员，再构造自己。？？待检验，析构函数相反。
238、问子类和基类构造函数如何调用？
答、先调用基类，再调用子类。析构顺序相反。
239、问如果父类存在有参构造，如何处理？
答、父类有有参构造函数，默认无参构造函数不会添加，需要在子类构造函数时指定初始化列表。
240、类的初始化列表的作用？
答、两个，1、初始化列表可以初始化对象成员；2、继承时，可以初始化父类的数据。
241、derive？
答、派生。
242、一个类中存在另一个类的对象，问这种模式称为什么？
答、组合。
243、如果一个子类中有其它类的对象做成员，即（继承和组合模式），那么这个子类的对象的构造顺序是什么？（常用面试题）
答、先调用基类构造函数，再调用对象成员的构造函数，最后调用该子类构造函数，析构函数相反。可以先将所有成员排个序（包括继承的），
然后根据成员顺序分析构造函数的调用情况。所有类的对象都是按照类成员的顺序进行构造。
244、问子类的函数如果和父类函数重名，编译器如何处理？
答、编译器会隐藏父类同名函数。子类对象按就近原则访问子类的同名函数，如果要访问父类的同名函数，可以通过指定作用域的方式。
245、只要子类的函数名和基类的重载版本的函数名同名，基类所有版本的重载函数都会被隐藏？
答、对，但是可以通过指定作用域方式重新调用。
246、有没有静态对象的概念？
答、待解答。
247、静态成员函数，能不能重载？
答、可以。
248、静态函数和普通函数的继承特性是一样的？
答、对。
249、问构造函数、析构函数、operator=、拷贝函数（即能够默认提供的）能不能被继承？
答、不能，都不能。
250、除了=号，其它的operator重载函数，能不能被继承？
答、可以。注意=号重载函数，和其它运算符重载函数不一样，它会被默认提供。
251、MyInteger myint(10);
cout << (++myint) << endl;
cout<<(myint++)<<endl;
cout<<myint<<endl;
cout<<"abcd"<<endl;
//myint++;
cout<<(myint++)<<endl;
cout<<(++myint)<<endl;
问这段代码有什么问题？
答、在linux上cout<<(myint++)<<endl;运行不了。
252、teststring.cpp:10:20: warning: deprecated conversion from string constant to ‘char*’ [-Wwrite-strings]
print("helloworld");
问linux上报错的原因？
答、因为函数print的形参是char *str；如果改变为const char *str；就可以消除。
253、c++中继承的最终目的是什么？
答、实现多态。
254、举一个c++中继承的例子？
答、继承的方式可以实现代码复用，例如网页的头部和尾部可以设计成一个基类，而网页的内容又分成另一个类，所有的网页都共同继承一个基类头部和一个基类尾部，
当改变网页的头部或尾部时，
只要改一个头基类或尾基类即可。
255、[]专业称呼是什么？
答、数组下标运算符。
256、问++只能用于整型变量吗？
答、不是，也可以用于浮点型。
257、匿名对象是什么？
答、有存储空间，但是这个空间的地址不能获得。
258、类中有成员函数：Person operator+(const Person &p1)
{
Person temp;
temp.age=this->age+p1.age;
return temp;
}
cout<<p1+p2<<endl;
存在全局重载运算符<<的函数：
ostream &operator<<(ostream &os,Person &p1)
{
os<<p1.age;
return os;
};
问linux上能不能运行成功？
答、不能;分析cout<<p1+p2<<endl;运行机制；
重载<<中os会引用对象cout(std命名空间中),本来p1要引用p1+p2的返回值，但是gcc是不会引用一个匿名对象的，除非加上const。
所以必须将重载<<函数的第二个参数改为const Person &p1;
如果在main函数中；Person &p1=Person(20);同样是运行不成功的，Person(20)产生的是一个匿名对象，所以必须加上const。
259、问int &&m=10;m是什么变量？
答、m是用来引用右值的变量（可以是匿名对象，字面值，字符串，）。&&右值引用是在c11中才出现。
260、如何在vim中注释指定行，取消注释呢？
答、注释：首先进入命令行模式，然后移动光标到要批量注释（插入字符）的起始行，然后按下ctrl+v键，
进入visual block模式，然后用j、k选中要批量注释的行，再按一次大写I，最后输入注释符/或要插入的符号。
取消注释：首先进入命令行模式，然后移动光标到要批量取消注释(消除字符）的起始行的首列，然后按下ctrl+v键，
进入visual block模式，然后使用l键选中要取消的符号的列，再按k，l键进行调整，选中要取消的行，
再按d键，就可以全部删除。
261、前置++重载函数，返回值是什么？
答、返回值是引用。
262、后置++重载函数，返回值是什么？
答、返回值是一个类型。
263、new运算符创建的对象返回值是什么？delete操作的对象的存储空间是什么？
答、指针。指针。
264、+=的重载运算符功能？
答、将一个类的每个成员数据分别加上某个值。
265、问person operator+（int a）;
+号是和谁结合？
答、operator。
266、问类对象a;要实现a+3的功能，应该重载成什么类型函数？
要实现3+a的功能，应该重载成什么类型函数？
答、第一个重载为成员函数；第二个重载为全局函数。
267、哪四个运算符最好重载成成员函数？
答、=、[]、（）、->;
268、哪两个操作符最好通过友元函数进行重载？
答、<<、>>;
269、哪五个操作符不能进行重载？
答、.、::、.*、？:、sizeof
270、使用vs开发人员命令，查看类的成员情况？
答、打开Developer Command Prompt for vs 2017;输入命令g:\vscode\Practice\Practice>cl /d1 reportSingleClassLayoutDerived AllOverLoad.cpp；
其中cl前为.cpp文件所在的目录，是cL(应该小写）；不是c one；其中Derived为类名。AllOverLoad.cpp为类Derived所在的文件。
271、问private和protected的区别？
答、如果没有涉及到继承和派生，private和protected权限是同等级的，外部不允许访问。
如果涉及到继承和派生，基类中的private权限变量是不可以被子类内访问的；但是protected对象是可以在子类中被访问。
对protected的理解只有通过与private比较。
272、问一般网络服务器的域名名字？
答、www
273、vs快捷键如何添加注释？如何取消注释？
答、ctrl+k ctrl+c；
取消注释是：ctrl+k ctrl +u
274、如何在记事本中实现查找功能？
答、在编辑菜单栏中存在。
275、strncpy(newname, this->name, this->name-start);
其中start是字符子针指向的是this->name字符串中某个与另一字符串使用strstr后匹配的结果。问有什么问题？
答、this->name比start地址小，所以是赋值，运行报错：0x0FAC0509 (ucrtbased.dll)处(位于 Practice.exe 中)引发的异常: 0xC0000005: 写入位置 0x01231000 时发生访问冲突。
276、程序中已经定义某个数据，为什么还会报错没有定义？
例如 类成员int a；已经定义，但是函数中对该变量访问，ide任会报错提示没有该数据，是什么原因？
答、少了}、；等。造成int a被定义到函数中去了，想想也是，说明 int a 的作用域并不是像自己所设计的那样。
277、问perons &operator+=(int age);
函数如何返回？
答、返回*this;因为person &需要返回的值必须要代表一个存储空间。
278、is >> "请输入年龄:" >> age;
is是istream类的对象，问这句代码有什么错误？
答、"请输入年龄"是字符串，不是一个变量。
279、gcc不能直接打印匿名对象？引用匿名对象要加上const？
答、是。对。例如 const Person &p1=Person();
280、问什么是匿名对象？
答、有存储空间，但是存储空间的地址对用户来说未知的量。（在这里量表示这个存储空间，实际上标识符本身就有
代表存储空间的意思）。
281、问可以通过数组下标重载成p1[p2]的形式吗？已知p1和p2是类的对象？
答、可以，虽然p2是在[]内，但是它本质上还是以实参的形式传递给函数。
282、给出重载int型（只是个例子）函数的代码？使用的代码？
答、类的成员函数
operator int()
{
return this->age;
}
Person p1(20,"张三");
int age=p1;
operator 后的类型就是要隐式转换的类型。必须与return的数据保持一致
(注意，没有返回类型，但是有return；实际上return要加是因为operator 后的类型是int；（）是不允许有参数的。
283、问类的前置声明的作用？
答、可以扩大类的作用范围，前置声明下面都可以访问。
284、
class Person
{
public:
int age;
void print();
}
print()
{
cout<<this->age<<endl;
}
问这段代码有什么问题？
答、class定义完后要加上;号，print（）函数定义时要加上Person::;
285、
class Student;
class Person
{
public:
int age;
void print()
{
Student s1;
cout<<s1.number<<endl;
}
};
class Student
{
public:
int number;
};
问这段代码犯了什么错误？
答、Student类定义在Person类后面，print（）函数中定义了一个Studnet类对象是不合法的，因为此时Student类还未定义，无法为变量s1确定内存空间，编译器会报错；
应该只在类中声明该函数成员函数，在Student定义完后再定义这个函数。
class Student;
class Person
{
public:
int age;
void print();//声明一个成员函数
};
class Student
{
public:
int number;
};
Person::void print()
{
Student s1;
cout<<s1.number<<endl;
}
286、c++中命名空间能在函数中被定义吗？
答、不能，只能全局定义(在函数外)。
287、命名空间可以嵌套定义吗？
答、可以。一个命名空间内可以定义另一个命名空间。
288、命名空间定义以后，能再次定义该命名空间，并投入标识符吗？
答、可以，但是如果是相同的数据，同一个命名空间就有多个同名标识符？？？
289、无名的命名空间相当于什么？
答、相当于让空间内所有标识符都添加了static。
290、能不能为命名空间指定别名？
答、可以。
291、命名空间中有重载函数，问如何合理调用？
答、通过using方式；例如 using A::func;就能调用所有重载了func的函数。也可以通过using namespace A；的方式。
292、直接在函数中通过using的方式使用命名空间，有什么缺点？
答、例如
void test02（）
{
using namespace A;
using namespace B;
}
可能会造成二义性，不如A::的方式好。
293、命名空间的作用怎么样？
答、很有用。
294、using namespace std的using的作用是什么？
答、using是为了打开命名空间std。
295、问const的作用？
答、限定变量为常量。
296、问c语言中如果局部定义const int arrSize=10；
int arr[arrSize];
能运行吗？
答、不能，因为编译器编译时arrSize是占用内存空间的，而编译器不知道它编译时的值是多少。如果是全局的就可以？
待检验。
在c++中待验证失败，可以运行。但是在c语言中不行，不能运行。
297、c++中所有函数外定义的const作用域是什么？
答、整个文件。但是其它文件不能访问，即不具有全局作用域(项目其它文件也能使用).这与c语言是不一样的。
298、问c++中const int a=10；a有没有被分配存储空间？
答、取决于有没有对a取地址，或extern操作，如果没有，编译器会优化成常量，不分配内存空间。试问这个时候
a存储在哪？10存储在哪？
299、问c语言中全局的const修饰变量存储在哪？c++中当有extern或者对变量取地址时，const修饰的变量存储在哪？
答、c语言中会存储在常量区，c++中也会存储在常量区，而且此时已经分配内存空间。
300、问字面值存储在哪？
301、问局部定义的变量const int constA=b;问会不会优化？
int b = 10;
const int constA = b;
int* p = (int*)&constA;
*p = 300;
cout << "constA:" << constA << endl;
cout << "*p:" << *p << endl;
这个代码输出结果是什么？
答、不会。constA:300;*p:300;
302、const int constA = 10;
int* p = (int*)&constA;
*p = 300;
cout << "constA:" << constA << endl;
cout << "*p:" << *p << endl;
问输出什么？其中constA是在局部定义？
答、constA:10;
*p:300;
303、问c++中const优化指的的什么？
答、const修饰的局部变量a，如果初始化时的值是一个字面值10、12等。①、当不对该变量a进行取址操作或extern操作，变量a不会被分配内存，仅仅是用10代替a，相当于define；
②、但对a进行取址操作，c++编译器非常智能地，会为a分配存储空间，并用*改变了a内的数据，但是cout<<a<<endl;任然不会输出a改变后的值，而是继续类似define的功能方式，
输出原值。
304、c++中const定义的局部变量，什么时候不优化？
答、当volatile修饰了const时；当用另一个会开辟内存空间的变量(非const)初始化赋值给该变量；（例如int b,类对象，结构体）
305、如何将c++中函数外定义的const修饰的变量，具有全局作用域？
答、加extern。
306、问怎样用数组下标定义变量？
答、在c99编译器中可以。但是vs2013不支持c99.
307、#define A 20;宏常量如何终止使用？
答、通过#undef A，
308、问宏常量有没有命名空间？
答、没有。namespace MySpace{
#define num 1024
}
void test(){
//cout << MySpace::NUM << endl; //错误
//int num = 100; //命名冲突
cout << num << endl;
}
这段代码错误。
309、能不能对NULL进行引用？
答、不能。
311、问引用的本质？
答、int &a=b；
int *const a=&b;
312、函数作为左值，对函数的要求？
答、函数的返回值必须是引用。
313、问预处理器能访问类的成员吗？
答、不能，所以不能在类中使用预定义的宏函数。也不能定义宏函数。
314、问预处理阶段是通过什么完成的？
答、预处理器。
315、问内联函数在什么时候会被处理？
答、在编译的时候。
316、问c++自定义类的构造函数(非拷贝构造)，问默认的拷贝构造函数还存在吗？
答、存在。
317、类的构造函数调用顺序？
答、按成员的顺序调用，最后再调用自己的。
318、问c++创建对象时的执行过程？
答、先为对象分配内存，再用构造函数来初始化。
319、问new操作符本质？
答、封装了动态分配内存的方案。
320、问Person *p=new Person[10];会调用多少个构造函数？
答、10个。
321、问delete[]操作和delete什么时候用？
答、有严格限定，当new []时，必须要用delete []，当new时，必须要用delete。
322、类的静态变量什么时候分配虚拟内存空间？
答、编译阶段，对象还没创建时。
323、编译阶段会不会分配虚拟存储空间？
答、会。
324、问静态成员函数有没有权限？
答、有。
325、问const static类成员最好在哪初始化？
答、类中。
326、单例是什么？
答、一种特殊的类的别称。
327、问单例的语法特点？
答、默认构造和拷贝构造私有；存在静态的类指针变量，并实现指向一个对象；存在静态getInstance()用来访问静态的
类指针变量。
328、如何从函数中返回对象？
答、return *this
329、问成员函数后加const修饰的是什么？
例如 void someOperatre()const{}?
答、const Person *const this。即用const修饰this又用const修饰this指向的存储空间。所以常函数内是不能改变
this所指对象的数据的。除非类的成员用mutable修饰。
330、问常对象是什么？有什么特点？
答、常对象是const修饰的对象；特点有两个：①只能调用常函数；②只能通过常对象访问(cout<<perosn.a<<endl)类的
成员，不能修改，除非类的成员用mutable修饰。
331、c++友元的种类有哪些？
答、全局友元函数、类成员友元函数、友元类。
332、设置友元机制时，友元的关键字friend使用有什么特点？
答、只在声明处开头出现。
333、友元函数如果是类的成员有this指针吗？
答、有。但没有属于要去访问的类的this指针。
334、问友元关系具有传递性吗？
答、不具有，例如类B是类A的朋友，类C是类B的朋友，但类C不一定是类A的朋友。
335、什么时候要在类的成员函数中添加this指针？
答、当有数据冲突的时候。
336、重载运算符的一个潜在要求？
答、使得重载运算符函数与运算符内在的功能相吻合。
337、问什么时候调用拷贝函数？什么时候调用赋值=函数？
答、初始化时调用的是拷贝函数，已初始化，就是调用赋值函数。
338、问重载=号赋值运算符函数有什么特点？
答、为了满足连续=号运算要求，必须返回一个对象的引用，这个对象就是this所指的对象。
同理+=、-=、*=、/=号也是如此。vector和string中遵守了这个协定。所以最好也要遵守。
339、为什么不要重载&&、||运算符？
答、因为在执行重载的&&、||函数时，不能很好地按内在的功能很好地保持一致。即可能先算了&&右边的值，
再算左边的值。
340、什么是多继承？
答、一个类有多个基类；例如class:public a,public b;
341、问子类是派生类，构造函数如何调用？
答、先调用父类构造函数，再调用对象成员构造函数，最后调用子类构造函数。
342、一般子类访问成员是什么意思？
答、通过子类的成员函数访问子类的成员。二是通过子类的对象访问成员
342、如果基类和子类存在同名的成员，问子类如何访问这个同名的成员？
答、子类的成员函数如果没有作特殊说明，访问的就是子类的成员。子类对象也是如此。除非指定作用域。
343、问什么是函数的隐藏？
答、子类如果有一个函数名与父类相同，则父类所有与该函数名相同的函数都会被隐藏，隐藏的结构是不能通过子类对
象直接访问父类的成员函数。也不能通过子类成员函数直接调用父类中被隐藏的函数。
344、面向对象编程的基本原则，试写一例？
答、对修改关闭，对扩展开放。
345、问c++中通过类对象实现封装功能，问这样做的目的是什么？
答、实现多态。
346、问如何解决多继承中出现的二义性？
答、通过作用域或virtual虚继承的方式。
347、问什么是二义性？
答、继承的基类超过一次。例如class person{};class p1:public person{};class p2:public person();
class p3:public p1,public p2{};这种就称为菱形继承。
基类person被继承超过一次。
还有一种情况就是继承的两个子类中出现了同变量的数据。造成访问冲突，这种不是菱形继承。
348、问虚继承时子类对象创建后，编译器创建的vbptr指针指向哪里？
答、vbtable（实际上是数组）。而且vbptr在子类对象中被创建。
350、问类继承时，子类对象创建后，内部所有成员有没有对所有数据按基类的类型进行区分？
答、会。并不是一视同仁。
351、问基类没有无参构造函数，但有有参构造函数，问子类要采取什么措施？
答、使用初始化参数列表。
352、问虚继承是为了解决什么问题？
答、只能解决菱形继承的二义性以及存储空间的浪费问题，不能解决非菱形继承的二义性问题。所以除了菱形继承，
其它情况不要用virtual进行虚继承。
353、问为了解决菱形继承问题，使用了虚继承，那么子类会如何初始化虚继承的基类数据成员？
答、由最后的子类初始化虚继承的基类成员数据。
354、class BigBase{
public:
BigBase(){ mParam = 0; }
void func(){ cout << "BigBase::func" << endl; }
public:
int mParam;
};
class Base1 : virtual public BigBase{};
class Base2 : virtual public BigBase{};
class Derived : public Base1, public Base2{};
问Derived类对象创建后BigBase类的成员由谁的构造函数初始化？
答、由Derived类的构造函数，而不是base1或base2初始化。
355、程序员应该如何做笔记？
答、做的笔记要保证以后查到后能编写出程序。
356、问设计模式与语法有关吗？
答、没有。
357、问c++面向对象三个基本特性有哪些？
答、数据抽象、继承、多态。
358、继承的好处？
答、扩展类的功能、类的数据、为了实现多态。
359、什么是静态多态？什么是动态多态？
答、静态多态是在编译时实现多态，函数的调用地址在编译阶段就能确定，动态多态是在运行时多态，函数的调用
地址在运行时才能确定（用虚函数、纯虚函数实现动态多态）。
360、静态多态实现方式？
答、函数重载、运算符重载。
361、问运算符重载和函数重载有什么区别？
答、运算符是对运算符进行重载，函数重载是对函数进行重载。
362、问写程序代码要考虑什么？
答、通过新增代码来扩展功能，而不是通过修改代码。
363、问基类中定义了虚函数，子类中对虚函数进行了实现，问通过基类类型的指针调用虚函数是如何工作的？
如果子类没有实现呢？
答、指向哪个对象，就调用哪个对象的虚函数实现。如果子类没有实现，调用基类虚函数。
364、问什么是向上类型转换？什么是向下类型转换？
答、子类对象向父类类型转换称为向上类型转换；把父类转换子类称为向下类型转换。
例如 Derived d；base b=d；（类derived继承了base）；
365、class base{public:func();};
class derived:public base{public:func()};
问：
derived d；
void print（base & temp）
{
temp.func();
}
print函数执行过程是怎样的，调用的是哪个func函数？
答、没有在基类中使用virtual，所以实行静态多态，调用的是base类的func，而不会去找子类func。
（联想强制类型转换）；当加virtual后，子类如果对base类的该函数重写（注意参数类型名字必须一模一样，
只是定义不一样），子类对象中的vfptr指针会指向子类编译时创建的虚函数表，但是这个虚函数表会在编译
时将该函数写成子类的，而父类的对应虚函数不会在子类中出现。运行时才会通过vfptr指针查找该表函数。
（只有虚函数才会在虚函数表中，非虚函数不在。）
366、问class base{void func（）};base a；
a占多少个字节？如果void func（）变成virtual void func（）；占几个字节
答、1个。4个。
367、问如果类中有虚函数，编译器编译这个类时有什么不同？编译这个类（包括继承）的对象时有什么不同？
答、会给当前类创建一张虚函数表(vftable)（实际上是数组）;会给对象添加vfptr指针，并指向虚函数表。
368、问变量a是指针变量；如何将a强转成函数指针？
答、(void (*)())a;
369、问虚函数实现多态会造成什么影响？
答、会造成函数调用效率降低，这也是c++比c语言效率低的原因。
370、问子类对象直接调用虚函数和非虚函数的区别？基类子针指向子类对象时调用虚函数和非虚函数的区别？
基类对象用子类对象赋值时调用虚函数和非虚函数的区别？
答、子类对象调用虚函数和非虚函数一样，没有区别，会覆盖父类的同名函数。基类子针调用虚函数是调用子类的，
调用非虚函数是？？？（需验证,结合this指针分析）。
基类对象用子类对象赋值时调用虚函数和非虚函数是一样的，都是基类，子类对象的数据会被截取，只保留基类的数据。
371、问具有纯虚函数的类能不能创建对象？
答、不能。这样的类称为抽象类。
372、问子类没有实现继承的抽象类的纯虚函数要注意什么？
答、这样的子类还是抽象类，是不能创建对象的。
373、纯虚函数的格式？
答、virtual void func（）=0;
374、问如果子类没有实现父类的纯虚函数，会造成什么后果？
答、子类不能创建对象，任旧是一个抽象类。
377、c++中接口类是什么？
答、类中的函数都是纯虚函数。
378、问如果子类中的虚函数没有写，会对程序有什么影响？
答、因为调用虚函数是通过vfptr指针，且指针必须添加，所以会降低效率。
380、问纯虚析构函数会被定义吗？纯虚析构函数和普通的虚函数有什么区别？
答、会，但必须在类外（所有函数外）。纯虚析构函数会造成类变成抽象类是不能实例化出对象的。即使它在类外也定义了。
与普通虚函数相比，唯一的不同是，纯虚析构函数必须要在类外（所有函数外）定义
381、类外有哪几种？
答、类定义的外面但在main函数外面和类定义的外面但在函数内。
382、问virtual函数在父类中已经写了，在子类中还要写该关键字吗？
答、不需要。
383、问子类隐藏父类，是如何体现隐藏作用的？
答、子类的对象直接访问父类成员，访问不了，但是可以通过作用域访问；子类中需要调用父类的数据，不能调用。
必须通过作用域。
384、问如果用基类指针指向子类对象（动态创建），基类析构函数没有设置为虚函数，
用delete释放指针，那么子类的析构函数会被调用吗？
答、不会。只会调用基类的析构函数。
385、问多态是如何分类的？
答、多态分成静态多态（通过运算符重载和函数重载的方式）和动态多态（通过虚函数的形式）。
386、动态多态必须借助指针或引用，这句话对吗？
答、对。
387、问泛型的含义？
答、与变量类型无关。
388、函数模板能自动推导类型吗？类模板呢？什么是自动推导类型？
答、函数模板能，类模板不能，自动推导类型是不指定模板的参数类型，只传递参数，函数模板会根据参数的类型，自动推导（前提是能推导）。例如
template<class T>
void mySwap(T &a,T &b)
{
}
调用：
int a;
int b;
mySwap(a,b);
mySwap<int>(a,b);
两种都可以。
389、函数模板能用typename定义模板参数类型吗？（用 typename指定一个标识符表示类型）
答、可以；template<typename T>;
390、typename除了定义模板还有其它功能吗？
答、有。
391、问template<typename T>的作用域
答、只对下面的一个函数有效。
392、类模板必须指定类型吗？
答、对。
393、模板在哪方面比较常用？
答、数据结构，STL。
394、问如何在栈中分配与字符串相同的空间存储字符串，而且不会涉及用户自己数字符串？
答、char arr[]="aaaa";
395、当某个函数模板涉及到比较时，例如排序时，比较大小int型、char型数据很容易做到，那么如果传入的是类型呢，
如何做到？
答、可以对运算符比较符号例如大于小于进行重载。
396、学c++最好要再学一个web语言，例如java或php
答、正解。
397、问模板参数可以有默认值吗？
答、可以。例如typename<class T=int>
398、问函数模板能进行自动类型转换吗？
答、不能，必须严格匹配
399、问函数模板与模板函数，哪个会被先调用（调用时类型实参与函数模板和模板函数都匹配）？
答、模板函数。但是可以通过模板参数列表指定用函数模板。例如myFunc<>(a,a)。
400、能用另一个函数模板重载原函数模板吗？
答、可以。
401、问函数模板编译机制？
答、编译器发现函数模板，首先编译一次；若含有对函数模板的调用，编译器会生成一个函数实例
（编译器偷偷为我们做了一些事）,再对这个实例进行编译（检查生成的函数是否正确）。
402、问编译器编译文件时知不知道其它文件？
答、如果没有包含，不知道。
403、问如果没有对函数模板的调用，还会生成模板函数的实例吗？
答、不会。
404、c++中标准库中的数据结构通过什么实现？
答、函数模板。
405、模板类不能自动推导类型，编程时要注意什么？
答、必须写模板参数列表；Perosn<string,int>person("aaa",10);
406、遇到有模板的程序如何分析？
答、必须要先分清是函数模板还是类模板。
407、问类模板作为父类，非模板的派生类要如何继承？为什么？
答、必须指定T的类型，不指定T的类型，派生类就不知道内存空间该分配多少，无法创建对象。
408、问派生类是模板，父类也是模板，要注意什么？
答、基类如果有有参构造函数，派生类必须用参数化列表对基类构造函数初始化；必须指定继承的父类的参数类型T，
可以用派生类的T或T1代替；例如
template<class T,class T1,typename T3>
class Derived:public Base<T3>
{}
409、问类的成员函数支不支持，类内声明，类外定义实现？
答、可以。
410、给出类外实现类的成员函数的模板的实例？
答、template<class T>
class Myvector
{
public:
Myvector(int capcity);
}
template<class T>
Myvector<T>::Myvector(int capcity)
{
}
411、问c++类模板能分文件编写吗？
答、即只在类中存放函数的声明，但是函数的定义放在另一个文件（但包含了头文件）。这种模式叫做分文件。
可是类模板是不支持分文件编译。链接器会报错。函数调用找不到具体的函数。最根本的原因是c++对模板文件
是通过独立编译和二次编译的方式。解决方案：1、常用，将类内的成员函数的模板声明和实现放在同
一文件，最好在类内实现；2、当要调用类模板时，在该文件中包含类模板头文件和cpp文件（声明的文件和调用的文件）。
412、问.hpp文件一般是什么文件？
答、文件中定义了模板的文件。
413、问在类中定义了一个普通友元函数，需要做什么处理？
答、如果不做任何处理，链接器不知道普通友元函数是不是模板的函数，所以必须要在函数标识符后添加一个<>标志，
表示友元函数是类模板的友元函数。而且要在之前添加类模板和友元函数模板的声明，这是因为链接器在处理类内
的友元函数声明时，与一般的函数声明不一样，必须严格要求模板类和函数模板提前声明。
414、问在类中定义了一个友元的模板函数，需要做什么处理？
答、不需要提前声明，按普通模式声明定义。但是注意必须在声明中包括template<class T,class TT>
415、问回调函数的两种形式？
答、函数指针、函数对象。
416、问函数对象是什么？
答、struct myShow
{
void print（）
{
cout<<endl;
}
};
myShow ab;
ab就是函数对象。
417、问__cdecl 是什么？
答、c语言的调用惯例（函数参数压栈顺序）。
418、问函数参数压栈顺序是什么？
答、默认从右向左。
419、问__stdcall是什么？
420、问匿名对象有什么用处？
答、可以向函数传递参数。
421、问
class person
{
public:
person(int a,int b)
{
this->age=a;
this->id=b;
}
public:
int age;
int id;
};
person p1;
问这个对象能不能被创建？
答、不能，因为无参构造函数没有生成，默认无参构造函数在自定义了构造函数时是不会生成的。
答、约定参数的压栈顺序，，在windows api中指定函数的压栈顺序。
420、__thiscall、__fastcall是什么？
答、同样是调用惯例，甚至可以将前两个参数压入寄存器中。
421、问在linux上默认模板参数如何使用？
答、必须在编译的时候指定-std=c++11。
422、默认模板参数的函数模板，怎样调用函数？
答、直接通过函数名调用，甚至可以不加<>。
423、问typeid在c++中是什么？
答、是操作符，不是函数。用来获得变量类型的名称。用法typeid(变量).name();
424、typeid在什么时候识别非引用类型，什么时候识别引用类型？
答、在编译时期识别非引用类型，在运行时识别引用类型。
425、问<>的作用？
答、当模板函数和函数模板都能匹配时，告诉编译器匹配函数模板。
426、
严重性 代码 说明 项目 文件 行 Suppression State
错误 C2679 二进制“<<”: 没有找到接受“std::string”类型的右操作数的运算符(或没有可接受的转换) Project2 g:\vsc++\project2\project2\源.cpp 108
错误(活动) E0349 没有与这些操作数匹配的 "<<" 运算符 Project2 g:\vsc++\Project2\Project2\源.cpp 108
问为什么错误？
答、没有找到接受“std::string”类型的右操作数的运算符，意味string头文件没有包含。
427、类内的函数一定会内联吗？
答、不一定。
428、问vs有没有分屏功能？
答、有。
429、c++中某个关键字显示错误，不能编译，可能原因是什么？
答、关键字后面所接的标识符不合法。
430、在一个类中，定义这个类的成员函数为这个类的友元函数可行吗？
答、不行，没必要，友元函数是为了访问另一个类的私有成员设计的。
431、template<class T>
class Person
{
friend std::ostream&operator<<(std::ostream &os, Person &person)
{
os << person.mAge;
return os;
}
public:
Person(int age)
{
mAge = age;
}
void showPerson()
{
cout << "Age:" << mAge << endl;
}
public:
T mAge;
};
问这种写法合理吗？
答、合理，友元函数在类中定义。
432、template<class T>
class Person
{
friend std::ostream & operator<<<>(::ostream & os, Person &person);
friend void printPerson<>(Person &person);
template<class TT>friend void lookPerson(Person &person);
public:
Person(int age);
void showPerson();
public:
T mAge;
};
//省略掉定义
问有什么错误？
答、没有对类名和函数原型进行前置声明。在类中声明的友元函数必须连同模板进行前置声明。
template<class T>class Person;
template<class T>void printPerson(Person<T>&person);
template<class T>std::ostream&operator<<(std::ostream& os, Person<T>&person);
template<class T>
class Person
{
friend std::ostream & operator<<<>(::ostream & os, Person &person);
friend void printPerson<>(Person &person);
template<class TT>friend void lookPerson(Person &person);
public:
Person(int age);
void showPerson();
public:
T mAge;
};
433、vs中""不能删除右边单引号，如何解决？
答、在""中输入空格，再删除右边。
434、问#include<string>
class Person
{
public:
int age;
string name;
};
问有什么问题？
答、string在std空间中定义；string要想有效，必须包含<iostream>
435、比较函数的函数返回值最好选择什么？
答、int型。
436、问c++中调试过程中，如何添加局部变量，得到运行过程中数据？
答、通过添加监视。
437、问iostream中有没有printf。
答、有。
438、能不能在函数中定义类。
439、问c++分文件编译的编译单元是什么？
答、文件以及文件本身扩展的文件。
440、问template<class T1=int,class T2,class T3>class Person{};问有什么错误？
答、类模板的默认参数的设置和函数模板一样，一个参数默认以后，后面的所有参数也必须默认。
441、问template<class T1=int,class T2,class T3>void print(T1 pa,T2 pb, T3 Pc){};对吗？
答、不对，模板函数不能有默认参数。
442、问类模板的默认参数能不是不同类型吗？
答、不能。template<class T1=int,class T2=double,class T3=double>class CeilDemo{}.这种用法是错误的。
443、问template<class T1,A m>class Cc{};有什么问题？
答、错误，非类型模板形参不能是对象，非类型模板形参的类型只能是对象的引用或指针。
444、问template<class T1,double a>class Cc{};有什么问题？
答、错误，非类型模板的形参不能是double类型，可以是double的引用。
445、template<class T1,A<int>m>class Cc{};问有什么问题？
答、非类型模板的形参不能是对象，可以是对象的引用或指针。这条规则对于模板形参也不例外。
446、问typeid（变量名）.name();常使用在哪？
答、和模板联合使用，用来显示模板的中变量类型。
447、问
template <class T1,int a>
class Person{
void g(){};
};
在类外定义g()时，应该如何进行？
答、template<class T1,int a>
void Person<T1,a>::g(){cout<<"class Person"<<endl;
注意两个template类型要保持一致，而且，函数定义中Person<T1,a>也要一致。
448、问template <class T1,class T2=int>
class Person{
void g(){};
};
如果定义函数
template<class T1,class T2=int>void Person<T1,T2>::g(){cout<<endl;};问有什么错误？
答、在类模板外部定义带有默认参数类型的形参时，在template的形参表中默认值应省略。
449、问int main()
{
template<class T>void h(){};
do other things;
return 0;
}
有什么错误？
答、模板的声明或定义只能在全局、命名空间或类范围内。不能在局部、函数内。
450、问int main()
{
A<2>m;
do other things;
return 0;
}
有什么错误？
答、必须指定类型。
451、问存在模板类
template<class T1,int a>class Ci
{};
const int a2=3;
Ci<int,a2>mci有什么问题？
答、没有问题，因为a2是常量。
452、问存在模板类
template<class T1,int a>class Ci
{};
int a=3;
Ci<int,a>mci有什么问题？
答、有问题，因为a是变量。
453、什么是模板的非类型形参？
答、例如template<class T,int a>class Ci{}
其中int a就是模板的非类型形参。
454、问模板的非类型形参有什么特点？
答、实参必须是一个常量表达式。可以是地址的常量表达式（地址常量），也可以是变量的常量表达式（常量）。
455、存在全局的变量int a=30;(main函数外定义)
template<class T1,int &a>class Cip{};
问Cip<int,a>mcip;有什么错误？
答、没有错误，模板的非类型形参对应的实参要求是常量表达式。
459、问int *a=&b;
*a表示什么？
答、*a表示变量b的这个存储空间。
460、问插入排序
void insertsort(int *arr, int len)
{
for (int i = 1; i < len; i++)
{
if (arr[i - 1] > arr[i])
{
int temp = arr[i];
int j = 0;
for (j = i; j > 0 && arr[j - 1] > arr[i]; j--)// arr[i] 换成temp
{
arr[j] = arr[j - 1];
}
arr[j] = temp;
}
}
}
算法有什么问题？
答、for (j = i; j > 0 && arr[j - 1] > arr[i]; j--)
{
arr[j] = arr[j - 1];
}
此句中arr[j]=arr[j-1]会覆盖调用arr[i]的值，造成arr[i]改变。应该换成temp.
461、问插入排序
void insertsort(int *arr, int len)
{
for (int i = 1; i < len; i++)
{
if (arr[i - 1] > arr[i])
{
int temp = arr[i];
int j = 0;
for (j = i; j > 0 && arr[j - 1] > arr[j]; j--)
{
arr[j] = arr[j - 1];
}
arr[j] = temp;
}
}
}
算法有什么问题？
答、插入算法的思想是外层循环从头开始遍历，内层循环从外层中的位置中向前与一个temp定值比较，并移动位置。
462、问class Person
{
public:
Person(int a, int b)
{
this->temp = a;
this->temptemp = b;
}
/*Person()
{
}*/
public:
int temp;
int temptemp;
};
class Student :public Person
{
public:
Student(int a, int b) :p1(a, b)
{
/*p1.temp = a;
p1.temptemp = b;*/
}
public:
Person p1;
};
int main()
{
Person p1(2, 3);
Student s1(2, 3);
cout << s1.p1.temp << endl;
cout << s1.p1.temptemp << endl;
system("pause");
return 0;
}
这段代码有问题吗？
答、有，应该在基类中添加默认的无参构造函数。题目情形是基类只有有参构造函数，所以默认的无参构造函数不会被编译器添加，
而子类又继承了基类，所以必须要在基类中自己定义无参构造函数。
463、问class Person
{
public:
Person(int a, int b)
{
this->temp = a;
this->temptemp = b;
}
/*Person()
{
}*/
public:
int temp;
int temptemp;
};
class Student
{
public:
Student(int a, int b) :p1(a, b)
{
/*p1.temp = a;
p1.temptemp = b;*/
}
public:
Person p1;
};
int main()
{
Person p1(2, 3);
Student s1(2, 3);
cout << s1.p1.temp << endl;
cout << s1.p1.temptemp << endl;
system("pause");
return 0;
}
这段代码有问题吗？
答、没有，这里没有继承关系，一个类中有另一个类对象做成员。
464、基类中数据是由构造函数初始化，如果子类中没有相应的初始化列表,要在基类中添加什么？
答、无参构造函数。
465、问子类的初始化列表如何即为基类分配数据，又为子类中的基类对象分配数据？
答、Student(T c, TT d,TT e) :Person(d, d), mPerson(d, e){}
466、template<typename T>
class Person
{
public:
Person(T a, T b)
{
this->a = a;
this->b = b;
}
/*Person()
{
}*/
public:
T a;
T b;
};
template<typename T, class TT>
class Student :public Person<TT>
{
public:
Student(T c, TT d,TT e) :Person(d, d), mPerson(d, e)
{
this->c = c;
this->d = d;
}
public:
T c;
TT d;
Person<TT> mPerson;
};
问为什么要加Person(d,d);
答、子类中既有基类对象，又继承基类。但是基类中没有添加无参构造函数，只有有参构造函数，所以要通过Person(d,d)为基类数据初始化。
467、c++中使用new时，如何将new出来的堆空间自动清空？
答、加上（）；例如
char *a=new char[100]();
这样new出来的空间会自动清零。
468、问如何在类中声明成员函数，但是在类外定义成员函数？
答、类内不需要加上template模板声明。在类外加上模板声明，而且必须和类的template声明相同。例如
template<typename T>
class Person
{
public:
void PrintPerson()
{
cout << a << endl;
cout << b << endl;
}
void PrintPerson1();
public:
T a;
T b;
};
template<typename T>
void Person<T>::PrintPerson1()
{
cout << typeid(a).name() << endl;
cout << typeid(b).name() << endl;
}
469、问链接器有什么作用？
答、由于c++中编译是分文件编译，所以链接器起到链接作用，将不同的文件编译后生成的.obj文件链接到一起。
470、问能在类的public域内定义一个友元函数吗？
答、经vs测试，可以。但不确定其它编译器可以。
471、问如何在类模板外定义一个友元函数？
答、需要具备三个额外的条件:类模板的前置声明;函数原型的前置的声明;在类内声明时需要在标识符后加上<>。
或需要四步：类模板的前置声明;函数原型的前置的声明;在类内声明时需要在标识符后和参数列表前加上<>;类外定义实现函数。
template<class T>class Person;
template<class T>ostream& operator<<(ostream &os, Person<T> &p1);
template<class T>
class Person
{
public:
Person(T a, T b)//定义公有成员构造函数，方便定义对象
{
this->a = a;
this->b = b;
}
//friend ostream&operator<<(ostream &os, Person & p1)//类内定义友元函数
//{
// os << p1.a << endl;
// os << p1.b << endl;
// return os;
//}
friend ostream& operator<<<>(ostream &os, Person &p1);//在类外定义运算符重载的友元函数
//friend void PrintPerson<>(Person &p1);//在类外定义全局的友元函数
//template<class T, class TT>friend void ShowPerson(Person &p1,TT a);//定义全局的模板函数，且是友元的
private:
T a;
T b;
};
template<class T>
ostream& operator<<(ostream &os, Person<T> &p1)
{
os << p1.a << endl;
os << p1.b << endl;
return os;
}
472、问如何在类模板内定义一个友元的模板函数？
答、两步；一在类模板中声明一个函数；二在类模板外定义。
template<class T>
class Person
{
public:
Person(T a, T b)//定义公有成员构造函数，方便定义对象
{
this->a = a;
this->b = b;
}
//friend ostream&operator<<(ostream &os, Person & p1)//类内定义友元函数
//{
// os << p1.a << endl;
// os << p1.b << endl;
// return os;
//}
//friend ostream& operator<<<>(ostream &os, Person &p1);//在类外定义运算符重载的友元函数
//friend void PrintPerson<>(Person &p1);//在类外定义全局的友元函数
template<class T, class TT>friend void ShowPerson(Person &p1,TT a);//定义全局的模板函数，且是友元的
private:
T a;
T b;
};
template<class T,class TT>
void ShowPerson(Person<T> &p1, TT a)
{
cout << a << endl;
printf("ShowPerson works.");
}
473、问#define MAX=10;
有什么问题？
答、不需要用=号。且不需要;号（重要）
474、问根据时间设置随机数的表达式是？
答、srand(unsigned(time(NULL)));（指定随机数生成以时间为依据）;
rand();//产生时间。
475、问快速排序的特征是什么？
答、1、每次按照同样的法则（从下标角度出发）选择一个基数；2、一次循环中包括多次小循环，小循环的目的是将所有数分成比基数大和基数小的数列；
3、小循环分成两种，一种是从左向右，找到一个比基数大的数（假设这次快速排序的目的是按照升序）；另一种是从右向左，找到一个比基数小的数；
4、每个小循环执行成功后，要将该不符合排序规律的数覆盖到相对方向的端点处，并使下标增加，让相对方向的端点向使数据范围缩小的方向移动；
5、循环体退出后，将基数放入合适的数组下标指定的位置。
476、void InsertSort(int arr[], int len)
{
int i = 0;
int j = 0;
//int temp = 0;
for (i = 1; i < len; i++)
{
int temp = arr[i];
j = i;
//if(arr[j-1]>arr[j])
//{
for ( ; j >0 && arr[j-1] > temp; j--)
{
arr[j] = arr[j-1];
}
//}
arr[j] = temp;
}
return;
}
InsertSort(arr, MAX-1);
问为什么数组的最后一个数总是无法排序？
答、因为MAX-1形参传入后，造成最后一个数据不能被访问。（注意插入排序传入的数据是MAX-1，表示下标）；MAX是数组的长度。
477、问冒泡排序算法有什么问题？
答、void BubbleSort(int arr[], int len)//升序
{
int i = 0;
int j = 0;
//设置temp变量用来交换数据
int temp;
for (i = 0; i < len; i++)
{
for (j = 0; j < len-i; j++)
{
if (arr[j] > arr[j + 1])
{
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
答、第二层for循环内，当j=len-1时若执行for语句arr[j]=arr[j+1]会造成数组越界，访问了arr[len]处的元素，而len是数组的总个数。
478、问++运算符和*运算符（间址访问）哪个优先级更高？
答、一样的，结合性从右到左；
479、问类Stuent的成员函数Person operator*(){return *PPerson;};
是如何模仿*号间指操作符的？
答、通过Student的对象s1，对s1进行间指操作，就能访问到Person对象。注意所有类成员重载函数，都是将对象与重载的运算符结合获得函数的调用。
480、问下面代码有什么不足？
Person operator*()
{
return *PPerson;
}
答、应该返回Person &;这样可以很好地运行，否则会调用拷贝构造函数，降低效率。
481、class Printer
{
public:
static Printer *Generator(const char *str = NULL)
{
if (str != NULL)
{
cout << str << endl;
PPrinter->Times++;
}
return PPrinter;
}
private:
Printer()
{
Times = 0;
}
public:
static Printer *PPrinter;
int Times;
};
Printer*Printer::PPrinter = new Printer;
问此单例程序有什么错误？
答、没有定义析构函数，释放空间。单例的所有成员都是私有的。必须定义拷贝构造函数。Generator中不应该打印。再写一个函数最好。times最好是静态的。
481、问vs总是安装不上，是什么原因？
答、不能将多版本的vs删除干净，应该进入控制面板中进行删除。
482、容器提供迭代器，算法使用容器提供的迭代器对容器的数据进行操作？
答、对。这是容器、迭代器、算法三种STL组件的关系。
482、问vector的本质？
答、动态数组。而且是单口的动态数组。
483、问数组在首部插入元素效率怎么样？
答、不高，需要移动后面所有元素。
484、容器的迭代器是指向容器的内存的，如果容器的内存重新分配，原迭代器指向的内存就失效了？
答、对。
483、问dequeue容器可以看成什么？
答、双端队列或双端数组。
482、问vector容器和其它容器的最大区别？
答、vector容器有容量capacity的性质，但是其它容器没有。意味resize只能改变数据个数，但是不能改变容量大小，容量在这里是指存放数据的内存大小。
483、问STL中的容器是函数模板还是类模板？算法呢？
答、容器都是类模板，算法都是函数模板。
484、类编写时，必须保证内部所有数据成员都有定义？
答、正确，这样才能知道分配多少内存。
485、问
#define TEST(ABC) #ABC
string abc=TEST("ABC");
std::cout<<abc<<std::endl;
结果是什么？
答."ABC"，注意不是abc
486、问就成员函数调用而言基类和派生类的角色是什么？
答、函数版本。
487、问什么是动态类型？
答、表达式或变量的内存中的对象的类型。
488、问什么是静态类型？
答、编译时的类型，变量声明时的类型或表达式生成的类型；
489、派生类的对象中含有基类对象的成分？
答、正确。
490、初始化、赋值过程都是调用类的函数？
答、正确。
491、override关键字的作用？使用位置和使用要求？
答、
①、说明派生类中的虚函数；
②、派生类、虚函数中；
492、c++primer中覆盖的含义？
答、基类指针或引用调用虚函数时，派生类的函数会覆盖掉基类。
493、c++primer中覆盖的上下文局限于虚函数？
答、正确。
494、c++primer中final的作用？
答、不允许后续的其他类覆盖f1(int);
495、问纯虚函数能不能被定义？
答、能。
496、什么是重构？
答、重构负责重新设计类的体系以便将操作和/或数据从一个类移动到另一个类中。
497、问派生类怎样访问基类中受保护的成员？
答、在派生类中，就出现的基类对象和派生类对象而言，派生类的成员和友元只能访问派生类对象中
的基类部分的受保护成员；对于普通的基类对象中的成员不具有特殊的访问权限；因为该派生类不是
基类的友元；
498、类没有写任何构造函数，什么情况下编译器也不会为类生成默认的构造函数?
答、当有类类型的成员，且这个 成员的类型没有默认构造函数。
499、问什么是默认构造函数？
答、不接受任何实参的构造函数。
500、问"Empty"字符串会被c++当做什么？
答、string临时对象。
501、常函数如果返回引用，该引用类型也应该是常引用？
答、正确。
502、内联函数不会带来任何额外的运行时开销？
答、正确。
503、问类的定义分成几步处理，是哪几部？
答、首先，编译成员的声明；直到类全部可见后才编译函数体；
504、如果一个构造函数为所有参数都提供了默认实参，则它实际上也定义了默认构造函数？
答、正确。
505、为什么类的静态数据成员只能在类内声明，在类外初始化？
答、因为类的构造函数含有this指针。
506、类的成员分成几种？
答、3种，数据、函数和类型成员；
507、问什么是c++的封装？
答、将实现部分设为private完成封装；
508、问什么是接口？
答、不包含数据成员；但是可以含有函数。
509、问拷贝构造函数定义成=delete的作用？
答、告诉编译器不要生成该拷贝构造函数。
510、问含有const成员的类，该成员不能默认构造，能使用合成的默认构造函数吗？
答、不能。
511、c++primer 5 477
关于带有引用的成员的类，赋值操作没有很好理解。
512、如何使得类定义得像指针？
答、通过shared_ptr成员。
513、内联体现调用函数和函数定义之间的关系。
514、当需要拷贝某个对象之后，该对象可以被销毁，可以考虑使用对象移动，可以提高性能。
515、什么情况下可以使用移动而不是拷贝？
答、对于IO类或unique_ptr等，都包含不能被共享的资源，因此这种类型的对象不能拷贝但是可以移动。
516、如果类包含不被共享的资源，那么可以设置这个类不能被拷贝。拷贝函数=delete;
517、c++中变量是什么？
答、表达式。
518、问move的作用？
答、告诉编译器，我们有一个左值，但我们希望像一个右值一样处理它。
519、问右值引用的作用？
答、绑定到一个将要销毁的对象。
520、问左值表达式和右值表达式表示的是什么？
答、一个对象的身份、对象的值。
521、问移动构造函数的作用？
答、窃取资源。
522、如何防止编译器会认为移动操作函数会发生异常，而做一些额外的工作？
答、在函数末尾加上noexcept；
523、问什么情况下编译器会为类合成移动构造函数或移动赋值运算符？
答、当类没有定义任何自己版本的拷贝控制成员，且类的每个非static数据成员都是可以移动的。或者
一个类的成员是类类型，且该类有对应的移动操作，编译器也能移动这个成员。
524、问函数是什么？
答、计算单元。
525、short有对应的字面值吗？
答、没有。
526、函数体内的内置类型的对象如果没有初始化，则其值未定义。
527、函数体内部，如果试图初始化一个由extern关键字标记的变量，将引发错误。
扫一扫
643
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
