一、概述

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

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

  • 可以利用指针变量保存地址

    二、指针变量的定义和使用

    指针变量定义语法： 数据类型 变量名;
    *示例1：

    1. #include <iostream>
    2. using namespace std;
    3. int main()
    4. {
    5.   int a = 10;
    6.   int *p;
    7.   p= &a;
    8.   cout << "a的地址为:"<< p << endl;
    9.   return 0;
    10. }

    结果：
    image.png
    示例2：

    #include <iostream>
using namespace std;
int main()
{
  int a = 10;
  int *p;
  p= &a;
  cout << "a的值为:"<< *p << endl;
  return 0;
}

    结果：
    image.png
    注意:“&”代表取址符，就是获取一个变量的内存地址，”*”代表解引用，是获取该指针地址内存储的实际的值

    三、指针占用的内存空间

  • 在32位操作系统下指针占用4个字节

  • 在64位操作系统下指针占用8个字节

示例：

#include <iostream>
using namespace std;
int main()
{
    cout << "sizeof(int *)所占用的空间为：" << sizeof(int *) << endl;
    cout << "sizeof(float *)所占用的空间为：" << sizeof(float *) << endl;
    cout << "sizeof(double *)所占用的空间为：" << sizeof(double *) << endl;
    cout << "sizeof(char *)所占用的空间为：" << sizeof(char *) << endl;
    return 0;
}

image.png

四、空指针和野指针

空指针：指针变量指向内存中编号为0的空间 int p=NULL
用途：初始化指针变量
注意：空指针指向的内存是不可以访问的
*示例1：空指针

int main()
{
int *p=NULL;      //1、空指针用于给指针变量进行初始化
cout<<*p<<endl; 
}

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

int *p=(int*)0x1100;  //指针指向0x1100这个地址
cout<<*p<<endl;

结果：
image.png
注意：空指针和野指针都是不能够访问的空间

五、const修饰指针

const修饰指针有三种情况：

  • const修饰指针：常量指针
  • const修饰常量 ：指针常量
  • const即修饰针指，又修饰常量

示例：常量指针

const int *p=NULL;

#include <iostream>
using namespace std;
int main()
{
    int a = 1, b = 2;
    const int* p = NULL;
    p = &b;
    cout << p << endl;
    cout << *p << endl;
    p = &a;
    cout << p << endl;
    cout << *p << endl;
    return 0;
}

结果：
image.png
特点：指针的指向可以修改，但是指针指向的值不可以改
示例：指针常量

int * const p=&a;

#include <iostream>
using namespace std;
int main()
{
    int a = 1, b = 2;
    int * const p = &b;
    cout << p << endl;
    cout << *p << endl;
    *p = a;
    cout << p << endl;
    cout << *p << endl;
    return 0;
}

结果：
image.png
特点：指针的指向不可以修改，但是指针指向的值可以改
示例：const既修饰指针又修饰常量

const int * const p=&a;

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

六、指针和数组的使用

作用：利用指针访问数组内的每个元素
示例：

#include <iostream>
using namespace std;
int main()
{
    int arry[10] = { 1,2,3,4,5,6,7,8,9,10 };
    cout << "数组的第一个元素:" << arry[0] << endl;
    int* p = arry;
    cout << "利用指针访问数组的第一个元素:" << *p << endl;
    p++;
    cout << "移动指针访问数组的第二个元素:" << *p << endl;
    return 0;
}

结果：
image.png
注意：如果指针指向数组名，数组名就是数组的首地址，如果指针和数组为相同的数据类型，比如都是int类型，那么p++指针就会自动向后移动4个字节，就是下第二个元素的地址

七、指针和函数

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

#include <iostream>
using namespace std;
void swap(int* a, int* b)
{
    cout << "交换前:a= " << *a << " b= " << *b << endl;
    int temp = *a;
    *a = *b;
    *b = temp;
    cout << "交换后:a= " << *a << " b= " << *b << endl;
}
int main()
{   
    int a=10; 
    int b=20;
    swap(&a, &b);
    cout << "实际a= " << a << " 实际b= " << b << endl;
    return 0;
}

结果：
image.png
注意：这里是实现的地址交换，我们看到地址交换会将实参的内容改变

八、指针、数组、函数

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

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

#include <iostream>
using namespace std;
void maopao(int *arry,int len)
{
    int temp;
    for (int i = 0; i < len - 1; i++)
    {
        for (int j = 0; j < len - i - 1; j++)
        {
            if (arry[j] > arry[j + 1])
            {
                temp = arry[j];
                arry[j] = arry[j+1];
                arry[j+1] = temp;
            }
        }
    }
}
void print(int* arry, int len)
{
    for (int i = 0; i < len; i++)
    {
        cout << arry[i] << endl;
    }
}
int main()
{   
    int arry[10] = { 4,3,6,9,1,2,10,8,7,5 };
    int len = sizeof(arry) / sizeof(arry[0]);
    maopao(arry, len);
    print(arry, len);
    return 0;
}

结果：
image.png