C++学习笔记（三）（指针）

本笔记主要来源于教程https://www.bilibili.com/video/av41559729?p=1

7 指针

7.1 指针的基本概念

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

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

7.2 指针变量的定义和使用

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

int a=10;
int *p;
p=&a;
//指针p就是a的地址，&为取址符，&a和p的输出结果相同。

使用指针：

//可以通过解引用的方式找到指针指向的内存
//指针前加*代表解引用，找到指针指向内存中的数据
*p=1000;
//改变*p等同于改变a的值，现在a=1000

7.3 指针所占内存空间

提问：指针也是一种数据类型，那么这种数据类型占用多少内存空间？
答：32位操作系统无论是什么数据类型都占4个字节，64位则是8个字节。一般开发都是在32位系统下。

7.4 空指针和野指针

空指针：指针变量指向内存中编号为0的空间。
用途：初始化指针变量
注意：空指针指向的内存是不可以访问的。

#include< iostream>
using namespace std;

int main()
{
    //空指针
    //1.空指针用于给指针变量初始化
    int *p = NULL;


    //2.空指针是不可以进行访问的
    //0~255之间的内存编号是系统占用的，因此不可以访问
    *p = 100;//只要有*p的操作编译就会出错

    system("pause");

    return 0;
}

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

#include< iostream>
using namespace std;

int main()
{
    //野指针
    //在程序中，尽量避免出现野指针
    int *p = (int *)0x1100;//此地址并没有申请使用所以无法操纵
    cout << *p << endl;//一旦操纵就会报错

    system("pause");

    return 0;
}

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

7.5 const修饰指针

const修饰指针有三种情况：

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

    int a = 10;
    int b = 10;
    int *p = &a;


    //1.const修饰指针——常量指针
    const int *p = &a;
    //特点：指针的指向可以修改，但是指针指向的值不可以改。
    *p = 20;//错误，指针指向的值不可以修改
    p = &b;//正确，指针的指向可以改

    //2.const修饰常量——指针常量
    int * const p = &a;
    //特点：指针的指向不可以改，指针指向的值可以改
    *p = 20;//正确，指向的值可以改
    p = &b;//错误，指针的指向不可以修改

    //3.const即修饰指针，又修饰常量
    const int *const p = &a;
    //特点：指针的指向和指向的值都不可以修改
    *p = 20;//错误
    p = &b;//错误

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

7.6 指针和数组

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

#include< iostream>
using namespace std;

int main()
{
    //指针和数组
    //利用指针访问数组中的元素
    int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };

    cout << "第一个元素为 " << arr[0] << endl;

    int *p = arr;//arr就是数组的首地址

    cout << "利用指针来访问第一个元素为： " << *p << endl;

    p++;//让指针向后偏移四个字节

    cout << "利用指针来访问第二个元素为： " << *p << endl;

    cout << "用指针遍历数组" << endl;

    int *p2 = arr;
    for (int i = 0; i < 10; i++)
    {
        //cout << arr[i] << endl;
        cout << *p2 << endl;
        p2++;
    }


    system("pause");
    return 0;

}

7.7 指针和函数

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

#include< iostream>
using namespace std;

//实现两个数字进行交换
void swap01(int a, int b)
{
    int temp = a;
    a = b;
    b = temp;
    cout << "swao01 a= " << a << endl;
    cout << "swap01 b= " << b << endl;
}
void swap02(int*p1, int*p2)
{
    int temp = *p1;
    *p1 = *p2;
    *p2 = temp;
}
int main()
{
    //指针和函数
    //1.值传递(swap里a和b发生了变化，但实际函数里ab未发生变化)
    int a = 10;
    int b = 20;
    //swap01(a, b);

    //2.地址传递
    //如果是地址传递，可以修饰实参（ab改变了）
    swap02(&a, &b);
    cout << "a= " << a << endl;
    cout << "b= " << b << endl;


    system("pause");
    return 0;

}

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

7.8 指针、数组、函数

案例描述：封装一个函数，利用冒泡排序，实现对整型数组的升序排序。
例如数组：int arr[10]={4,3,6,9,1,2,10,8,7,5};

#include< iostream>
using namespace std;

//冒泡排序函数  参数1 数组的首地址  参数2 数组的长度
void bubbleSort(int *arr,int len)
{
    for (int i = 0; i < len - 1; i++)
    {
        for (int j = 0; j < len - i - 1; j++)
        {
            if (arr[j] > arr[j + 1])
            {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}
//打印数组
void printArray(int *arr, int len) 
{
    for (int i = 0; i < len;i++)
    {
        cout << arr[i] << endl;
    }
}

int main()
{
    //1.先创建数组
    int arr[10] = {4,3,6,9,1,2,10,8,7,5};

    //数组长度
    int len = sizeof(arr) / sizeof(arr[0]);
    //2.创建函数，实现冒泡排序
    bubbleSort(arr, len);

    //3.打印排序后的数组
    printArray(arr, len);

    system("pause");
    return 0;

}

 
最后欢迎大家访问我的个人博客青蛙听禅的博客