[toc]

指针

指针的基本概念

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

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

指针变量的定义和使用

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

示例：

#include <iostream>

using namespace std;

int main()
{
    // 1.定义指针
    int a = 10;
    int* p = &a;

    cout << "a的地址为：" << &a << endl;
    cout << "指针p为：" << p << endl;

    // 2.使用指针
    cout << "a = " << a << endl;
    cout << "*p = " << *p << endl;
    *p = 1000;
    cout << "a = " << a << endl;
    cout << "*p = " << *p << endl;

    system("pause");

    return 0;
}

指针所占用内存空间

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

在32为操作系统下，占用4个字节空间，在64为系统下，占用8个字节空间

示例

#include <iostream>

using namespace std;

int main()
{
    // 1.定义指针
    int a = 10;
    int* p = &a;

    cout << "sizeof(int*) = " << sizeof(int*) << endl;
    cout << "sizeof(float*) = " << sizeof(float*) << endl;
    cout << "sizeof(double*) = " << sizeof(double*) << endl;
    cout << "sizeof(char*) = " << sizeof(char*) << endl;

    system("pause");
    return 0;
}

控制住和野指针

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

用途：初始化指针变量

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

示例1：空指针

#include <iostream>

using namespace std;

int main()
{
    // 1.定义空指针
    int* p = NULL;
    // 会报错
    cout << *p << endl;

}

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

示例2：野指针

#include <iostream>

using namespace std;

int main()
{
    // 1.定义野指针
    int* p = (int*)0x1100;
    // 会报错
    cout << *p << endl;
}

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

const修饰指针

const修饰指针有三种情况：

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

示例：

#include <iostream>

using namespace std;

int main()
{
    int a = 10;
    // 1.const修饰指针   常量指针
    // 特点：指针的指向可以修改，但是指针值不可以改
    const int* p = &a;
    int b = 20;

    // *p = 20;
    p = &b;

    // 2.const修饰常量 指针常量
    // 特点：指针的指向不可以改，指针的值可以改
    int* const p1 = &a;

    *p1 = 20;
    // p1 = &b;

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

    system("pause");
    return 0;
}

指针和数组

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

示例：

#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++; // 让指针偏移4个字节,64为8个字节

    cout << "利用指针返回下一个元素：" << *p << endl;

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

    int* p1 = arr;

    for (int i = 0; i < 10; i++)
    {
        cout << *p1 << endl;
        p1++;
    }

    system("pause");
    return 0;
}

指针和函数

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

示例

#include <iostream>

using namespace std;

void swapA(int a, int b)
{
    int temp = a;
    a = b;
    b = temp;
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
}

void swapB(int* p1, int* p2)
{
    int temp = *p1;
    *p1 = *p2;
    *p2 = temp;
    cout << "a = " << *p1 << endl;
    cout << "b = " << *p2 << endl;
}

int main()
{
    // 指针和函数
    int a = 10, b = 20;
    // 1. 值传递
    swapA(a, b);

    cout << "a = " << a << endl;
    cout << "b = " << b << endl;

    // 2.指针传递
    swapB(&a, &b);
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;

    system("pause");
    return 0;
}

总结：不想修改实参就用值传递，想修改实参用指针传递

指针，数组，函数

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

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

示例：

#include <iostream>

using namespace std;

// 冒泡排序
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;
            }
        }
    }
}

int main()
{
    int arr[10] = { 4,3,6,9,1,2,10,8,7,5 };

    bubbleSort(arr, 10);

    int* p = arr;
    for (int i = 0; i < 10; i++)
    {
        cout << *p << endl;
        p++;
    }

    system("pause");
    return 0;
}