NO2.C++语言基础|C++和Java|常量|重载重写重定义|构造函数|强制转换|指针和引用|野指针和悬空指针|const修饰指针|函数指针(C++)

6. C++ 和 Java 区别（语⾔特性，垃圾回收，应⽤场景等）

指针：

Java 语⾔让程序员没法找到指针来直接访问内存，没有指针的概念，并有内存的⾃动管理功能，从⽽有效的防⽌了 C++ 语⾔中的指针操作失误的影响。但并⾮ Java 中没有指针， Java 虚拟机内部中还是⽤了指针，保证了 Java 程序的安全。

多重继承：

C++ ⽀持多重继承但 Java 不⽀持，但⽀持⼀个类继承多个接⼝，实现 C++ 中多重继承的功能，⼜避免了 C++ 的多重继承带来的不便。

数据类型和类：

Java 是完全⾯向对象的语⾔，所有的函数和变量必须是类的⼀部分。除了基本数据类型之外，其余的都作为类对象，对象将数据和⽅法结合起来，把它们封装在类中，这样每个对象都可以实现⾃⼰的特点和⾏为。 Java 中取消了 C++ 中的 struct 和 union 。

⾃动内存管理：

Java 程序中所有对象都是⽤ new 操作符建⽴在内存堆栈上， Java ⾃动进⾏⽆⽤内存回收操作，不需要程序员进⾏⼿动删除。⽽ C++ 中必须由程序员释放内存资源，增加了程序设计者的负担。 Java 中当⼀个对象不再被⽤到时， ⽆⽤内存回收器将给他们加上标签。 Java ⾥⽆⽤内存回收程序是以线程⽅式在后台运⾏的，利⽤空闲时间⼯作来删除。
Java 不⽀持操作符重载。操作符重载被认为是 C++ 的突出特性。
Java 不⽀持预处理功能。 C++ 在编译过程中都有⼀个预编译阶段， Java 没有预处理器，但它提供了 import 与 C++ 预处理器具有类似功能。

类型转换：

C++ 中有数据类型隐含转换的机制， Java 中需要限时强制类型转换。

字符串：

C++中字符串是以 Null 终⽌符代表字符串的结束，⽽ Java 的字符串 是⽤类对象（string 和 stringBuffer）来实现的。
Java 中不提供 goto 语句，虽然指定 goto 作为关键字，但不⽀持它的使⽤，使程序简洁易读。
Java 的异常机制⽤于捕获例外事件，增强系统容错能⼒

7. 说⼀下 C++ ⾥是怎么定义常量的？常量存放在内存的哪个位置？

对于局部常量，存放在栈区；
对于全局常量，编译期⼀般不分配内存，放在符号表中以提⾼访问效率；
字⾯值常量，⽐如字符串，放在常量区

8. C++ 中重载和重写，重定义的区别

重载

翻译⾃ overload，是指同⼀可访问区内被声明的⼏个具有不同参数列表的同名函数，依赖于C++函数名字的修饰会将参数加在后⾯，可以是参数类型，个数，顺序的不同。根据参数列表决定调⽤哪个函数，重载不关⼼函数的返回类型。

重写

翻译⾃ override，派⽣类中重新定义⽗类中除了函数体外完全相同的虚函数，注意被重写的函数不能是 static 的，⼀定要是虚函数，且其他⼀定要完全相同。要注意，重写和被重写的函数是在不同的类当中的，重写函数的访问修饰符是可以不同的，尽管 virtual 中是 private 的，派⽣类中重写可以改为 public。

重定义（隐藏）

派⽣类重新定义⽗类中相同名字的⾮ virtual 函数，参数列表和返回类型都可以不同，即⽗类中除了定义成 virtual 且完全相同的同名函数才不会被派⽣类中的同名函数所隐藏（重定义）。

9. 介绍 C++ 所有的构造函数

类的对象被创建时，编译系统为对象分配内存空间，并⾃动调⽤构造函数，由构造函数完成成员的初始化⼯作。
即构造函数的作⽤：初始化对象的数据成员。

⽆参数构造函数：

即默认构造函数，如果没有明确写出⽆参数构造函数，编译器会⾃动⽣成默认的⽆参数构造函数，函数为空，什么也不做，如果不想使⽤⾃动⽣成的⽆参构造函数，必需要⾃⼰显示写出⼀个⽆参构造函数。

⼀般构造函数：

也称重载构造函数，⼀般构造函数可以有各种参数形式，⼀个类可以有多个⼀般构造函数，前提是参数的个数或者类型不同，创建对象时根据传⼊参数不同调⽤不同的构造函数。

拷⻉构造函数：

拷⻉构造函数的函数参数为对象本身的引⽤，⽤于根据⼀个已存在的对象复制出⼀个新的该类的对象，⼀般在函数中会将已存在的对象的数据成员的值⼀⼀复制到新创建的对象中。如果没有显示的写拷⻉构造函数，则系统会默认创建⼀个拷⻉构造函数，但当类中有指针成员时，最好不要使⽤编译器提供的默认的拷⻉构造函数，最好⾃⼰定义并且在函数中执⾏深拷⻉。

类型转换构造函数：

根据⼀个指定类型的对象创建⼀个本类的对象，也可以算是⼀般构造函数的⼀种，这⾥提出来，是想说有的时候不允许默认转换的话，要记得将其声明为 explict 的，来阻⽌⼀些隐式转换的发⽣。

