一、指针基础：
数据在内存中是如何存取的？
系统根据程序中定义变量的类型，给变量分配一定的长度空间。字符型占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;
}输出结果：
扫一扫
1115
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
