思科的一道面试题如下：
 
 
不要用编译器  用1分钟事件思考下
 
源文件A：
 int a[10];
 int *b=a;
 
 源文件B:
 extern int *a;
 extern int b[];
 int x,y;
 ...
 x=a[3];
 y=b[3];
 
  
解释执行两条赋值语句时会发生什么？
 

 
 
ChinaUnix里面有一高人的解释如下：
 
 
这个问题不会产生编译错误和链接错误，也就是说程序是合法的。当然运行时是会出问题的。指针本身的标识需要占用一个int长的空间；数组本身的标识是不占地方的，把数组第一个元素的地址作为数组的标识。所以这个问题有趣的地方在这里。
 
 

 
 
编译时
 
 
B里面编译器认为a是指针，所有它认定这个指针在某个地方占了一个int长。B里面编译器认为b是数组，所有它认定这个数组的地址是某个地方的第一个元素地址。
  
A里面编译器认为a是数组，b是指针，这是很直接的。
 

 
 
链接时
  
缺的都是符号，刚好有，所有连上去了B(a)=A(a),B(b)=A(b)
 

 
 
运行时
 
因为B(a)被认为是指针，所以运行的时候那个地址应该是一个int长来存放它的内容，所以它把A(a)的第一个int长作为指针的空间，所以A(a)的第一个数组元素的值就做了指针的值。
 因为B(b)被认为是数组，所以运行的时候那个地址应该是一个数组的首元素地址，所以B(b)的第一个元素应该保存的是a的地址。
  
也就是说，如果A(a) = {n,......};，那么B(a)=n，B(b)=&A(a)
 

 
 
链接之后，b[3]是随机的，但是b[0]=&a和a=n是确定的。
 

 
 
讨论参见http://bbs.chinaunix.net/thread-3705891-1-1.html
 

引用（reference）用作对象的另一名字。在实际程序中，引用主要用作函数的形式参数。在这里，我们用独立的对象来介绍并举例说明引用的用法。
 
引用是一种复合类型（compound type），通过在变量名前添加“＆”符号来定义。复合类型是指用其他类型定义的类型。在引用的情况下，每一种引用类型都“关联到”某一其他类型。不能定义引用类型的引用，但可以定义任何其他类型的引用。
 
引用必须用和该引用同类型的对象初始化：
 
int ival = 1024;

int &refVal = ival; // ok: refVal refers to ival

int &refVal2; // error: a reference must be initialized

int &refVal3 = 10; // error: initializer must be an object
 
引用是别名
 
因为引用只是它绑定的对象的另一名字，作用在引用上的所有操作事实上都是作用在该引用绑定的对象上：
 
refVal += 2;
 
将refVal指向的对象ival加2。类似地，
 
int ii = refVal;
 
把和ival相关联的值赋给ii。
 
当引用初始化后，只要该引用存在，它就保持绑定到初始化时指向的对象。不可能将引用绑定到另一个对象。
 
要理解的重要概念是引用只是对象的另一名字。事实上，我们可以通过ival的原名访问ival，也可以通过它的别名refVal访问。赋值只是另外一种操作，因此当我们编写
 
refVal = 5;
 
效果是把ival的值修改为5。这一规则的结果是必须在定义引用时进行初始化。初始化是指明引用指向哪个对象的唯一方法。
 
定义多个引用
 
可以在一个类型定义行中定义多个引用。必须在每个引用标识符前添加“&”符号：
 
int i = 1024, i2 = 2048;

int &r = i, r2 = i2; // r is a reference, r2 is an int

int i3 = 1024, &ri = i3; // defines one object, and one reference

int &r3 = i3, &r4 = i2; // defines two references
 
const引用
 
const引用是指向const对象的引用：

const int ival = 1024;

const int &refVal = ival; // ok: both reference and object are const

int &ref2 = ival; // error: nonconst reference to a const object
 
可以读取但不能修改refVal，因此，任何对refVal的赋值都是不合法的。这个限制有其意义：不能直接对ival赋值，因此不能通过使用refVal来修改ival。
 
