深入 C++ 和 C 的指针世界

13天前 17.7k 0

在C和C++编程中,指针是一个至关重要的概念。从初学者到高级开发者,掌握指针的使用不仅能提高代码效率,还能增强对内存管理的理解。

深入 C++ 和 C 的指针世界-1

一、初级:指针基础

1.什么是指针?

指针是一个变量,其值为另一个变量的地址。简单来说,指针存储的是内存地址而不是数据本身。

#include 
int main() 
{
  int a = 10;
  int* p = &a; // p 是一个指向 a 的指针
  
  printf("a 的值: %d\n", a); // 输出 10
  printf("p 指向的地址: %p\n", p); // 输出 a 的地址
  printf("*p 的值: %d\n", *p); // 输出 10 (解引用指针 p 获取值)
  
  return 0;
}

在上面的例子中,int* p 声明了一个指向整型变量的指针 p,并将 a 的地址赋给了它。*p 用于解引用指针,从而获得 a 的值。

2.指针的基本操作

  • 声明指针:int* p;
  • 获取变量地址:p = &a;
  • 解引用指针:*p

3.指针和数组

指针和数组密切相关。在很多情况下,指针可以用来遍历数组。

#include 
int main() {
int arr[] = {1, 2, 3, 4, 5};
int* p = arr; // p 指向数组的第一个元素

for (int i = 0; i < 5; i++) {
printf("%d ", *(p + i)); // 使用指针遍历数组
}

return 0;
}

4.指针数组 

数组中的元素是指针类型,可以用来存储一组指针。

int x = 10, y = 20, z = 30;
int *ptrArr[3] = {&x, &y, &z};
printf("Second element: %d\n", *ptrArr[1]); // 访问指针数组的第二个指针所指向的值

5.数组指针(pointer to an array) 

是一种指向数组的指针,它与指向数组第一个元素的普通指针不同。数组指针的主要用途是在处理多维数组时更加方便。这里详细介绍数组指针的定义和使用方法。

数组指针是指向数组的指针,其定义方式如下:

int (*ptr)[N]; 其中,N是数组的大小。ptr是一个指向包含N个整型元素的数组的指针。

数组指针的使用 以下是一些使用数组指针的示例:

(1) 一维数组指针

#include 

int main() {
    int arr[5] = {1, 2, 3, 4, 5};
    int (*ptr)[5] = &arr; // ptr是指向包含5个整型元素的数组的指针

    printf("First element: %d\n", (*ptr)[0]);
    printf("Second element: %d\n", (*ptr)[1]);

    return 0;
}

在这个例子中,ptr指向数组arr,通过(*ptr)[i]访问数组中的元素。

(2) 二维数组指针 

对于二维数组,数组指针的使用更为常见和有用:

#include 

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

    int (*ptr)[4] = arr; // ptr是指向包含4个整型元素的数组的指针

    for (int i = 0; i < 3; ++i) {
        for (int j = 0; j < 4; ++j) {
            printf("%d ", ptr[i][j]);
        }
        printf("\n");
    }

    return 0;
}

在这个例子中,ptr是一个指向包含4个整型元素的数组的指针,也就是指向二维数组的每一行。通过ptr[i][j]访问二维数组中的元素。

二、中级:指针进阶

1.指针的指针

指针不仅可以指向数据,还可以指向另一个指针,这种情况称为指针的指针。

#include 
int main()
{
  int a = 10;
  int* p = &a;
  int** pp = &p; // pp 是一个指向指针 p 的指针
  
  printf("a 的值: %d\n", a); // 输出 10
  printf("*p 的值: %d\n", *p); // 输出 10
  printf("**pp 的值: %d\n", **pp); // 输出 10
  
  return 0;
}

2.函数指针

函数指针是指向函数的指针,可以用来动态调用函数。

#include 

int add(int a, int b) {
return a + b;
}

