c++中易混淆的概念

（1）局部变量 全局变量 静态变量 const常量 寄存器变量 宏定义的常量 static变量
局部变量: 指在函数(过程)内部定义的变量 作用域为定义该变量的函数 内存分配: 在栈中按地址从高到低分配;
全局变量: 通常在文件开头定义(理想位置),当这些函数以及同一个程序中的其他源程序文件中的某些函数需要使用该全局变量时 在函数内部对该变量使用extern加以说明他是外部的; 作用域: 在程序的执行过程中一直有效; 初始化: 定义时不做初始化则系统将自动为其赋值数值型为0 内存分配: 从静态储存区域分配.
静态变量: 用static语句可将变量声明为静态变量; 作用域是当前的子程序模块内, 而它的生存期是到整个总程序的结束; 内存分配: 全局/静态存储区;
寄存器类型:使用关键字register声明寄存器类型的目的是将所声明的变量放入寄存器内,从而加快程序的运行速度。
（2）static作用：①函数体内static变量的作用范围为该函数体，不同于auto变量，该变量的内存只被分配一次，因此其值在下次调用时仍维持上次的值；
②在模块内的static全局变量可以被模块内所用函数访问，但不能被模块外其它函数访问；
③在模块内的static函数只可被这一模块内的其它函数调用，这个函数的使用范围被限制在声明它的模块内；
④在类中的static成员变量属于整个类所拥有，对类的所有对象只有一份拷贝；
⑤在类中的static成员函数属于整个类所拥有，这个函数不接收this指针，因而只能访问类的static成员变量。
（3）const作用:①欲阻止一个变量被改变，可以使用const关键字。在定义该const变量时，通常需要对它进行初始化，因为以后就没有机会再去改变它了；
②对指针来说，可以指定指针本身为const，也可以指定指针所指的数据为const，或二者同时指定为const；
③在一个函数声明中，const可以修饰形参，表明它是一个输入参数，在函数内部不能改变其值；
④对于类的成员函数，若指定其为const类型，则表明其是一个常函数，不能修改类的成员变量；
⑤对于类的成员函数，有时候必须指定其返回值为const类型，以使得其返回值不为“左值”。例如： const classA operator*(const classA& a1,const classA& a2);
operator*的返回结果必须是一个const对象。如果不是，这样的变态代码也不会编译出错：
classA a, b, c;
(a * b) = c; // 对a*b的结果赋值
const用法：①限定符声明变量只能被读②必须初始化
③在另一连接文件中引用const常量
extern const int i; //合法
extern const int j=10; //非法，常量不可以被再次赋值
④便于进行类型检查
用const方法可以使编译器对处理内容有更多了解。
const long &i=10; 由于编译器的优化，使得在const long i=10时i不被分配内存，而是以10直接代入以后的引用中，以致在以后的代码中没有错误，为达到说教效果，特别地用&i明确地给出了i的内存分配。不过一旦你关闭所有优化措施，即使const long i=10;也会引起后面的编译错误。
⑤可以避免不必要的内存分配
由于const定义常量从汇编的角度来看，只是给出了对应的内存地址，而不是象#define一样给出的是立即数，所以，const定义的常量在程序运行过程中只有一份拷贝，而#define定义的常量在内存中有若干个拷贝，所以每一次都需要重新分配一块内存。
⑥可以通过函数对常量进行初始化
const int i=value();假定对ROM编写程序时，由于目标代码的不可改写，本语句将会无效，不过可以变通一下，const int &i=value();只要令i的地址处于ROM之外，即可实现：i通过函数初始化，而其值有不会被修改。
优点：const常量有数据类型，而宏常量没有数据类型。编译器可以对前者进行类型安全检查，而对后者只进行字符替换，没有类型安全检查，并且在字符替换时可能会产生意料不到的错误（边际效应） const 修饰类的数据成员，const数据成员只在某个对象生存期内是常量，而对于整个类而言却是可变的。因为类可以创建多个对象，不同的对象其const数据成员的值可以不同。所以不能在类声明中初始化const数据成员，因为类的对象未被创建时，编译器不知道const 数据成员的值是什么。const数据成员的初始化只能在类的构造函数的初始化表中进行。要想建立在整个类中都恒定的常量，应该用类中的枚举常量来实现。枚举常量不会占用对象的存储空间，他们在编译时被全部求值。但是枚举常量的隐含数据类型是整数，其最大值有限，且不能表示浮点数。const位于星号的左侧，则const就是用来修饰指针所指向的变量，即指针指向为常量；如果const位于星号的右侧，const就是修饰指针本身，即指针本身是常量。
const初始化：
①非指针const常量初始化的情况：A b;
const A a = b;
②指针const常量初始化的情况：

   A* d = new A();
  const A* c = d;
  或者：const A* c = new A();