同理，用ival初始化ref2也是不合法的：ref2是普通的非const引用（nonconst reference），因此可以用来修改ref2指向的对象的值。通过ref2对ival赋值会导致修改const对象的值。为阻止这样的修改，须要规定将普通的引用绑定到const对象是不合法的。
 
术语：const引用是指向const的引用
 
C++程序员常常随意地使用术语const引用。严格来说，“const引用”的意思是“指向const对象的引用”。类似地，程序员使用术语“非const引用”表示指向非const类型的引用。这种用法非常普遍，我们在本书中也遵循这种用法。
 
const引用可以初始化为不同类型的对象或者初始化为右值（2.3.1节），如字面值常量：
 
int i = 42;

// legal for const references only

const int &r = 42;

const int &r2 = r + i;
 
同样的初始化对于非const引用却是不合法的，而且会导致编译时错误。其原因非常微妙，值得解释一下。
 
观察将引用绑定到不同的类型时所发生的事情，最容易理解上述行为。假如我们编写
 
double dval = 3.14;

const int &ri = dval;
 
编译器会把这些代码转换成如以下形式的编码：
 
int temp = dval; // create temporary int from the double

const int &ri = temp; // bind ri to that temporary
 
如果ri不是const，那么可以给ri赋一新值。这样做不会修改dval，而是修改了temp。期望对ri的赋值会修改dval的程序员会发现dval并没有被修改。仅允许const引用绑定到需要临时使用的值完全避免了这个问题，因为const引用是只读的。
 
非const引用只能绑定到与该引用同类型的对象。
 
const引用则可以绑定到不同但相关的类型的对象或绑定到左值。

Google C++ Coding Style定义
 
输入参数以值或者const引用形式传入，输出参数使用指针。 所有以引用形式输入参数必须加上const，即const T&的形式。
 
即如下形式:
 
void Foo(const string &in, string *out);
 
在如下情况下, 可以使用const T*的形式: 
 * 需要进行指针的判空 (即空指针是合理的)。 
 * 需要使用到输入参数的指针或引用形式。
 
为什么要使用const T&形式?
 
以值传入是最为安全的形式，因为它总是提供一个复本到函数中。对于复杂的参数（结构或类），这也引入了不必要的拷贝的开销。使用指针及引用都可以解决这个问题。而引用则更为安全，可以避免一些不必要的空指针判断。所以输入参数以const T&的形式的定义, 与传递值的语义相似，既避免了拷贝，又避免了意外修改。
 
下面这个例子，则表现出函数即使定义为const T&形式，仍然可能出现空指针引入的问题:
 
 void test(const A& a) { 
    a.max = 10;
 }

 A* b = NULL;
 test(*b);
 
这是一个错误使用引用的示范，语法上合法，但这样的实现是不允许的。判空的责任在于调用者，而不在函数。（参考:How do you check for NULL when passing by reference in C++?）
 
另外，因为传引用，在其本质也是以指针形式提供的，所以在性能相对于传值会低一些的。所以简单的数据类型还是要传值。
 
输出参数为什么是指针呢
 
以引用和指针的形式，都可以作为函数的输出参数。如果没有const修饰引用，则引用形式的参数就可以成为一个输出参数。这可能会让代码的读者对参数的类型产生错觉。正是Google C++ Coding Style中所描的: 引用有着和值类的语法，但却是指针的语义。代码的读者会对能不能改变一个参数的值产生疑问, 以为传入的是Value, 但值却改变了。虽然看一下函数声明就可以了，但如果一个大型项目，还是要追求做到一目了然。
 
总结
 
作为编码规范定义出来的，主要是为了统一大家的编码习惯，减少一些”惊喜”。单纯从传值，传引用，亦或传指针的形式，cplusplus.com上的一篇也可以作为参考When to pass parameters by value, reference, and pointer。总结一下参数三种传入形式的核心点: 
 1. 传值性能最高，但有拷贝的开销。 
 2. 传引用时空值是不合法的，不用判空，没有拷贝的开销。 
 3. 传指针时空值是合法的，需要判空，也没有拷贝的开销。

