05.指针和引用

目录介绍

• 5.1 指针基本概念
• 5.2 指针变量定义
• 5.3 指针所占内存空间
• 5.4 空指针和野指针
  • 5.4.1 空指针
  • 5.4.2 野指针
• 5.5 const修饰指针
• 5.6 指针和数组
• 5.7 指针和函数
• 5.8 指针数组&函数
• 5.9 引用定义和使用
  • 5.9.1 引用定义
  • 5.9.2 引用使用
  • 5.9.3 注意事项
  • 5.9.4 引用的本质
  • 5.9.5 常量引用
• 5.10 引用和函数
  • 5.10.1 引用做函数参数
  • 5.10.2 引用做函数返回值

5.1 指针基本概念

指针的作用： 可以通过指针间接访问内存

• 内存编号是从0开始记录的，一般用十六进制数字表示
• 可以利用指针变量保存地址

5.2 指针变量定义

指针变量定义语法： 数据类型 * 变量名；

示例：

int main() {
    int a = 10; //定义整型变量a
    //1、指针的定义
    //指针定义语法： 数据类型 * 变量名 ;
    int * p;
    //指针变量赋值
    p = &a; //指针指向变量a的地址
    cout << &a << endl; //打印数据a的地址
    cout << p << endl;  //打印指针变量p

    //2、指针的使用
    //通过*操作指针变量指向的内存
    cout << "*p = " << *p << endl;
    return 0;
}

指针变量和普通变量的区别

• 普通变量存放的是数据,指针变量存放的是地址
• 指针变量可以通过" * "操作符，操作指针变量指向的内存空间，这个过程称为解引用

总结1： 我们可以通过 & 符号 获取变量的地址

总结2：利用指针可以记录地址

总结3：对指针变量解引用，可以操作指针指向的内存

5.3 指针所占内存空间

提问：指针也是种数据类型，那么这种数据类型占用多少内存空间？

示例：

int main() {
    int a = 10;
    int * p;
    p = &a; //指针指向数据a的地址

    cout << *p << endl; //* 解引用
    cout << sizeof(p) << endl;
    cout << sizeof(char *) << endl;
    cout << sizeof(float *) << endl;
    cout << sizeof(double *) << endl;\
    return 0;
}
//10
//8
//8
//8
//8

总结：所有指针类型在32位操作系统下是4个字节

5.4 空指针和野指针

5.4.1 空指针

空指针：指针变量指向内存中编号为0的空间

**用途：**初始化指针变量

**注意：**空指针指向的内存是不可以访问的

示例1：空指针

int main() {
	//指针变量p指向内存地址编号为0的空间
	int * p = NULL;
	//访问空指针报错 
	//内存编号0 ~255为系统占用内存，不允许用户访问
	cout << *p << endl;
	return 0;
}

5.4.2 野指针

野指针：指针变量指向非法的内存空间

示例：野指针

int main() {
	//指针变量p指向内存地址编号为0x1100的空间
	int * p = (int *)0x1100;
	//访问野指针报错 
	cout << *p << endl;
	return 0;
}

总结：空指针和野指针都不是我们申请的空间，因此不要访问。

5.5 const修饰指针

const修饰指针有三种情况

1. const修饰指针 --- 常量指针
2. const修饰常量 --- 指针常量
3. const即修饰指针，又修饰常量

示例：

int main() {
    int a = 10;
    int b = 10;
    //const修饰的是指针，指针指向可以改，指针指向的值不可以更改
    const int * p1 = &a;
    p1 = &b; //正确
    //*p1 = 100;  报错
    //const修饰的是常量，指针指向不可以改，指针指向的值可以更改
    int * const p2 = &a;
    //p2 = &b; //错误
    *p2 = 100; //正确
    //const既修饰指针又修饰常量
    const int * const p3 = &a;
    //p3 = &b; //错误
    //*p3 = 100; //错误
    return 0;
}

技巧：看const右侧紧跟着的是指针还是常量, 是指针就是常量指针，是常量就是指针常量

5.6 指针和数组

作用：利用指针访问数组中元素

示例：

int main() {
    int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int *p = arr;  //指向数组的指针
    cout << "第一个元素： " << arr[0] << endl;
    cout << "指针访问第一个元素： " << *p << endl;
    for (int i = 0; i < 10; i++) {
        //利用指针遍历数组
        cout << *p << endl;
        p++;
    }
    return 0;
}

5.7 指针和函数

**作用：**利用指针作函数参数，可以修改实参的值

示例：

//值传递
void swap1(int a, int b) {
    int temp = a;
    a = b;
    b = temp;
}

//地址传递
void swap2(int *p1, int *p2) {
    int temp = *p1;
    *p1 = *p2;
    *p2 = temp;
}

int main() {
    int a = 10;
    int b = 20;
    swap1(a, b); // 值传递不会改变实参
    swap2(&a, &b); //地址传递会改变实参
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
    return 0;
}

总结：如果不想修改实参，就用值传递，如果想修改实参，就用地址传递

5.8 指针数组&函数

案例描述：封装一个函数，利用冒泡排序，实现对整型数组的升序排序

