C++系列内容的学习目录 → \rightarrow →​ ​​C++学习系列内容汇总​​。



1. 指针的基本概念

  指针是一个变量，其值为另一个变量的地址，即内存位置的直接地址。

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

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

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

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

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

  实例如下所示。

#include<iostream>
using namespace std;

int main()
{

  //1.定义指针
  int a = 10;
  //指针定义的语法：数据类型 * 指针变量
  int * p;
  //让指针记录变量a的地址
  p = &a;  //& 取址
  cout << "a的地址为：" << &a << endl;
  cout << "指针p为：" << p << endl;

  //2.使用指针
  //可以通过解引用的方式来找到指针指向的内存
  //指针前加 * 代表解引用，找到指针指向的内存中的数据
  cout << "a = " << a << endl;
  cout << "p = " << *p << endl;

  system("pause");

  return 0;
}

a的地址为：012FF76C

指针p为：012FF76C

a = 10

p = 10

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

      2. 利用指针可以记录地址；

      3. 对指针变量解引用，可以操作指针指向的内存。

3. 指针所占内存空间

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

  实例如下所示。

#include<iostream>
using namespace std;

int main()
{

  //指针所占内存空间
  int a = 10;
  //int * p;
  //p = &a;
  int * p = &a;

  //在32位操作系统下，指针是占4个字节空间大小，不管是什么数据类型
  //在64位操作系统下，指针是占8个字节空间大小
  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;
}

sizeof(int *) = 4

sizeof(float *) = 4

sizeof(double *) = 4

sizeof(char *) = 4

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

4. 空指针和野指针

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

  空指针的用途： 初始化指针变量。

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

  空指针的实例如下所示。

#include<iostream>
using namespace std;

int main()
{

  //空指针
  //1.空指针用于给指针变量进行初始化
  int * p = NULL;

  //2.空指针是不可以进行访问的
  //0 ~ 255之间的内存编号是系统占用的，因此不可以访问
  //* p = 100;  //引发了异常: 写入访问权限冲突。
  //cout << *p << endl;  //引发了异常: 读取访问权限冲突。

  system("pause");

  return 0;
}

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

  野指针的实例如下所示。

#include<iostream>
using namespace std;

int main()
{

  //野指针
  //在程序中，尽量避免出现野指针
  int * p = (int *)0x1100;  //地址0x1100不是我们申请的，不能对其操作

  //cout << *p << endl;  //引发了异常: 读取访问权限冲突。

  system("pause");

  return 0;
}

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

5. const修饰指针

  const修饰指针有三种情况：

  1. const修饰指针 —— 常量指针
    特点：指针的指向可以修改，但指针指向的值不可以修改。
  2. const修饰常量 —— 指针常量
    特点：指针的指向不可以修改，但指针指向的值可以修改。
  3. const既修饰指针，又修饰常量
    特点：指针的指向和指针指向的值都不可以更改。

  实例如下所示。

#include<iostream>
using namespace std;

int main()
{

  //const修饰指针
  //1.const修饰指针——常量指针
  int a = 10;
  int b = 10;

  const int * p1 = &a;
  //指针指向的值不可以修改，指针的指向可以修改
  //* p1 = 100;  //错误
  p1 = &b;

  //2.const修饰常量
  //指针的指向不可以修改，指针指向的值可以修改
  int * const p2 = &a;
  *p2 = 100;
  //p2 = &b;  //错误

  //3.const既修饰指针，又修饰常量
  const int * const p3 = &a;
  //指针的指向不可以修改，指针指向的值也不可以修改
  //*p3 = 100;  //错误
  //p3 = &b;  //错误

  system("pause");

  return 0;
}

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 * p1 = arr;  //arr就是数组的首地址
  cout << "利用指针访问第一个元素：" << *p1 << endl;
  p1++;  //让指针向后偏移4个字节
  cout << "利用指针访问第二个元素：" << *p1 << endl;

  cout << "利用指针遍历数组" << endl;
  int * p2 = arr;
  for (int i = 0; i < 10; i++)
  {
    cout << *p2 << endl;
    p2++;
  }

  system("pause");

  return 0;
}

第一个元素为：1

利用指针访问第一个元素：1

利用指针访问第二个元素：2

利用指针遍历数组

1

2

3

4

5

6

7

8

9

10

7. 指针和函数

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

  实例如下所示。

#include<iostream>
using namespace std;

//实现两个数字之间进行交换的函数
void swap1(int num1, int num2)
{
  int temp = num1;
  num1 = num2;
  num2 = temp;

  cout << "swap1 num1 = " << num1 << endl;
  cout << "swap1 num2 = " << num2 << endl;
}

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

  cout << "swap2 *p1 = " << *p1 << endl;
  cout << "swap2 *p2 = " << *p2 << endl;
}

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

  cout << "a = " << a << endl;  //实参未发生改变
  cout << "b = " << b << endl;

  //2.地址传递
  //如果是地址传递，可以修饰实参
  swap2(&a, &b);

  cout << "a = " << a << endl;  //实参发生改变
  cout << "b = " << b << endl;

  system("pause");

  return 0;
}

swap1 num1 = 20

swap1 num2 = 10

a = 10

b = 20

swap2 *p1 = 20

swap2 *p2 = 10

a = 20

b = 10

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

  • 值传递

C++基础入门（七）—— 指针_C 开发

  • 地址传递

C++基础入门（七）—— 指针_C 开发_02

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])  //如果j>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 < 10; 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;
}

1

2

3

4

5

6

7

8

9

10

  总结： 将一个数组传入到一个函数中， 需要把数组首地址传入，利用指针​​int *arr​​接收首地址。

9. 总结

C++基础入门（七）—— 指针_编程开发_03