从Java到C++——指针与引用
   
C++即有指针又有引用，而且很多时候具有相似的功能，常常容易让人混淆，着实让人头痛。用两句通俗的话说明两者本质的含意：引用就是一个变量或对象的别名（引用的本质是一个对象）；指针是一个段内存空间的地址(指向存储一个变量值的空间或一个对象的空间)；如下图所示：
   

 
C++中的引用与指针
   
引用
   
引用是为变量或对象起的另外一个别名，定义形式：T& v;  T为类型，v为变量名。使用引用时，注意以下几点：
   
1.引用在创建的时候必须被初始化（指针可以在任何时候赋值）
   
2.一旦引用初始化后，就不能改变引用所指向的变量(或对象)，一直和该变量(或对象)邦定在一起。
   
3.引用必须与一个确定的合法内存单元相关联。不存在NULL引用。(指针可以为NULL)
   
下面用例子来解释，【例1】：
   
void Reference()
       
{
       
//int &r1; //不符第1要点， 报错  Error:refercece value "r" requires an intializer
       
//int & r2 = 100; //非const类型的引用，不能与常量邦定在一起
       
int i = 10;
       
int &r3 = i; //引用r2与变量i邦定在一起，符合第1要点
       
cout << "初始值  i:" << i << "   r3:"  << r3 << endl;
       
i = 15; //改变i的值，r3跟着改变，因为i和r3是指向同一块内存,符合第2要点
       
cout << "改变i   i:" << i << "   r3:"  << r3 << endl;
       
r3 = 20; //改变r3的值，i跟着改变，因为i和r3是指向同一块内存是，符合第2要点
       
cout << "改变r3  i:" << i << "   r3:"  << r3 << endl;
       
int i2 = 25;
       
r3 = i2; //并不是引用r3指向了变量i2，而是i2的值赋给了变量i(r3所指向的变量)，符合第2要点
       
cout << "赋值r3  i:" << i << "   r3:"  << r3 << "   i2:" << i2 << endl;
       
int& r4 = r3; //用引用r3指向的变量i的值初始化引用r4，所用r3,r4邦定的是同一个变量i；r3、r4、i指向同一块内存
       
cout << "引用r4  i:" << i << "   r3:"  << r3 << "   r4:" << r4 << endl;
       
Data d;
       
Data& rData = d; //也可对对象进行引用，原理与变量一样。
       
cout << "d.iVal:" << d.iVal << "   rData.iVal:" << rData.iVal << endl;
       
d.iVal = 8;
       
cout << "d.iVal:" << d.iVal << "   rData.iVal:" << rData.iVal << endl;
       
}
       
结果：
   
初始值  i:10   r3:10
   
改变i   i:15   r3:15
   
改变r3  i:20   r3:20
   
赋值r3  i:25   r3:25   i2:25
   
引用r4  i:25   r3:25   r4:25
   
d.iVal:0   rData.iVal:0
   
d.iVal:8   rData.iVal:8
   
 
我们也可以用debug模式对它进行调试，这样可以看到各个变量的内存地址，如下：
   

 
 
指针
   
指针是指向另外一个类型的复合类型，定义形式：T* p; T为类型，p为指针变量。与引用类似，指针也实现了其它变量或对象的间接访问。使用指针变量p时，在p的前面加上*(即：*p)就是解引用符，用来访问指针所指向的对象。指针具有以下特点：
   
1.指针本身就是一个对象，允许对指针进行赋值和拷贝；
   
2.指针的生命周期内它可以先后指向几个不同的对象；
   
3.指针无须在定义时赋初值；
   
4.与内置类型一样，如果指针没有初始化，将指向一个不确定的值；
   
5.不能定义指向引用的指针(因为引用不是对象，没有实际的地址)。
   
【例2】
   
void TestPointer()
       
