第002课 C++指针与引用

一、指针基础：

数据在内存中是如何存取的？   

      系统根据程序中定义变量的类型，给变量分配一定的长度空间。字符型占1个字节，整型数占4个字节.....。内存区的每个字节都有编号，称之为地址。

---

---

(一)、变量访问的方式： 

1、直接访问。    按变量地址存取变量的值。cin>>i;   实际上放到定义 i 单元的地址中。

例： 

#include<iostream>
using namespace std;

int main()
{
    //直接访问
    int i = 0;      
    cout << "i在内存单元地址编号:" << &i << endl;
    cout << "请输入i的值：";
    cin >> i;
    cout << "你输入i的值为：" << i << endl;
    return 0；
}

输出结果：

2、间接访问。   将变量的地址存放在另一个单元p中，通过 p 取出变量的地址，再针对变量操作。

        一个变量的地址称为该变量的指针。     如果在程序中定义了一个变量或数组，那么，这个变量或数组的地址（指针）也就确定为一个常量。

 例： 

#include<iostream>
using namespace std;

int main()
{
   //间接访问
   int* p = NULL;  
   int x = 560;
   cout << "x的地址编号：" << &x << endl;
   p = &x;
   cout << "p的值 是 x的地址编号：" << p << endl;
   cout << "输出指针变量p指向地址编号里面的值：" << *p << endl; 
   return 0;
}

输出结果：

 

(二)、变量的指针和指向变量的指针变量

       变量的指针就是变量的地址，当变量定义后，其指针（地址）是一常量。     可以定义一个变量专门用来存放另一变量的地址，这种变量我们称之为指针变量。在编译时同样分配一定字节的存储单元，未赋初值时，该存储单元内的值是随机的。 指针变量定义的一般形式为：

 数据类型标识符   *  变量名；  

int i; 
int * pt = &i ; // 定义了一个指向 int 型指针变量pt，pt 指向 i的内存单元

     一个指针变量只能指向同一类型的变量。即整型指针变量只能放整型数据的地址，而不能放其它类型数据的地址。   * 在定义语句中只表示变量的类型是指针，没有任何计算意义。

3、指针变量的引用     

      指针变量只能存放地址，不要将非地址数据赋给指针变量。

例：

#include<iostream>
using namespace std;

int main()
{
   //指针引用
   int a , b ;
   int* p1 = &a, * p2 = &b;
   *p1 = 20,  *p2 = 40;
   cout << "a=" << a << "  ,  " << "b=" << b << endl;
   cout << "*p1=" << *p1 << "  ,  " << "*p2=" << *p2 << endl;
   return 0;
}

输出结果：

4、指针变量作为函数参数     

      函数的参数可以是指针类型，它的作用是将一个变量的地址传送到另一个函数中。     指针变量作为函数参数与变量本身作函数参数不同，变量作函数参数传递的是变量的值，而指针作函数参数传递的是变量的内存地址。

二、变量引用：

      对变量取另外一个名字 (外号)，这个名字称为该变量的引用。    <类型>   &<引用变量名> = <原变量名>； 其中原变量名必须是一个已定义过的变量。如：     int   max ;     int  &refmax=max;     refmax并没有重新在内存中开辟单元，只是引用max的单元。max与refmax在内存中占用同一地址，即同一地址两个名字。

例：

#include<iostream>
using namespace std;

int main()
{
     //变量的引用
    int max = 899;
    int& refmax = max; //变量引用

    cout << "max= " << max << endl;
    cout << "refmax= " << refmax << endl;
    cout << "max的地址： " << &max << endl;
    cout << "refmax的地址： " << &refmax << endl;
    return 0;
}

输出结果：

【注】对引用类型的变量，说明以下几点：

1、引用在定义的时候要初始化。

int max;
int& refmax; //错误，没有具体的引用对象
int& refmax = max; //max是已定义过的变量

 2、对引用的操作就是对被引用的变量的操作。

3、 引用类型变量的初始化值不能是一个常数。

int i;
int& ref1 = 5; // 是错误的。
int& ref1=i; //变量i的引用

4、引用同变量一样有地址，可以对其地址进行操作，即将其地址赋给一指针。

int   a, *p;
int& m=a; //变量的引用
p = &m; //p 指向 变量的引用 m 
*p = 10; //指针的引用

 5、可以用动态分配的内存空间来初始化一个引用变量。

float& refmax = * new float ;  // 用new开辟一个空间，取一个别名refmax
refmax= 200;	// 给空间赋值
cout << refmax ;// 输出200
delete &refmax;	// 收回这个空间
//这个空间只有别名，但程序可以引用到。

float  *p,  a;
p= new  float; //用new开辟一个空间 给空指针p 

float a = * new float;//错误

6、指针与引用的区别：

(1)、指针是通过地址间接访问某个变量，而引用是通过别名直接访问某个变量。

(2)、引用必须初始化，而一旦被初始化后不得再作为其它变量的别名。 当&a的前面有类型符时（如int &a），它必然是对引用的声明；如果前面无类型符（如cout<<&a）,则是取变量的地址。

【注】以下的声明是非法的

1、企图建立数组的引用            int & a[9];

2、企图建立指向引用的指针    int & *p;

3、企图建立引用的引用            int & &px;

7、对常量（用const声明）的引用：

例：

#include<iostream>
using namespace std;

void main(void)
{
	const int& r=8; //说明变量的引用 r 为常量，不可再赋值
	cout<<"r="<<r<<endl;
	//	r+=15;		//r为常量，不可作赋值运算
	cout<<"r="<<r<<endl;
}

 输出结果：

例：

//const修饰的变量被限制为常量类型
const int x = 90;
cout << "x=" << x << endl; 
//x = 100; //不能给 常量x 赋值
//int& x_ref = x; //错误, 被限制为常量类型， 不能有变量的引用