赋值运算符的重载：

注意，这个类似拷⻉构造函数，将＝右边的本类对象的值复制给＝左边的对象，它不属于构造函数，＝左右两边的对象必需已经被创建。如果没有显示的写赋值运算符的重载，系统也会⽣成默认的赋值运算符，做⼀些基本的拷⻉⼯作。

A a1, A a2; a1 = a2;//调⽤赋值运算符  
A a3 = a1;//调⽤拷⻉构造函数，因为进⾏的是初始化⼯作， a3 并未存在

10. C++ 的四种强制转换

C++ 的四种强制转换包括： static_cast, dynamic_cast, const_cast, reinterpret_cast

static_cast：

明确指出类型转换，⼀般建议将隐式转换都替换成显示转换，因为没有动态类型检查，上⾏转换（派⽣类->基类）安全，下⾏转换（基类->派⽣类） 不安全，所以主要执⾏⾮多态的转换操作；

dynamic_cast：

专⻔⽤于派⽣类之间的转换， type-id 必须是类指针，类引⽤或 void*，对于下⾏转换是安全的，当类型不⼀致时，转换过来的是空指针，⽽static_cast，当类型不⼀致时，转换过来的事错误意义的指针，可能造成⾮法访问等问题。

const_cast：

专⻔⽤于 const 属性的转换，去除 const 性质，或增加 const 性质， 是四个转换符中唯⼀⼀个可以操作常量的转换符。

reinterpret_cast：

不到万不得已，不要使⽤这个转换符，⾼危操作。使⽤特点： 从底层对数据进⾏重新解释，依赖具体的平台，可移植性差； 可以将整形转 换为指针，也可以把指针转换为数组；可以在指针和引⽤之间进⾏肆⽆忌惮的转换。

11. 指针和引⽤的区别

指针和引⽤都是⼀种内存地址的概念，区别呢，指针是⼀个实体，引⽤只是⼀个别名。
在程序编译的时候，将指针和引⽤添加到符号表中。

编译

指针它指向⼀块内存，指针的内容是所指向的内存的地址，在编译的时候，则是将“指针变量名-指针变量的地址”添加到符号表中，所以说，指针包含的内容是可以改变的，允许拷⻉和赋值，有 const 和⾮ const 区别，甚⾄可以为空， sizeof 指针得到的是指针类型的⼤⼩。

⽽对于引⽤来说，它只是⼀块内存的别名，在添加到符号表的时候，是将"引⽤变量名-引⽤对象的地址"添加到符号表中，符号表⼀经完成不能改变，所以引⽤必须⽽且只能在定义时被绑定到⼀块内存上，后续不能更改，也不能为空，也没有 const 和⾮ const 区别。

sizeof

sizeof 引⽤得到代表对象的⼤⼩。⽽ sizeof 指针得到的是指针本身的⼤⼩。另外在参数传递中，指针需要被解引⽤后才可以对对象进⾏操作，⽽直接对引⽤进⾏的修改会直接作⽤到引⽤对象上。

参数

作为参数时也不同，传指针的实质是传值，传递的值是指针的地址；传引⽤的实质是传地址，传递的是变量的地址。

12. 野(wild)指针与悬空(dangling)指针有什么区别？如何避免？

野指针(wild pointer)：

就是没有被初始化过的指针。⽤ gcc -Wall 编译, 会出现 used uninitialized 警告。

悬空指针：

是指针最初指向的内存已经被释放了的⼀种指针。

⽆论是野指针还是悬空指针，都是指向⽆效内存区域(这⾥的⽆效指的是"不安全不可控")的指针。 访问"不安全可控"(invalid)的内存区域将导致"Undefined Behavior"。

如何避免使⽤野指针？

在平时的编码中，养成在定义指针后且在使⽤之前完成初始化的习惯或者使⽤智能指针。

13. 说⼀下 const 修饰指针如何区分？

下⾯都是合法的声明，但是含义⼤不同：

const int * p1; 
//指向整形常量 的指针，它指向的值不能修改  
int * const p2; 
//指向整形的常量指针 ，它不能在指向别的变量，但指向（变量）的值可以修改。  
const int *const p3; 
//指向整形常量 的 常量指针 。它既不能再指向别的常量，指向的值也不能修改。

理解这些声明的技巧在于，查看关键字const右边来确定什么被声明为常量 ，如果该关键字的右边是类型，则值是常量；如果关键字的右边是指针变量，则指针本身是常量。

14. 简单说⼀下函数指针

从定义和⽤途两⽅⾯来说⼀下⾃⼰的理解：

⾸先是定义：

函数指针是指向函数的指针变量。函数指针本身⾸先是⼀个指针变量，该指针变量指向⼀个具体的函数。这正如⽤指针变量可指向整型变量、字符型、数组⼀样，这⾥是指向函数。
在编译时，每⼀个函数都有⼀个⼊⼝地址，该⼊⼝地址就是函数指针所指向的地址。有了指向函数的指针变量后，可⽤该指针变量调⽤函数，就如同⽤指针变量可引⽤其他类型变量⼀样，
在这些概念上是⼤体⼀致的。

其次是⽤途：

调⽤函数和做函数的参数，⽐如回调函数。

char * fun(char * p) {…} // 函数fun  
char * (*pf)(char * p);  // 函数指针pf
pf = fun;  // 函数指针pf指向函数fun
pf(p);     // 通过函数指针pf调⽤函数fun