③引用const常量初始化的情况：
  A f;
const A& e = f; // 这样作e只能访问声明为const的函数，而不能访问一般的成员函数；
④修饰参数的const
调用函数的时候，用相应的变量初始化const常量，则在函数体中，按照const所修饰的部分进行常量化，如形参为const A* a，则不能对传递进来的指针的内容进行改变，保护了原指针所指向的内容；如形参为const A& a，则不能对传递进来的引用对象进行改变，保护了原对象的属性。注： 参数const通常用于参数为指针或引用的情况，且只能修饰输入参数;若输入参数采用“值传递”方式，由于函数将自动产生临时变量用于复制该参数，该参数本就不需要保护，所以不用const修饰。对于非内部数据类型的输入参数，应该将“值传递”的方式改为“const引用传递”，目的是为了提高效率。例如，将void Func(A a)改为void Func(const A &a)。对于内部数据类型的输入参数，不要将“值传递”的方式改为“const引用传递”。否则既达不到提高效率的目的，又降低了函数的可理解性。例如void Func(int x)不应该改为void Func(const int &x)。
⑤修饰返回值的const，如const A fun2( ); const A* fun3( );
这样声明了返回值后，const按照”修饰原则”进行修饰，起到相应的保护作用。
const Rational operator*(const Rational& lhs, const Rational& rhs)
{
return Rational(lhs.numerator() * rhs.numerator(),
lhs.denominator() * rhs.denominator());
}
返回值用const修饰可以防止允许这样的操作发生:
Rational a,b;
Radional c;
(a*b) = c;
一般用const修饰返回值为对象本身（非引用和指针）的情况多用于二目操作符重载函数并产生新对象的时候。
总结：
① 一般情况下，函数的返回值为某个对象时，如果将其声明为const时，多用于操作符的重载。通常，不建议用const修饰函数的返回值类型为某个对象或对某个对象引用的情况。原因如下：如果返回值为某个对象为const（const A test = A 实例）或某个对象的引用为const（const A& test = A实例） ，则返回值具有const属性，则返回实例只能访问类A中的公有（保护）数据成员和const成员函数，并且不允许对其进行赋值操作，这在一般情况下很少用到。②如果给采用“指针传递”方式的函数返回值加const修饰，那么函数返回值（即指针）的内容不能被修改，该返回值只能被赋给加const 修饰的同类型指针。如：
const char * GetString(void);
如下语句将出现编译错误：
char *str=GetString();
正确的用法是：
const char *str=GetString();
③ 函数返回值采用“引用传递”的场合不多，这种方式一般只出现在类的传值函数中，目的是为了实现链式表达。如：

class A
{…
A &operate = (const A &other); //赋值函数
}
A a,b,c; //a,b,c为A的对象
…
a=b=c; //正常
(a=b)=c; //不正常，但是合法
若赋值函数的返回值加const修饰，那么该返回值的内容不允许修改，上例中a=b=c依然正确。(a=b)=c就不正确了。

④类成员函数中const的使用
一般放在函数体后，形如：void fun() const;

任何不会修改数据成员的函数都应该声明为const类型。如果在编写const成员函数时，不慎修改了数据成员，或者调用了其他非const成员函数，编译器将报错，这大大提高了程序的健壮性。