int main() {
int (*func_ptr)(int, int) = &add; // 声明一个指向函数的指针

int result = func_ptr(3, 4); // 调用函数
printf("结果: %d\n", result); // 输出 7

return 0;
}

3.指针函数 

是一个返回指针的函数。它与函数指针不同,函数指针是指向函数的指针,而指针函数是返回值为指针类型的函数。下面详细介绍指针函数的定义、使用方法及一些常见的例子。

定义指针函数,指针函数的定义方式是指定函数返回值为指针类型,例如:

int* func();

这表示func是一个返回int类型指针的函数。

指针函数的使用 指针函数通常用于动态分配内存、返回数组、字符串或结构体等情况。以下是一些使用指针函数的例子:

(1) 返回指向单个变量的指针

#include 

int* getNumber() {
    static int num = 42; // 使用static使num的生命周期延续到函数之外
    return #
}

int main() {
    int *ptr = getNumber();
    printf("Number: %d\n", *ptr);
    return 0;
}

在这个例子中,getNumber函数返回指向num的指针。因为num是静态变量,它在函数返回后依然存在。

(2) 返回动态分配内存的指针

#include 
#include 

int* allocateArray(int size) {
    int *arr = (int *)malloc(size * sizeof(int));
    return arr;
}

int main() {
    int *arr = allocateArray(5);
    if (arr != NULL) {
        for (int i = 0; i < 5; i++) {
            arr[i] = i * 2;
        }
        for (int i = 0; i < 5; i++) {
            printf("%d ", arr[i]);
        }
        printf("\n");
        free(arr); // 别忘了释放内存
    }
    return 0;
}

这个例子中,allocateArray函数返回一个指向动态分配内存的指针。

(3) 返回指向数组的指针

复制代码
#include 

int* getArray() {
    static int arr[5] = {1, 2, 3, 4, 5};
    return arr;
}

int main() {
    int *ptr = getArray();
    for (int i = 0; i < 5; i++) {
        printf("%d ", ptr[i]);
    }
    printf("\n");
    return 0;
}

在这个例子中,getArray函数返回指向静态数组arr的指针。静态数组在函数返回后依然存在,所以返回的指针是有效的。

(4) 常见的应用场景 

  • 字符串操作:函数返回指向字符串的指针,例如处理输入输出字符串。
  • 链表操作:函数返回指向链表节点的指针,用于创建、插入、删除链表节点。
  • 动态内存管理:函数返回动态分配的内存指针,用于数组、结构体等的动态创建和管理。

4.动态内存分配

动态内存分配是指在运行时分配内存,而不是在编译时。C语言提供了 malloc、calloc 和 free 函数来进行动态内存分配和释放。

#include 
#include 

int main() {
int* p = (int*)malloc(sizeof(int) * 5); // 分配5个整数大小的内存

if (p == NULL) {
printf("内存分配失败\n");
return 1;
}

for (int i = 0; i < 5; i++) {
p[i] = i + 1; // 使用分配的内存
}

for (int i = 0; i < 5; i++) {
printf("%d ", p[i]);
}

free(p); // 释放内存

return 0;
}

常量指针和指针常量是两个非常重要的概念,在C和C++中经常被用到。它们分别表示指针和指针指向的内容的常量性不同。

5.常量指针(const pointer)

指针本身是常量,不能修改指向的地址,但可以修改指针指向的内容。

int x = 10;
int y = 20;
const int *ptr = &x; // 常量指针,指向一个整型常量
*ptr = 5; // 错误,不能通过常量指针修改指向的内容
ptr = &y; // 正确,可以修改常量指针指向的地址

6.指针常量(pointer to const)

指针指向的内容是常量,不能通过指针修改其指向的内容,但可以修改指针指向的地址。

int x = 10;
int y = 20;
int *const ptr = &x; // 指针常量,指针本身是常量,指向一个整型变量
*ptr = 5; // 正确,可以通过指针修改指向的内容
ptr = &y; // 错误,不能修改指针常量指向的地址