例如数组：int arr[10] = { 4,3,6,9,1,2,10,8,7,5 };

示例：

//值传递
void swap1(int a, int b) {
    int temp = a;
    a = b;
    b = temp;
}

//地址传递
void swap2(int *p1, int *p2) {
    int temp = *p1;
    *p1 = *p2;
    *p2 = temp;
}

int main() {
    int a = 10;
    int b = 20;
    swap1(a, b); // 值传递不会改变实参
    swap2(&a, &b); //地址传递会改变实参
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
    return 0;
}

总结：当数组名传入到函数作为参数时，被退化为指向首元素的指针

5.9 引用定义和使用

5.9.1 引用定义

5.9.2 引用使用

作用： 给变量起别名

语法： 数据类型 &别名 = 原名

示例：

void test1() {
    int a = 10;
    int &b = a;
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
    b = 100;
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
}

int main() {
    test1();
    return 0;
}

打印结果如下

//a = 10
//b = 10
//a = 100
//b = 100

5.9.3 注意事项

• 引用必须初始化
• 引用在初始化后，不可以改变

示例：

void test2() {
    int a = 10;
    int b = 20;
    //int &c;//错误，引用必须初始化
    int &c = a;//一旦初始化后，就不可以更改
    c = b; //这是赋值操作，不是更改引用
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
    cout << "c = " << c << endl;
}

int main() {
    test2();
    return 0;
}

打印结果如下

a = 20
b = 20
c = 20

5.9.4 引用的本质

本质：引用的本质在c++内部实现是一个指针常量.

讲解示例：

//发现是引用，转换为 int* const ref = &a;
void func(int & ref) {
    ref = 100; // ref是引用，转换为*ref = 100
}

void test4() {
    int a = 10;
    //自动转换为 int* const ref = &a; 指针常量是指针指向不可改，也说明为什么引用不可更改
    int& ref = a;
    ref = 20; //内部发现ref是引用，自动帮我们转换为: *ref = 20;
    cout << "a:" << a << endl;
    cout << "ref:" << ref << endl;
    func(a);
}

int main() {
    test4();
    return 0;
}

打印结果如下所示

ref2 = 20
ref2 = 0x100bb4000
ref2 = 1000
ref2 = 0x100bb4000

结论：C++推荐用引用技术，因为语法方便，引用本质是指针常量，但是所有的指针操作编译器都帮我们做了。

5.10 引用和函数

5.10.1 引用做函数参数

作用：函数传参时，可以利用引用的技术让形参修饰实参

优点：可以简化指针修改实参

示例：

//1. 值传递
void mySwap01(int a, int b) {
    int temp = a;
    a = b;
    b = temp;
}

//2. 地址传递
void mySwap02(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

//3. 引用传递
void mySwap03(int& a, int& b) {
    int temp = a;
    a = b;
    b = temp;
}

void test1() {
    int a = 10;
    int b = 20;
    mySwap01(a, b);     //值传递
    cout << "a:" << a << " b:" << b << endl;

    mySwap02(&a, &b);   //地址传递
    cout << "a:" << a << " b:" << b << endl;

    mySwap03(a, b); //引用传递
    cout << "a:" << a << " b:" << b << endl;
}

int main() {
    test1();
    return 0;
}

打印结果如下

a:10 b:20
a:20 b:10
a:10 b:20

总结：通过引用参数产生的效果同按地址传递是一样的。引用的语法更清楚简单

5.9.5 常量引用

作用：常量引用主要用来修饰形参，防止误操作

在函数形参列表中，可以加==const修饰形参==，防止形参改变实参

示例：

//引用使用的场景，通常用来修饰形参
void showValue(const int & v) {
    //v += 10; //常量不能做新的赋值
    cout << v << endl;
}

void test5() {
    //int& ref = 10;//引用本身需要一个合法的内存空间，因此这行错误
    //加入const就可以了，编译器优化代码，int temp = 10; const int& ref = temp;
    const int& ref = 10;
    //ref = 100;  //加入const后不可以修改变量
    cout << ref << endl;
    //函数中利用常量引用防止误操作修改实参
    int a = 10;
    showValue(a);
}

int main() {
    test5();
    return 0;
}

5.10.2 引用做函数返回值

作用：引用是可以作为函数的返回值存在的

注意：不要返回局部变量引用

用法：函数调用作为左值

示例：

//引用做函数返回值
//int& test01(){
//    int a = 10;
//    return a;
//}

int& test02() {
    static int a = 20;
    return a;
}

int main() {
    //不能返回局部变量的引用
//    int& ref = test01();
//    cout << "ref = " << ref << endl;
//    cout << "ref = " << &ref << endl;
    //如果函数做左值，那么必须返回引用
    int& ref2 = test02();
    cout << "ref2 = " << ref2 << endl;
    cout << "ref2 = " << &ref2 << endl;
    test02() = 1000;
    cout << "ref2 = " << ref2 << endl;
    cout << "ref2 = " << &ref2 << endl;
    return 0;
}

打印日志如下所示

ref2 = 20
ref2 = 0x102500000
ref2 = 1000
ref2 = 0x102500000