使用const的一些建议 ：
1 要大胆的使用const，这将给你带来无尽的益处，但前提是你必须搞清楚原委；
2 要避免最一般的赋值操作错误，如将const变量赋值，具体可见思考题；
3 在参数中使用const应该使用引用或指针，而不是一般的对象实例，原因同上；
4 const在成员函数中的三种用法（参数、返回值、函数）要很好的使用；
5 不要轻易的将函数的返回值类型定为const;
6除了重载操作符外一般不要将返回值类型定为对某个对象的const引用;

思考题：

①以下的这种赋值方法正确吗？
const A* c=new A();

    A* e = c;

    这种方法不正确，因为声明指针的目的是为了对其指向的内容进行改变，而声明的指针e指向的是一个常量，所以不正确；
②以下的这种赋值方法正确吗?
A* const c = new A();
A* b = c;

这种方法正确，因为声明指针所指向的内容可变；
③这样定义赋值操作符重载函数可以吗？
const A& operator=(const A& a);
这种做法不正确；在const A::operator=(const A& a)中，参数列表中的const的用法正确，而当这样连续赋值的时侯，问题就出现了：
A a,b,c:
(a=b)=c;
因为a.operator=(b)的返回值是对a的const引用，不能再将c赋值给const常量。
附：赋值操作符必须重载成成员函数：
如果重载为A& operator = (const A& other){/* do stuff */return *this; }，则依次是a.operator=(b); a.operator=(c);
如果重载为A& operator = (A& other){/* do stuff */return other;}，则依次是a.operator=(b); b.operator=(c)；