总的来说,常量指针用于保护指向的内容不被修改,而指针常量用于保护指针本身不被修改。在实际编程中,根据需求选择合适的类型可以增强代码的安全性和可读性。

7.常量指针常量(const pointer to const)

是指指针本身和指针指向的内容都是常量,即既不能通过指针修改指向的地址,也不能通过指针修改指向的内容。

int x = 10;
const int y = 20;

const int *const ptr = &x; // 常量指针常量,指针和指向的内容都是常量
*ptr = 5; // 错误,不能通过指针修改指向的内容
ptr = &y; // 错误,不能修改指针指向的地址

在上面的例子中,ptr是一个指向整型常量的常量指针常量,因此既不能通过ptr修改指向的内容,也不能修改ptr指向的地址。这种类型的指针通常用于指向常量数据,以确保数据的不可变性。

三、高级:指针高级用法

1.指向函数的指针数组 

指针数组可以用来存储多个函数指针,从而实现动态调用不同的函数。

#include 

int add(int a, int b) {
return a + b;
}

int subtract(int a, int b) {
return a - b;
}

int multiply(int a, int b) {
return a * b;
}

int main() {
int (*func_ptr[])(int, int) = {add, subtract, multiply};

int x = 10, y = 5;
for (int i = 0; i < 3; i++) {
printf("结果: %d\n", func_ptr[i](x, y));
}

return 0;
}

2.指针与数据结构* 

在数据结构中,指针用于实现链表、树等结构。以下是单链表的简单实现:


#include 
#include 

struct Node {
int data;
struct Node* next;
};

void printList(struct Node* n) {
while (n != NULL) {
printf("%d ", n->data);
n = n->next;
}
}

int main() {
struct Node* head = NULL;
struct Node* second = NULL;
struct Node* third = NULL;

head = (struct Node*)malloc(sizeof(struct Node));
second = (struct Node*)malloc(sizeof(struct Node));
third = (struct Node*)malloc(sizeof(struct Node));

head->data = 1;
head->next = second;

second->data = 2;
second->next = third;

third->data = 3;
third->next = NULL;

printList(head);

free(head);
free(second);
free(third);

return 0;
}

3.多维数组与指针

多维数组可以使用指针进行遍历和操作。

int main() 
{
int arr[2][3] = {{1, 2, 3}, {4, 5, 6}};
int (*p)[3] = arr; // 指向包含3个整数的一维数组的指针

for (int i = 0; i < 2; i++) 
{
  for (int j = 0; j < 3; j++) 
  {
    printf("%d ", p[i][j]);
  }
  printf("\n");
}

return 0;
}

4.指针的陷阱与安全

指针的使用虽然强大,但也伴随着潜在的风险,如悬空指针、野指针、缓冲区溢出等。 

  • 悬空指针:指针指向的内存已经被释放,但指针本身未被重置为NULL。 
  • 野指针:指针未初始化或指向未分配的内存区域。
#include 
#include 

int main() {
int* p = (int*)malloc(sizeof(int));
*p = 10;

free(p);
p = NULL; // 避免悬空指针

if (p != NULL) {
*p = 20; // 避免野指针
} else {
printf("指针已被释放\n");
}

return 0;
}

5.C++中的智能指针 

C++11引入了智能指针,用于自动管理内存,避免内存泄漏。常见的智能指针包括 std::unique_ptr 和 std::shared_ptr。

#include
#include

class Test {
public:
Test() { std::cout

相关文章

深度解析Java Thread Locals工作原理
一日一技:如何正确处理多行字符串的缩进问题
OpenTelemetry并非可观测性的“神奇按钮”
Python 对象的行为是怎么区分的?
面试官:你能实现一个 JavaScript 模板引擎吗?
记一次 .NET某工控WPF程序被人恶搞的卡死分析

发布评论