{
       
double* p1; //定义一个指向double类型的指针p1，指针未被初始化，可能指向任意一个地址
       
double dVal1 = 2; 
       
p1 = &dVal1; //给指针p1赋值, &是取地址符,也就是把dVal1的地址赋给p1
       
cout << "p1:" << p1 << "   *p1:" << *p1 << endl; //*是解引用符，*p1也就是获取指针p1所指向的变量dVal1的值
       
double* p2 = p1; //定义指针p2，同时将p1的值赋给p2，这时p1和p2指向同一个地址
       
cout << "p1:" << p1 << "   p2:" << p2 << "   *p1:" << *p1 << "   *p2:" << *p2 << endl;
       
}
       
结果：
   
p1:001AF6B8
   
*p1:2
   
p1:001AF6A8   p2:001AF6A8   *p1:5   *p2:5
   
 
我们也可以用debug模式对它进行调试，这样可以看到各个变量的内存地址，如下：
   

 
指针的值的状态
    
指针的值(即地址)应是下面四种状态之一：
   
1.指向一个对象(或内置类型变量)；
   
2.指向紧邻对象所占空间的下一个位置；
   
3.空指针，意味着没有指向任何对象；
   
4.无效指针，也就是以上情况之外的其它值。
   
举例解释【例3】
   
void TestPointer2()
       
{
       
short sInt = 65;
       
short *sP; //状态4，未被初始化，无效指针
       
//cout << sP << endl; //错误，将报异常：The variable 'sP' is being used without being initialized.
       
sP = &sInt; //状态1，指向变量ch
       
cout << "cP:" << sP << "  *cP:" << *sP << endl;
       
sP ++; //状态2，指向变量sInt所在地址的下一个地址
       
cout << "cP:" << sP << endl;
       
sP = NULL; //状态3，空指针
       
cout << "cP:" << sP << endl;
       
}
       
结果：
   
cP:0037FD54  *cP:65
   
cP:0037FD56
   
cP:00000000
   
 
 
易错点
   
对于初学者或是从其它语言转向c++的人来说，指针和引用这部分比较难，我觉得主要有以下几点，也是大家需要注意的：
   
 
1.&符号的多意性(多个用途)
   
&即用在引用也用在指针。定义引用变量，一般在“=”的左侧，在类型后加&符号(如果是在一行内定义多个引用，则每个变量名前加&)；表示取变量地址，一般在“=”的右侧用于给指针赋值，&在变量名前面。
   
void TestSymbol()
       
{
       
int nVal1 = 5;
       
int nVal2 = 6;
       
int nVal3 = 9;
       
int& rVal1 = nVal1; //定义引用
       
int &rVal2 = nVal2, &rVal3 = nVal3; //定义引用
       
cout << "rVal1:" << rVal1 << "  rVal2:" << rVal2 << "  rVal3:" << rVal3 << endl;
       
 
int *p1, *p2, *p3;
       
p1 = &nVal1; //取nVal1的地址，给p1赋值
       
p2 = &nVal2, p3 = &nVal3; //取nVal2, nVal3地址，分别给p2、p3赋值
       
cout << "*p1:" << *p1 << "  *p2:" << *p2 << "  *p3:" << *p3 << endl;
       
}
       
 
2.引用和指针的定义
   
一行内定义多个引用，每个引用前都要加&；一行内定义多个指针，每个引用前都要加*。引用的类型要和它所邦定的变量或对象匹配；指针的类型要和它所指向的变量或对象匹配。
   
void ReferencePointer()
       
{
       
int nVal1 = 10;
       
int nVal2 = 20;
       
int &rVal1 = nVal1, &rVal2 = nVal2;
       
cout << "rVal1:" << rVal1 << "  rVal2:" << rVal2 << endl;
       
int *p1 = &nVal1, *p2 = &nVal2, *p3 = &nVal2; //p2和p3指向同一个地址
       
cout << "*p1:" << *p1 << "    *p2:" << *p2 << endl;
       
double dVal = 10.125;
       
//double& rDVal = nVal1; //类型不匹配，编译错误
       
//double *p = &nVal1; //类型不匹配，编译错误
       
}
       
结果：
   
rVal1:10  rVal2:20
   
*p1:10    *p2:20