输出结果：

8、引用与函数

      引用的用途主要是用来作函数的参数或函数的返回值。

      变量的引用作函数的形参，实际上是在被调函数中对实参变量进行操作。(与 变量作为函数的形参操作的情形有所不同。)

例：

#include <iostream>
using namespace std;

void  change(int& x, int& y) //形参为变量的引用x,y是实参a,b的别名
{
    int  t;	     
    t = x;  
    x = y;   
    y = t;
}

int main()
{
    //变量的引用 被当作函数参数使用，
   int  a = 3, b = 5;
   change(a, b);  //实参为变量a,b 
   cout << " a=" <<a  << ", b=" << b << endl;  // 调用后，是对变量a、b 的操作，输出a=5 ,  b=3 

    return 0;
}

 输出结果：

9、函数的返回值为引用类型   

     可以把函数定义为引用类型，这时函数的返回值即为某一变量的引用（别名），因此，它相当于返回了一个变量，所以可对其返回值进行赋值操作。这一点类同于函数的返回值为指针类型 。

例：

#include <iostream>
using namespace std;

int a = 4; //全局变量

int& fun(int x) //函数返回 变量a的引用，即a的别名
{
    a = a + x;
    return  a;
}

int main()
{
   //变量的引用 被当作函数的返回值使用
   int   t = 5;
   cout << " fun(t)= " <<fun(t) << endl;  //输出 fun(t)=9   
   fun(t) = 20;   //此时，fun(t)是一个变量的引用，是可以作为左值    
   cout << " fun(t)= " << fun(t) << endl;  //输出 fun(t)=25
   t = fun(t);               //t=30
   cout << " fun(t)= " << fun(t) << endl;  //输出 fun(t)=60 
   return 0;
}

 输出结果：

一个函数返回引用类型，必须返回某个类型的变量。   

  语句：  getdata()=8;     
就相当于 int & temp=8;                            
               temp=8;  

【注意】：   

        由于函数调用返回的引用类型是在函数运行结束后产生的，所以函数不能返回自动变量和形参。返回的变量的引用，这个变量必须是全局变量或静态局部变量，即存储在静态区中的变量。           我们都知道，函数作为一种程序实体，它有名字、类型、地址和存储空间，一般来说，函数不能作为左值（即函数不能放在赋值号左边）。但如果将函数定义为返回引用类型，因为返回的是一个变量的别名，就可以将函数放在左边，即给这个变量赋值。

10、 const类型变量     

      当用const 限制说明标识符时，表示所说明的数据类型为常量类型。可分为const型常量和const型指针。 可用const 限制定义 标识符常量，如：  

 const  int MaxLine =1000;    
 const  float  Pi=3.1415926  

    用const定义的标识符常量时，一定要对其初始化。在说明时，进行初始化是对这种常量设置数值的唯一方法 ，不能用赋值运算符对这种常量进行赋值。

     如：     MaxLine =35;//在定义时已赋初值，不能再更改

const型指针

1)禁写指针变量    

      声明语句格式为：

       数据类型    *  const   指针变量名 ; 如：int  r=6;      int * const  pr=&r;       则指针pr被禁写， 即pr将始终指向一个地址，成为一个指针常量。它将不能再作为左值，不能再放在赋值号的左边。     同样，禁写指针一定要在定义的时候赋初值。虽然指针被禁写，但其间接引用并没有被禁写。即可以通过*pr对r赋值。*pr=8;

例：

#include <iostream>
using namespace std;

int main()
{
 //const修饰的是 指针px , const修饰的指针变量被限制为常指针类型
 int x = 900;
 int* const px = &x; //px为常指针，初始化后，不能再指向其他处
 cout  <<" &x=" << &x << endl;
 cout <<" px=" << px << endl;
 cout <<" *px=" << *px << endl; //输出 *px=900
 *px = 799;          // *px 可修改
 cout <<" *px=" << *px << endl; //输出 *px=799
 int y = 988;
 //px = &y; //常指针px,指向y 非法, px不可修改 
 
  return 0;
}

 输出结果：

2）禁写指针间接引用

声明语句格式：  

           const  数据类型   *指针变量名;

     所声明的指针指向一禁写的实体，即间接引用不能被改写。如：  const  int  *p;。    所以程序中不能出现诸如  *p=  的语句，但指针p并未被禁写，因而可对指针p进行改写。 

 例：

#include <iostream>
using namespace std;

int main()
{
  //const 修饰的是 *pa ,
  int  a = 3, b = 5;
  const  int* pa = &b;	//可以不赋初值
  pa = &a;		//指针变量可以重新赋值
  cout <<" *pa=" << *pa << endl;   //输出3
  // *pa = 10;		//非法，指针指向的内容不能赋值
  a = 100;		//变量可以重新赋值
  cout << " *pa=" << *pa << endl;  //输出100 
  return 0;
}

输出结果：

 3)禁写指针变量又禁写指针间接引用

将上面两种情况结合起来，声明语句为下面的格式：

       const   数据类型    *const     指针变量名 ；    如：const  int  *const  px=&x；

说明：px是一个指针常量，它指向一禁写的实体，并且指针本身也被禁写。 诸如：px=  *px=    此类的语句都是非法的。 在定义时必须赋初值。

例：

#include <iostream>
using namespace std;

int main()
{
   //const 既修饰的： pa , 又修饰的： *pa
   int  a = 3, b = 5;
   const  int* const pa = &b;//必须赋初值
   //pa = &a;		//非法，指针变量不能重新赋值
   cout <<" *pa=" << *pa << endl;   //输出5
   //*pa = 10;		//非法，指针指向的内容不能赋值

 return 0;
}

 输出结果：