指针

■ 作用

可以通过指针间接访问内存，可以利用指针变量保存地址

注：内存编号是从0开始记录的，一般用十六进制数字表示

■ 语法

□ 指针定义

数据类型 * 指针变量名;

□ 解引用

*指针变量

指针前加*代表解引用，找到指针指向的内存中的数据

int a = 10;  //定义整数变量a
int b = 100;  //定义整数变量b

int * p1;  //定义指针变量p1
p1 = &a;  //将指针变量p1指向整数变量a的地址

int * p2 = &b;  //定义指针变量p2，将指针变量p2指向整数变量b的地址

cout << &a << endl; //返回变量a的地址
cout << p1 << endl;  //返回变量a的地址

cout << &b << endl; //返回变量b的地址
cout << p2 << endl;  //返回变量b的地址

*p1  = 1000； //找到指针变量p指向的地址所存储的数据
cout << a << endl; //输出：1000
cout << *p << endl;  //输出：1000

*p2  = 2000； //找到指针变量p指向的地址所存储的数据
cout << b << endl; //输出：2000
cout << *p2 << endl;  //输出：2000

■ 指针所占内存空间

由于指针变量存放的数据都是地址，因此：

　　▶ 32位操作系统，占用4个字节空

　　▶ 64位操作系统，占用8个字节空间

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

cout << sizeof(int *) << endl;  //输出：4
cout << sizeof(p) << endl;  //输出：4

//指向其他数据类型的指针所占用空间也都是4个字节
cout << sizeof(float *) << endl;  //输出：4
cout << sizeof(double *) << endl;  //输出：4
cout << sizeof(char *) << endl;  //输出：4

■ 空指针和野指针

□ 空指针

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

用途：初始化指针变量

int * p = NULL;  //NULL表示0，指针变量p为空指针

*p = 100;   //运行报错，因为空指针是不可以进行访问的，0-255之间的内存编号是系统占用的，因此不可以访问

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

□ 野指针

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

int * p = (int *)0x1100; //将指针变量p随意的指向一个地址"0x1100"
cout << *p << endl;

注：在程序中，尽量避免出现野指针，因为编译是不报错的，但运行时却报错

□ 总结

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

■ const修饰指针

□ const修饰指针的三种情况

　　▶  const修饰指针，即常量指针

　　▶  const修饰常量，即指针常量

　　▶  const既修饰指针，又修饰常量

□ 常量指针

特点：指针的指向可以修改，但是指针指向的值不可以修改

int a = 10;
int b = 10;
const int * p = &a; 
*p = 20;  //错误，指针指向的值不可以改
p = &b;  //正确，指针的指向可以改

□ 指针常量

特点：指针的指向不可以修改，但是指针指向的值可以修改

int a = 10;
int b = 10;
int * const p = &a;
*p = 20;  //正确，指针指向的值可以改
p = &b;  //错误，指针的指向不可以改

□ const既修饰指针，又修饰常量

特点：指针的指向和指针指向的值都不可以修改

int a = 10;
int b = 10;
const int * const p = &a;
*p = 20;  //错误，指针指向的值不可以改
p = &b;  //错误，指针的指向不可以改

■ 指针和数组

利用指针访问数组中的元素

int arr[10] = {1,2,3,4,5,6,7,8,9,10};
int * p = arr;
count << *P << endl;  //输出：1，利用指针访问数组第1个元素
p++;  //让指针向后偏移4个字节(整型为4个字节)
count << *p << endl; //输出：2，利用指针访问数组第2个元素


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

■ 指针和函数

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

void swap01(int a, int b)
{
    int temp = a;
    a = b;
    b = temp;
}

void swap02(int *p1, int *p2)
{
    int temp = *p1;
    *p1 = *p2;
    *p2 = temp;
}

int main()
{
    int a = 10;
    int b = 20;
    swap01(a, b);
    cout << a << endl;  //输出：10
    cout << b << endl;  //输出：20
    
    swap02(&a, &b); //地址传递，可以修饰实参
    cout << a << endl;  //输出：20
    cout << b << endl;  //输出：10
}

注：若需要改变实参，则采用地址传递

　　若不需要改变实参，则采用值传递

■ 指针，数组和函数

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

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() {

    int arr[10] = { 4,3,6,9,1,2,10,8,7,5 };
    int len = sizeof(arr) / sizeof(arr[0]);
    bubbleSort(arr, len);
    printArray(arr, len);

    system("pause");
    return 0;

};