（4）malloc/new, free/delete 之间的区别
malloc,free 是C语言的标准函数库,new/delete 是C++的运算符,他们都可以动态申请内存和释放内存；对于非内部数据类型的对象而言, 光用malloc/free无法满足动态对象的需求. 对象要创建的同时要自动执行构造函数,对象在消亡之前要执行析构函数,由于malloc/free不是运算符, 不在编译器控制权限之内,不能把构造函数和析构函数的任务强加于malloc/free上. 因此,C++语言需要一个动态内存分配和初始化的运算符new和一个能完成清理与释放内存的运算符delete。我们不要企图用malloc/free来完成动态对象的内存管理，应该用new/delete。由于内部数据类型的“对象”没有构造与析构的过程，对它们而言malloc/free和new/delete是等价的.既然new/delete的功能完全覆盖了malloc/free，为什么C++不把malloc/free淘汰出局呢？这是因为C++程序经常要调用C函数，而C程序只能用malloc/free管理动态内存。malloc/free功能还有一好处，就是可以和realloc组合使用，在需要扩大内存块时不一定会导致内存移动；而用new/delete实现时只能用new[]-copy-delete[]操作序列完成，每次都会导致内存移动。
（5）内联函数宏定义区别, 各有什么优点.
C++语言支持内联函数,目的就是为了提高函数的执行效率. 内联函数直接将代码插入调用处,从而减少了普通函数调用时的资源消耗, 要对参数类型进行检查;而宏不是函数,只是在编译前(预编译处理之前)将程序中有关字符串替换成宏体,省去了参数压栈、生成汇编语言的CALL调用、返回参数、执行return等过程, 不对参数类型进行检查；两者都能提高运行效率,但使用宏代码最大的缺点是容易出错,对于C++ 而言，使用宏代码还有另一种缺点：无法操作类的私有数据成员; C++ 语言的函数内联机制既具备宏代码的效率，又增加了安全性，而且可以自由操作类的数据成员。所以在C++ 程序中，应该用内联函数取代所有宏代码，“断言assert”恐怕是唯一的例外。
（6）内存分配有哪几种形式？分别为何？区别是什么？对编译速度影响是何？
内存分配有三种方式: ①从静态存储区域分配, 内存在编译时就已分配好, 这块内存在程序整个运行期间都存在, 如:全局变量,STATIC变量。②在栈上分配, 如函数的局部变量可以在栈上分配,函数结束时自己被释放,栈内存分配的运算内置于处理器的指令集中,效率高,内存分配是连续的,,栈是向低地址扩展的数据结构,但容量有限; ③从堆上分配,亦即动态内存分配, 程序运行时用New/Malloc分配, 程序员自己负责何时用Delete/Free释放, 若程序员不释放，程序结束时可能由操作系统回收．类似于链表，在内存中的分布不是连续的，它们是不同区域的内存块通过指针链接起来的．一旦某一节点从链中断开，我们要人为的把所断开的节点从内存中释放．动态内存的生存期由我们决定,使用灵活(堆是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存),但问题也多 。
申请效率的比较： 栈由系统自动分配，速度较快。但程序员是无法控制的。 堆是由new分配的内存，一般速度比较慢，而且容易产生内存碎片,不过用起来最方便.
（7）什么是多态（Polymorphisn) ？举个例子试试
多态性是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作.允许将子类类型的指针赋值给父类类型的指针。多态性在Object Pascal和C++中都是通过虚函数（Virtual Function） 实现的。,当子类拥有和父类同样的函数，当使用这个变量调用这个函数的时候，定义这个变量的类，也就是父类，里的同名函数将被调用，当在父类里的这个函数前加virtual关键字，那么子类的同名函数将被调用。
（8） struct 和class有什么区别？c语言中的struct 和c＋＋中的struct一样么？有什么区别？
①默认继承权限。如果不明确指定，来自class的继承按照private继承处理，来自struct的继承按照public继承处理； ②成员的默认访问权限。class的成员默认是private权限，struct默认是public权限。 如果没有多态和虚拟继承，在C++中，struct和class的存取效率完全相同！简单的说就是,存取class的data member和非virtual function效率和struct完全相同！不管该data member是定义在基类还是派生类的。③C是一种过程化的语言，struct只是作为一种复杂数据类型定义，struct中只能定义成员变量，不能定义成员函数。c++中struct还有构造函数和成员函数，其实它还拥有class的其他特性，例如继承、虚函数等。因此C++中的struct扩充了C的struct功能。④以private方式继承父类的子类对象不能访问父类的public成员。class继承默认private继承，而struct继承默认是public继承。另外，在C++模板中，类型参数前面可以使用class或typename，如果使用struct，则含义不同，struct后面跟的是“non-type template parameter”，而class或typename后面跟的是类型参数。
事实上，C++中保留struct的关键字是为了使C++编译器能够兼容C开发的程序。
C的struct与C++的class的区别：struct只是作为一种复杂数据类型定义，不能用于面向对象编程。
C++中的struct和class的区别：对于成员访问权限以及继承方式，class中默认的是private的，而struct中则是public的。class还可以用于表示模板类型，struct则不行。
（9）说说什么是野指针？野指针什么情况下出现？（没有初始化，delete后没有赋值为NULL）
野指针不是NULL指针,是指向垃圾内存的指针,也就是指向不可用内存的指针,通常对这种指针进行操作会产生不可知道的错误,人们一般不会用错NULL指针,但是野指针很危险,IF对它不起作用;
于是出现的情况有两种:①没有初始化和delete/free②没有赋值为NULL.
（10）你熟悉预编译指令么？条件编译是用来做什么的？你会写么？
预处理过程扫描源代码，对其进行初步的转换，产生新的源代码提供给编译器。可见预处理过程先于编译器对源代码进行处理.
指令 用途
# 空指令，无任何效果
#include 包含一个源代码文件
#define 定义宏
#undef 取消已定义的宏
#if 如果给定条件为真，则编译下面代码
#ifdef 如果宏已经定义，则编译下面代码
#ifndef 如果宏没有定义，则编译下面代码
#elif 如果前面的#if给定条件不为真，当前条件为真，则编译下面代码
#endif 结束一个#if……#else条件编译块
#error 停止编译并显示错误信息
条件编译指令将决定那些代码被编译，而哪些是不被编译的。可以根据表达式的值或者某个特定的宏是否被定义来确定编译条件。