1.7指针 - AC

7 指针#

7.1 指针的基本概念#

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

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

7.2 指针变量的定义和使用#

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

示例：

1
#include<iostream>
2

3
int main() {
4

5
  //1、指针的定义
6
  int a = 10; //定义整型变量a
7

8
  //指针定义语法： 数据类型 * 变量名 ;
9
  int* p;
10

11
  //指针变量赋值
12
  p = &a; //指针指向变量a的地址
13
  std::cout << &a << std::endl; //打印数据a的地址
14
  std::cout << p << std::endl;  //打印指针变量p
15

16
  //2、指针的使用
17
  //通过*操作指针变量指向的内存
18
  std::cout << "*p = " << *p << std::endl;
19

20
  return 0;
21
}

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

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

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

总结2：利用指针可以记录地址

总结3：对指针变量解引用，可以操作指针指向的内存

7.3 指针所占内存空间#

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

示例：

1
#include<iostream>
2

3
int main() {
4

5
  int a = 10;
6

7
  int* p;
8
  p = &a; //指针指向数据a的地址
9

10
  std::cout << *p << std::endl; //* 解引用
11
  std::cout << sizeof(p) << std::endl;
12
  std::cout << sizeof(char*) << std::endl;
13
  std::cout << sizeof(float*) << std::endl;
14
  std::cout << sizeof(double*) << std::endl;
15

16
  return 0;
17
}

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

7.4 空指针和野指针#

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

用途：初始化指针变量

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

示例1：空指针

1
#include<iostream>
2

3
int main() {
4

5
  //指针变量p指向内存地址编号为0的空间
6
  int* p = NULL;
7

8
  //访问空指针报错
9
  //内存编号0 ~255为系统占用内存，不允许用户访问
10
  std::cout << *p << std::endl;
11

12
  return 0;
13
}

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

示例2：野指针

1
#include<iostream>
2

3
int main() {
4

5
  //指针变量p指向内存地址编号为0x1100的空间
6
  int* p = (int*)0x1100;
7

8
  //访问野指针报错
9
  std::cout << *p << std::endl;
10

11
  return 0;
12
}

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

7.5 const修饰指针#

const修饰指针有三种情况

const修饰指针 --- 常量指针
const修饰常量 --- 指针常量
const即修饰指针，又修饰常量

示例：

1
#include<iostream>
2

3
int main() {
4

5
  int a = 10;
6
  int b = 10;
7

8
  //const修饰的是指针，指针指向可以改，指针指向的值不可以更改
9
  // 就是 const * 代表取*后的数是常量不能变
10
  const int* p1 = &a;
11
  p1 = &b; //正确
12
  //*p1 = 100;  报错
13

14

15
  //const修饰的是常量，指针指向不可以改，指针指向的值可以更改
16
  // 代表 const 后面的指针变量不能变
17
  int* const p2 = &a;
18
  //p2 = &b; //错误
19
  *p2 = 100; //正确
20

21
  //const既修饰指针又修饰常量
22
  const int* const p3 = &a;
23
  //p3 = &b; //错误
24
  //*p3 = 100; //错误
25

26
  return 0;
27
}

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

7.6 指针和数组#

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

示例：

1
#include<iostream>
2

3
int main() {
4

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

7
  int* p = arr;  //指向数组的指针
8

9
  std::cout << "第一个元素： " << arr[0] << std::endl;
10
  std::cout << "指针访问第一个元素： " << *p << std::endl;
11

12
  for (int i = 0; i < 10; i++)
13
  {
14
    //利用指针遍历数组
15
    std::cout << *p << std::endl;
16
    p++;
17
  }
18

19
  return 0;
20
}

7.7 指针和函数#

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

示例：

1
#include<iostream>
2

3
//值传递
4
void swap1(int a, int b)
5
{
6
  int temp = a;
7
  a = b;
8
  b = temp;
9
}
10
//地址传递
11
void swap2(int* p1, int* p2)
12
{
13
  int temp = *p1;
14
  *p1 = *p2;
15
  *p2 = temp;
16
}
17

18
int main7() {
19

20
  int a = 10;
21
  int b = 20;
22
  swap1(a, b); // 值传递不会改变实参
23

24
  swap2(&a, &b); //地址传递会改变实参
25

26
  std::cout << "a = " << a << std::endl;
27

28
  std::cout << "b = " << b << std::endl;
29

30
  return 0;
31
}

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

7.8 指针、数组、函数#

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

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

示例：

1
#include<iostream>
2

3
//冒泡排序函数
4
void bubbleSort(int* arr, int len)  //int * arr 也可以写为int arr[]
5
{
6
  for (int i = 0; i < len - 1; i++)
7
  {
8
    for (int j = 0; j < len - 1 - i; j++)
9
    {
10
      if (arr[j] > arr[j + 1])
11
      {
12
        // *(arr + j) 等价于 arr[j]
13
        int temp = arr[j];
14
        arr[j] = arr[j + 1];
15
        arr[j + 1] = temp;
16
      }
17
    }
18
  }
19
}
20

21
//打印数组函数
22
void printArray(int arr[], int len)
23
{
24
  for (int i = 0; i < len; i++)
25
  {
26
    std::cout << arr[i] << std::endl;
27
  }
28
}
29

30
int main() {
31

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

35
  bubbleSort(arr, len);
36

37
  printArray(arr, len);
38

39
  return 0;
40
}

总结：当数组名传入到函数作为参数时，被退化为指向首元素的指针