【C语言高级指导】指针的高级应用

最新推荐文章于 2024-07-09 18:38:23 发布
最新推荐文章于 2024-07-09 18:38:23 发布
阅读量6.5k 收藏 24
点赞数 31
分类专栏： C语言 文章标签： c语言 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47406528/article/details/139962812
版权

指针的高级应用

指针是C语言区别于其他高级语言的一个显著特点，它们为程序员提供了对程序内存布局的精细控制。然而，指针的使用也需要谨慎，因为不当的指针操作可能导致内存泄漏、野指针、缓冲区溢出等安全问题。正确理解和使用指针对于编写高效、安全和可维护的C语言程序至关重要。

在C语言中，指针是核心概念之一，除了基本的用途外，指针还可以用于多种高级应用，这些应用涉及到更深层次的内存操作和优化。以下是一些指针的高级应用：

动态存储分配

动态内存管理

使用malloc、calloc、realloc和free等函数在堆上动态分配和释放内存。这对于处理大小可变的数据结构非常有用。

  1. malloc:
    • 从堆(heap)分配一块指定大小的内存区域，并返回指向这块内存的指针。如果分配失败，返回NULL。
    • 语法：void *malloc(size_t size);
  2. calloc:
    • 分配足够存储一个数组的内存，数组的每个元素初始化为0，并返回指向这块内存的指针。如果分配失败，返回NULL。
    • 语法：void *calloc(size_t nmemb, size_t size);
  3. realloc:
    • 调整之前通过malloc或calloc分配的内存块的大小。如果扩展失败，可以返回NULL。
    • 语法：void *realloc(void *ptr, size_t size);
  4. free:
    • 释放之前通过malloc、calloc或realloc分配的内存。不应该释放不属于堆的内存。
    • 语法：void free(void *ptr);

空指针

  • 空指针是一个指针值，它不指向任何内存地址。在C语言中，空指针通常表示没有分配内存或者用于结束某些数据结构（如链表）的标记。
  • 空指针在C语言中用NULL表示，NULL是一个宏定义，通常展开为(void *)0或0L（对于长整型）。

示例

#include <stdio.h>
#include <stdlib.h>

int main() {
    int *ptr = NULL; // 声明一个初始化为NULL的整型指针

    // 使用malloc分配内存
    ptr = (int *)malloc(sizeof(int));
    if (ptr == NULL) {
        fprintf(stderr, "Memory allocation failed\n");
        return 1;
    }

    // 使用calloc分配并初始化内存
    int *array = (int *)calloc(10, sizeof(int));
    if (array == NULL) {
        fprintf(stderr, "Memory allocation failed\n");
        free(ptr); // 释放之前分配的内存
        return 1;
    }

    // 使用realloc调整内存大小
    int *newArray = (int *)realloc(array, 20 * sizeof(int));
    if (newArray == NULL) {
        fprintf(stderr, "Memory reallocation failed\n");
        free(array); // 释放原始分配的内存
        free(ptr);   // 释放之前分配的内存
        return 1;
    }

    // 释放分配的内存
    free(newArray);
    free(ptr);

    return 0;
}

在使用这些内存分配函数时，应该始终检查返回值以确保内存分配成功。如果分配失败，应该适当处理错误，例如释放之前分配的内存并返回错误代码或打印错误消息。正确管理内存分配和释放是编写健壮C程序的关键。

动态分配字符串

动态内存分配在C语言中至关重要，它允许在运行时根据需要处理用户输入的可变长度字符串、高效地读取和存储文本文件数据、灵活地处理大规模数据集、优化内存使用特别是在资源受限的环境中、以及通过函数返回复杂的大型数据结构，同时还能超越静态数组大小的编译时限制。

使用malloc函数为字符串分配内存

使用 malloc 函数为字符串分配内存是C语言中常见的操作，尤其是在处理用户输入或动态生成的字符串时。以下是使用 malloc 为字符串分配内存的步骤和示例代码：

步骤

  1. 确定字符串的长度：首先确定需要存储的字符串的长度，包括结尾的空字符 '\0'。
  2. 使用 malloc 分配内存：根据字符串的长度乘以字符类型的大小（通常为 sizeof(char)），使用 malloc 函数分配相应大小的内存。
  3. 检查 malloc 返回值：检查 malloc 返回的指针是否为 NULL，以确保内存分配成功。
  4. 使用 strcpy 或其他函数填充字符串：如果需要，可以使用 strcpy 或其他字符串处理函数将字符串复制到新分配的内存中。
  5. 释放内存：使用完分配的内存后，使用 free 函数释放内存，避免内存泄漏。

示例代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main() {
    const char *initialString = "Hello, World!";
    char *dynamicString = NULL;

    // 为字符串分配内存，包括空字符'\0'
    dynamicString = (char *)malloc(strlen(initialString) + 1);

    // 检查malloc是否成功分配了内存
    if (dynamicString == NULL) {
        fprintf(stderr, "Memory allocation failed\n");
        return 1;
    }

    // 使用strcpy将初始字符串复制到新分配的内存中
    strcpy(dynamicString, initialString);

    // 打印动态分配的字符串
    printf("Dynamic string: %s\n", dynamicString);

    // 释放分配的内存
    free(dynamicString);
    dynamicString = NULL;

    return 0;
}

注意事项

  • 确保分配的内存大小足以容纳字符串和结尾的空字符 '\0'。
  • 使用 strlen 函数获取字符串的长度时，确保字符串是正确终止的。
  • 在复制字符串后，不需要手动添加空字符 '\0'，因为 strcpy 会复制整个字符串，包括结尾的空字符。
  • 始终检查 malloc 的返回值，以防内存分配失败。
  • 在不再需要动态分配的内存时，使用 free 函数释放它，避免内存泄漏。

通过这种方式，你可以在C语言中安全地为字符串分配和使用动态内存。

在字符串函数中使用动态存储分配

动态存储分配是一种常用的技术，它允许程序在运行时根据实际需要分配内存。以下是一些使用动态存储分配的常见场景和方法：

场景
  1. 用户输入：当用户输入的字符串长度未知时，使用动态分配可以确保有足够的空间存储输入的字符串。
  2. 字符串复制与连接：在复制或连接两个字符串时，可能需要比原有更大的空间，动态分配可以提供这种灵活性。
  3. 字符串处理函数：创建自定义的字符串处理函数，如搜索、替换或分割字符串，可能需要额外的内存来存储中间结果。
  4. 大型数据结构：处理大型的字符串数据结构，如文本缓冲区或多行文本编辑器，可能需要动态分配内存来存储数据。
方法

  1. 使用 malloc 分配内存：

    • 根据需要的大小，使用 malloc 函数分配内存。
    char *str = malloc(size * sizeof(char));

  2. 使用 calloc 初始化内存：

    • 使用 calloc 分配内存并初始化为零，适用于需要清零的字符串。
    char *str = calloc(size, sizeof(char));

  3. 使用 realloc 调整内存大小：

    • 如果需要调整已分配内存的大小，使用 realloc 函数。
    str = realloc(str, new_size * sizeof(char));

  4. 复制字符串到动态分配的内存：

    • 使用 strcpy 或 strncpy 将字符串复制到动态分配的内存中。
    strcpy(str, "Hello, World!");

  5. 处理用户输入：

    • 可以使用循环和 fgets 来读取用户输入，并动态分配足够的内存。
    char *buffer = NULL;
size_t size = 0;
getline(&buffer, &size, stdin);

  6. 释放内存：

    • 使用完动态分配的内存后，使用 free 函数释放。
    free(str);
示例代码
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main() {
    char *dynamicStr = NULL;
    size_t size = 10; // 初始大小

    dynamicStr = malloc(size * sizeof(char));
    if (dynamicStr == NULL) {
        perror("Failed to allocate memory");
        return EXIT_FAILURE;
    }

    // 假设我们预期用户输入不会超过这个大小
    printf("Enter a string: ");
    if (!fgets(dynamicStr, size, stdin)) {
        perror("Failed to read string");
        free(dynamicStr);
        return EXIT_FAILURE;
    }

    // 去除fgets读取的换行符
    size_t len = strlen(dynamicStr);
    if (dynamicStr[len - 1] == '\n') {
        dynamicStr[len - 1] = '\0';
    }

    printf("You entered: %s\n", dynamicStr);

    free(dynamicStr);
    return EXIT_SUCCESS;
}

在这个示例中，我们首先使用 malloc 分配了足够的内存来存储预期的用户输入。然后，我们使用 fgets 从标准输入读取字符串，并确保去除末尾的换行符。最后，我们使用 free 释放了分配的内存。

动态分配字符串的数组

动态分配字符串数组在C语言中是一种常见的做法，特别是在处理不确定数量的字符串时。以下是如何动态分配字符串数组的步骤，以及一个简单的示例：

步骤
  1. 确定数组大小：首先确定你需要多少个字符串（即数组的长度）。
  2. 分配内存：使用malloc或calloc为字符串指针数组分配内存。每个指针将指向一个字符串。
  3. 初始化指针：为每个字符串指针分配内存，通常使用malloc为其分配足够的字符空间。
  4. 读取或赋值：为每个字符串赋初值或从数据源（如用户输入、文件等）读取字符串。
  5. 释放内存：使用完毕后，释放每个字符串的内存，然后释放指针数组的内存。
示例代码
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main() {
    int num_strings = 5; // 假设我们有5个字符串
    char **string_array = malloc(num_strings * sizeof(char*)); // 分配指针数组

    if (string_array == NULL) {
        perror("Failed to allocate memory for string array");
        return EXIT_FAILURE;
    }

    // 为每个字符串分配内存
    for (int i = 0; i < num_strings; ++i) {
        string_array[i] = malloc(50 * sizeof(char)); // 假设每个字符串最大50个字符
        if (string_array[i] == NULL) {
            perror("Failed to allocate memory for a string");
            // 释放之前分配的所有字符串内存
            for (int j = 0; j < i; ++j) {
                free(string_array[j]);
            }
            free(string_array);
            return EXIT_FAILURE;
        }
        // 用空字符串初始化
        strcpy(string_array[i], "");
    }

    // 填充字符串数组（例如，从用户输入或其他来源）
    for (int i = 0; i < num_strings; ++i) {
        printf("Enter string #%d: ", i + 1);
        if (!fgets(string_array[i], 50, stdin)) {
            perror("Failed to read string");
        }
        // 去除fgets读取的换行符
        size_t len = strlen(string_array[i]);
        if (string_array[i][len - 1] == '\n') {
            string_array[i][len - 1] = '\0';
        }
    }

    // 打印所有字符串
    for (int i = 0; i < num_strings; ++i) {
        printf("String #%d: %s\n", i + 1, string_array[i]);
    }

    // 释放每个字符串的内存
    for (int i = 0; i < num_strings; ++i) {
        free(string_array[i]);
    }

    // 释放指针数组的内存
    free(string_array);

    return EXIT_SUCCESS;
}

在这个示例中，我们首先为字符串指针数组分配内存，然后为每个字符串分配了最大50个字符的内存空间。我们从用户那里读取每个字符串，并去除末尾的换行符。最后，我们打印所有字符串，并释放所有分配的内存。

动态分配数组

动态分配数组允许你在运行时根据需要创建任意大小的数组，这在事先不知道数组大小的情况下非常有用。使用 malloc 或 calloc 可以在堆上分配内存，而使用 free 可以在使用完毕后释放内存。

示例代码

#include <stdio.h>
#include <stdlib.h>

int main() {
    int n = 10;           // 假设我们需要一个大小为10的整型数组
    int *array = malloc(n * sizeof(int)); // 分配内存

    if (array == NULL) {
        fprintf(stderr, "Memory allocation failed\n");
        return 1;
    }

    // 初始化数组
    for (int i = 0; i < n; i++) {
        array[i] = i * 2; // 举例：将数组元素初始化为偶数
    }

    // 使用数组
    for (int i = 0; i < n; i++) {
        printf("%d ", array[i]);
    }
    printf("\n");

    // 释放分配的内存
    free(array);

    return 0;
}

在这个示例中，我们使用 malloc 动态分配了一个大小为10的整型数组的内存，并进行了初始化和使用。最后，使用 free 函数释放了分配的内存。这种方法提供了极大的灵活性，因为你可以根据实际需求调整数组的大小。

释放存储空间

在C语言中，释放存储空间是一个重要的内存管理操作，特别是在使用动态内存分配时。当你使用malloc、calloc或realloc等函数在堆上分配内存后，必须在不再需要这些内存时通过free函数来释放它们。以下是释放存储空间的相关概念和步骤：

相关概念

  1. 堆（Heap）：是内存中用于动态内存分配的区域。
  2. 动态内存分配：使用malloc、calloc、realloc等函数在堆上分配内存。
  3. 内存泄漏（Memory Leak）：当不再使用的内存没有被释放时，会占用内存资源，导致内存泄漏。
  4. 野指针（Dangling Pointer）：指向已经被释放内存的指针。
  5. 双倍释放（Double Free）：尝试释放同一块内存两次，这可能导致未定义行为。

步骤

  1. 确定内存不再需要：在程序中，一旦动态分配的内存不再被使用，就应该释放。

  2. 使用free函数：调用free函数并传递要释放的内存的指针。

    free(pointer);

  3. 设置指针为NULL：释放内存后，将指针设置为NULL，避免野指针的产生。

    pointer = NULL;

  4. 避免重复释放：确保每块内存只被释放一次。

  5. 考虑使用智能指针：在复杂的应用程序中，使用智能指针（如C++中的std::unique_ptr或std::shared_ptr）可以自动管理内存释放。

示例代码

#include <stdio.h>
#include <stdlib.h>

int main() {
    int *dynamicArray = (int *)malloc(10 * sizeof(int));
    if (dynamicArray == NULL) {
        fprintf(stderr, "Memory allocation failed\n");
        return 1;
    }

    // 使用分配的内存...

    // 释放内存
    free(dynamicArray);
    dynamicArray = NULL; // 避免野指针

    return 0;
}

注意事项

  • 总是检查malloc、calloc、realloc的返回值以确保内存分配成功。
  • 释放内存后，不要再次使用原来的指针，因为它指向的内存已经不再属于你的程序。
  • 在复杂的应用程序中，使c用内存管理工具或语言特性来帮助追踪内存分配和释放，避免内存泄漏。
  • 如果程序中存在循环引用的动态分配对象，考虑使用垃圾回收机制或弱引用来避免内存泄漏。

正确地管理动态内存分配和释放是编写健壮C语言程序的关键。

链表

链表是一种常见的数据结构，用于以线性方式存储数据集合，其中的每个元素（通常称为节点）除了存储数据外，还有一个或多个指向其他节点的指针。链表与数组不同，它不要求数据在内存中连续存储，因此提供了更高的灵活性来添加和删除元素。

链表的主要特点：

  1. 动态大小：链表可以在运行时动态地增加或减少大小。
  2. 非连续性：链表中的元素不需要在内存中连续存储。
  3. 指针连接：每个元素通过指针指向列表中的下一个或前一个元素。
  4. 灵活的内存使用：链表可以根据需要分配或释放内存，避免数组重新分配的开销。
  5. 可变的时间复杂度：链表的某些操作（如插入和删除）可以在 O(1) 时间内完成，而数组可能需要 O(n) 时间。

链表的类型：

单链表：每个节点包含一个指向列表中下一个节点的指针。

在这里插入图片描述

%A1%A8.webp&pos_id=img-5zStcFmv-1719304366061)

双链表：每个节点包含两个指针，一个指向前一个节点，一个指向后一个节点。

在这里插入图片描述

循环链表：最后一个节点的指针指向列表的第一个节点，形成一个循环。

在这里插入图片描述
在这里插入图片描述

基本操作：

  1. 插入：在链表的特定位置添加新节点。
  2. 删除：根据条件或位置移除节点。
  3. 搜索：查找具有特定值的节点。
  4. 遍历：从链表的开始或结束顺序访问每个节点。

示例代码（单链表）：

#include <stdio.h>
#include <stdlib.h>

// 定义链表节点的结构
typedef struct Node {
    int data;
    struct Node *next;
} Node;

// 创建新节点的函数
Node *createNode(int data) {
    Node *newNode = (Node *)malloc(sizeof(Node));
    if (newNode == NULL) {
        perror("Failed to allocate memory for new node");
        exit(EXIT_FAILURE);
    }
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}

// 向链表末尾添加节点的函数
void appendNode(Node **head, int data) {
    Node *newNode = createNode(data);
    if (*head == NULL) {
        *head = newNode;
    } else {
        Node *current = *head;
        while (current->next != NULL) {
            current = current->next;
        }
        current->next = newNode;
    }
}

// 打印链表的函数
void printList(Node *head) {
    Node *current = head;
    while (current != NULL) {
        printf("%d -> ", current->data);
        current = current->next;
    }
    printf("NULL\n");
}

// 释放链表内存的函数
void freeList(Node *head) {
    Node *current = head;
    while (current != NULL) {
        Node *temp = current;
        current = current->next;
        free(temp);
    }
}

int main() {
    Node *head = NULL;
    appendNode(&head, 1);
    appendNode(&head, 2);
    appendNode(&head, 3);

    printList(head);

    freeList(head);

    return 0;
}

在这个示例中，我们定义了一个简单的单链表，包括创建节点、向链表末尾添加节点、打印链表和释放链表内存的功能。链表提供了一种灵活的方式来管理数据集合，特别适用于数据元素数量频繁变化的场景。

声明一个结构体来表示链表的节点

typedef struct ListNode {
    int data;
    struct ListNode *next;
} ListNode;

创建节点

使用malloc函数动态分配内存来创建一个新的节点。

复制ListNode *createNode(int data) {
    ListNode *newNode = (ListNode *)malloc(sizeof(ListNode));
    if (newNode != NULL) {
        newNode->data = data;
        newNode->next = NULL;
    }
    return newNode;
}

->运算符

->运算符用于访问结构体指针的成员。

复制// 访问newNode的数据和下一个指针
printf("Node data: %d\n", newNode->data);
newNode->next = createNode(10);

在链表的开始处插入节点

在链表的头部插入新节点，使其成为新的头节点。

复制void insertAtBeginning(ListNode **head, int data) {
    ListNode *newNode = createNode(data);
    newNode->next = *head;
    *head = newNode;
}

搜索链表

遍历链表以查找具有特定数据的节点。

复制ListNode *searchList(ListNode *head, int searchData) {
    ListNode *current = head;
    while (current != NULL) {
        if (current->data == searchData) {
            return current;
        }
        current = current->next;
    }
    return NULL; // 如果未找到，返回NULL
}

从链表中删除节点

根据条件找到并删除链表中的节点。

复制void deleteNode(ListNode **head, int deleteData) {
    ListNode *current = *head;
    ListNode *previous = NULL;

    while (current != NULL && current->data != deleteData) {
        previous = current;
        current = current->next;
    }

    if (current == NULL) {
        printf("Data not found in the list.\n");
    } else {
        if (previous == NULL) {
            *head = current->next; // 删除头节点
        } else {
            previous->next = current->next; // 删除中间节点
        }
        free(current);
    }
}

有序链表

维护链表的有序性，确保插入新节点时保持链表的顺序。

复制void insertInOrder(ListNode **head, int data) {
    ListNode *newNode = createNode(data);
    if (*head == NULL || (*head)->data >= data) {
        newNode->next = *head;
        *head = newNode;
    } else {
        ListNode *current = *head;
        while (current->next != NULL && current->next->data < data) {
            current = current->next;
        }
        newNode->next = current->next;
        current->next = newNode;
    }
}

指向指针的指针

指向指针的指针是一个多级指针的概念，它是一个存储另一个指针地址的指针变量。这种指针主要用于访问和操作更深层次的内存层次，常见于需要动态分配数组或数据结构的场景，如链表、树等复杂数据结构的实现。

示例代码：

#include <stdio.h>
#include <stdlib.h>

int main() {
    int *p = malloc(sizeof(int)); // 分配内存并初始化指针 p
    if (p == NULL) {
        perror("Memory allocation failed");
        return 1;
    }
    *p = 5; // 通过指针 p 访问分配的内存

    int **pptr = &p; // pptr 是指向指针 p 的指针

    printf("Value: %d\n", **pptr); // 输出 pptr 指向的指针 p 指向的值

    // 修改 pptr 使其指向新分配的内存
    int *newP = malloc(sizeof(int));
    if (newP == NULL) {
        perror("Memory allocation failed");
        free(p); // 释放之前分配的内存
        return 1;
    }
    *newP = 10;
    *pptr = newP; // 现在 pptr 指向 newP

    printf("New Value: %d\n", **pptr); // 输出 newP 指向的值

    // 释放内存
    free(*pptr); // 释放 newP 指向的内存
    free(pptr); // 如果 pptr 不再使用，也应释放

    return 0;
}

在这个示例中，我们首先为一个整数分配内存，并创建一个指向该内存的指针 p。然后，我们创建一个指向 p 的指针 pptr。通过 pptr，我们可以访问 p 指向的值，并可以改变 pptr 使其指向不同的内存地址。最后，我们释放所有分配的内存。

指向指针的指针在处理多维数组、复杂的数据结构或需要动态分配内存的函数参数时非常有用。它们提供了一种间接访问和操作内存的方法，使得程序更加灵活。然而，使用多级指针也需要小心，因为它们增加了内存管理的复杂性，不当的使用可能导致内存泄漏或野指针等问题。

指向函数的指针

指向函数的指针是一种特殊的指针类型，它存储了函数的地址，并可以用来调用该函数。使用函数指针可以提供一种灵活的方式来动态调用函数，实现回调机制或多态行为。

基本用法：

  1. 声明函数指针： 声明函数指针时，需要指定被指向函数的返回类型、函数名以及参数列表。

    // 假设有一个返回int类型，接受两个int参数的函数
int (*functionPtr)(int, int);

  2. 初始化函数指针： 将一个函数的地址赋给函数指针。

    int add(int a, int b) {
    return a + b;
}
// 将add函数的地址赋给functionPtr
functionPtr = add;

  3. 通过函数指针调用函数： 使用函数指针调用函数，就像使用普通函数调用一样。

    int result = functionPtr(3, 5); // 调用add函数
printf("Result: %d\n", result);

  4. 作为参数传递给其他函数： 函数指针可以作为参数传递给其他函数，实现回调机制。

    void executeFunction(int (*fn)(int, int), int a, int b) {
    printf("Result: %d\n", fn(a, b));
}

  5. 作为返回值： 函数可以返回函数指针类型，用于返回函数地址。

    int (*selectFunction(char *name))(int, int) {
    if (strcmp(name, "add") == 0) {
        return add;
    } else {
        // 返回其他函数的地址或NULL
    }
}

  6. 数组或集合： 函数指针可以存储在数组或集合中，用于实现函数表或多态行为。

示例代码：

#include <stdio.h>
#include <string.h>

// 定义两个函数
int add(int a, int b) {
    return a + b;
}

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

// 使用函数指针
int main() {
    // 声明函数指针
    int (*functionPtr)(int, int) = NULL;

    // 赋值并调用函数
    functionPtr = add;
    printf("Addition: %d\n", functionPtr(3, 5));

    // 改变函数指针指向的函数
    functionPtr = subtract;
    printf("Subtraction: %d\n", functionPtr(10, 5));

    // 函数指针作为参数
    executeFunction(add, 3, 2);

    return 0;
}

// 回调函数
void executeFunction(int (*fn)(int, int), int a, int b) {
    printf("Result from callback: %d\n", fn(a, b));
}

在这个示例中，我们定义了两个简单的数学函数 add 和 subtract，然后声明了一个函数指针 functionPtr 并将其初始化为 add 函数的地址。通过 functionPtr 调用 add 函数，并输出结果。接着，我们将 functionPtr 指向 subtract 函数，并再次调用。此外，我们还展示了如何将函数指针作为参数传递给 executeFunction 函数。

函数指针是C语言中实现回调机制、策略模式和多态行为的关键工具。它们提供了一种灵活的方式来动态调用函数，使得程序设计更加灵活和模块化。然而，使用函数指针也需要谨慎，以确保正确的函数地址被赋值，避免程序出现不可预期的行为。

受限指针

受限指针（有时称为限定指针）是一种指针类型，它通过限定符来增加对指针使用的限制。

使用受限指针的场景：

  • 数组参数：在函数中，如果你确定只通过一个数组参数访问元素，可以使用受限指针来提高效率。
  • 多重指针：在处理多重指针时，如果确保只通过一个指针来访问数据，可以声明该指针为受限指针。
  • 编译器优化：受限指针可以帮助编译器进行更好的优化，因为它提供了关于代码行为的额外信息。

示例代码：

#include <stdio.h>

// 假设我们有一个函数，它只通过一个指针来访问数组
void processArray(int *restrict arr, size_t size) {
    for (size_t i = 0; i < size; ++i) {
        // 这里可以安全地使用 arr[i]，因为我们知道没有其他指针指向这个数组
        printf("%d ", arr[i]);
    }
    printf("\n");
}

int main() {
    int myArray[] = {1, 2, 3, 4, 5};
    processArray(myArray, sizeof(myArray) / sizeof(myArray[0]));

    return 0;
}

在这个示例中，processArray 函数接受一个 int *restrict 类型的参数 arr，表示在函数内部只通过 arr 访问数组元素。这允许编译器对循环进行优化，因为它知道没有其他指针被用来访问相同的数据。

受限指针的使用可以提高程序的性能，但也需要程序员确保在代码中确实没有其他方式访问相同的内存区域。如果违反了 restrict 的约束，程序的行为是未定义的，可能会导致运行时错误。

灵活数组成员

“灵活数组成员”（Flexible Array Member）是C99标准引入的一个特性，它允许结构体定义一个数组，该数组的大小可以在运行时确定。这种特性常用于创建可变大小的数据结构，如动态数组或固定大小的缓冲区。

灵活数组成员的语法：

struct StructName {
    int fixedSizeMember;
    int flexibleMember[]; // 灵活数组成员
};

在这个例子中，flexibleMember 是一个灵活数组成员，它没有固定的大小，程序员可以根据需要分配足够的内存。

使用灵活数组成员的步骤：

  1. 声明结构体： 声明一个包含灵活数组成员的结构体。
  2. 分配内存： 使用 malloc 为结构体分配内存，包括灵活数组成员的大小。
  3. 初始化结构体： 在分配内存后，初始化结构体的固定大小成员。
  4. 访问灵活数组成员： 可以直接通过结构体指针访问灵活数组成员。
  5. 释放内存： 使用 free 函数释放分配的内存。

示例代码：

#include <stdio.h>
#include <stdlib.h>

struct MyStruct {
    int size; // 固定大小的成员，存储灵活数组成员的大小
    int data[]; // 灵活数组成员
};

int main() {
    int numElements = 10;
    struct MyStruct *myStruct = malloc(sizeof(int) + numElements * sizeof(int));

    if (myStruct == NULL) {
        perror("Memory allocation failed");
        return 1;
    }

    myStruct->size = numElements;
    for (int i = 0; i < numElements; i++) {
        myStruct->data[i] = i * 2; // 初始化灵活数组成员
    }

    // 访问灵活数组成员
    for (int i = 0; i < myStruct->size; i++) {
        printf("%d ", myStruct->data[i]);
    }
    printf("\n");

    // 释放内存
    free(myStruct);

    return 0;
}

在这个示例中，我们定义了一个包含灵活数组成员的结构体 MyStruct，动态分配了足够的内存来存储结构体和灵活数组成员。然后，我们初始化并访问了灵活数组成员，最后释放了分配的内存。

注意事项：

  • 灵活数组成员的大小必须是已知的，或者在运行时可以计算出来的。
  • 不能直接声明一个只有灵活数组成员的结构体变量，因为它的大小是未知的。
  • 使用灵活数组成员时，需要手动分配和管理内存，以避免内存泄漏。
  • 灵活数组成员通常用于实现类似栈或队列这样的数据结构，它们的大小可以根据需要动态变化。

; // 固定大小的成员，存储灵活数组成员的大小
int data[]; // 灵活数组成员
};

int main() {
int numElements = 10;
struct MyStruct *myStruct = malloc(sizeof(int) + numElements * sizeof(int));

if (myStruct == NULL) {
    perror("Memory allocation failed");
    return 1;
}

myStruct->size = numElements;
for (int i = 0; i < numElements; i++) {
    myStruct->data[i] = i * 2; // 初始化灵活数组成员
}

// 访问灵活数组成员
for (int i = 0; i < myStruct->size; i++) {
    printf("%d ", myStruct->data[i]);
}
printf("\n");

// 释放内存
free(myStruct);

return 0;

}


在这个示例中，我们定义了一个包含灵活数组成员的结构体 `MyStruct`，动态分配了足够的内存来存储结构体和灵活数组成员。然后，我们初始化并访问了灵活数组成员，最后释放了分配的内存。

### 注意事项：

- 灵活数组成员的大小必须是已知的，或者在运行时可以计算出来的。
- 不能直接声明一个只有灵活数组成员的结构体变量，因为它的大小是未知的。
- 使用灵活数组成员时，需要手动分配和管理内存，以避免内存泄漏。
- 灵活数组成员通常用于实现类似栈或队列这样的数据结构，它们的大小可以根据需要动态变化。

灵活数组成员提供了一种在结构体中存储可变大小数据的方法，使得C语言在处理动态数据结构时更加灵活。然而，这也要求程序员更加小心地管理内存，确保程序的正确性和稳定性。
linfuture1
关注
  • 31
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c语言高级参考手册
12-16
《C语言高级参考手册》是一本专为C语言开发者设计的深入学习与实践的宝典。这本书涵盖了C语言的高级特性和使用技巧，旨在帮助开发者更高效地掌握和运用这门强大的编程语言。通过深入阅读和实践书中的内容，开发者...
c语言指导网站,c语言高级指导.pdf
weixin_39878855的博客
05-23 62
高质量C++/C 编程指南文件状态 文件标识：[ ] 草稿文件 当前版本： 1.0[ √] 正式文件 作 者： 林锐 博士[ ] 更改正式文件 完成日期： 2001 年7 月24 日高质量C++/C 编程指南，v 1....
c语言程序行指针应用,浅谈C语言程序设计中指针应用.doc
weixin_31156677的博客
05-20 103
浅谈C语言程序设计中指针应用浅谈C语言程序设计中指针应用摘要：该文从指针的概念、运算、使用、灵活应用时应注意的事项等方面对C语言指针进行浅析和探讨。指导学生如何应用指针。关键词：C语言；指针；指针变量；地址中图分类号：TP311文献标识码：A文章编号：1009-3044(2012)02-0389-03Discuss Application Of The Pointer in C Language ...
【C语言高级指导】什么是声明？
weixin_47406528的博客
06-28 913
声明（Declaration）是告诉编译器变量或函数的属性和特性的一种方式。声明对于编译器正确理解代码结构、分配内存、类型检查和代码优化至关重要。
【C语言高级指导】一篇文章搞懂程序设计
weixin_47406528的博客
06-30 8999
定义依赖于机器的类型通常指的是根据目标计算机架构来定义数据类型的大小和表示。由于不同的计算机架构可能具有不同的字长（word size）和内存对齐要求，某些类型的定义可能会依赖于特定的硬件平台。基本数据类型char：通常用于存储单个字符，通常是8位。short：短整型，通常为16位。int：基本整型，大小可能为16位、32位或更大，取决于平台。long：长整型，通常至少为32位，可能为64位，取决于平台。long long：更长的整型，至少为64位。指针类型。
c语言高级实例解析.zip
06-18
《C语言高级实例解析》是一份深度探讨C语言高级特性和实践技巧的资源包，它包含了一系列精心设计的实例，旨在帮助开发者提升在C语言编程中的能力。这份压缩包不仅涵盖了C语言的基础知识，还深入讲解了高级主题，如...
浅析C语言中指针的应用.pdf
09-19
在C语言中，指针可以被用来作为数据结构（如数组）的快捷访问方式，作为函数参数传递大量数据，以及实现动态内存分配等高级功能。 1. 指针概念理解 每个在C语言中定义的变量都在内存中占有特定的存储空间，这个...
C语言中数组指针在汇编语言寻址方式中的应用.pdf
09-19
在计算机科学中，C语言是一种高级语言，数组指针是C语言中的一个重要概念。数组指针是一种特殊的变量，它里面存储的数值被解释成为内存里的一个地址。在C语言中，数组指针可以分解为多个数组元素，这些数组元素可以...
C_language_study.rar_C language stu_C语言高级教程
09-24
通过《C语言高级教程》，初学者不仅能掌握C语言的基本语法，还能了解其在实际项目中的应用，从而为进一步学习操作系统、网络编程、数据结构等高级主题打下坚实的基础。上海贝尔的这份教程以其系统性和实践性，为...
Windows图形界面(GUI)-SDK-C/C++ - 应用程序结构
最新发布
0xCC说逆向
07-09 532
目录入口函数窗口注册窗口创建窗口显示窗口更新消息循环窗口过程窗口销毁调试信息示例代码 参数解析 ：当前实例的句柄(IMAGEBASE)。 ：在32位Windows应用程序中，这个参数总是为NULL。在早期版本的Windows中，用于标识程序的前一个实例。 ：指向一个以null终止的字符串，该字符串包含命令行参数。请注意，它不包含程序的名称。 ：指定窗口如何显示。 窗口注册 参数解析 ：指向结构的指针，该结构包含了窗口类的信息。 结构定义了窗口的特征，包括背景颜色、
【代码随想录_Day27】509 斐波那契数 70 爬楼梯 746 使用最小花费爬楼梯
qq_43671872的博客
07-08 705
509 斐波那契数70 爬楼梯746 使用最小花费爬楼梯今天的题目难度不低，尽量还是写一些简洁代码 ^ _ ^
算法力扣刷题 三十一【150. 逆波兰表达式求值】
danaaaa的博客
07-04 686
后缀表示法。
【力扣】数组中的第K个最大元素
m0_61876562的博客
07-05 275
l, left]（该部分小于基准元素key）、[left + 1, right - 1]（等于基准元素key）、[right, r]（大于基准元素key）。3、计算每部分所包含的元素个数，分别为a 、b = right - left - 1、 c = r - right + 1;请注意，你需要找的是数组排序后的第。你必须设计并实现时间复杂度为。个最大的元素，而不是第。1、随机选择基准元素。
每周算法：无向图的双连通分量
少儿编程乔老师
07-06 871
通过Tarjan算法求无向连通图的双连通分量，计算至少添加多少条边可以将原图变为一个双连通分量。
秋招力扣刷题——从前序与中序遍历序列构造二叉树
qq_50604294的博客
07-04 224
给定两个整数数组 preorder 和 inorder ，其中 preorder 是二叉树的先序遍历， inorder 是同一棵树的中序遍历，请构造二叉树并返回其根节点。：两种代码的结束条件以及分割的右区间处理方式不同，后者更容易理解一点。
算法库应用--Brute - Force算法串匹配(顺序串)
qq_57484399的博客
07-06 683
V1.0: 在原有的博客基础上, 加入我构建的算法库, 让博客更完全 , 代码可以运行看效果, 不是让算法仅仅停留在 逻辑方面, 这也是后续我努力的方向, 把这些算法模型, 尽可能的去运用到实际的嵌入式项目中, 把理论变成实物 , 本次也进行了名字优化, 让逻辑更清晰。利用B-f算法,寻找子串在母串中的位置。
算法力扣刷题 三十二【239. 滑动窗口最大值】
danaaaa的博客
07-05 665
单调队列（自定义一种队列规则）使用场景1.
二分查找算法【折半查找算法】
weixin_64534587的博客
07-09 314
二分查找法是一种在有序数组中查找特定元素的高效算法。它的工作原理是通过不断地将可能存在的范围，直至找到目标值或确定目标值不存在于数组中。二分查找的关键在于比较都能，因此其为，其中 n 是数组的长度。
如何学习C语言的指针
09-05
学习C语言的指针需要从理解指针的概念入手。指针是一种特殊的变量，它存储了另一个变量的内存地址。通过理解指针变量如何存储地址以及如何使用地址访问内存中的数据，您就可以更好地了解指针。 其次，您需要学习指针运算，例如如何创建指针变量，如何获取变量的地址以及如何使用指针变量访问内存中的数据。 此外，您还需要学习指针与数组的关系，以及如何使用指针实现动态内存分配。 通过阅读有关C语言指针的书籍和教程，以及在实际项目中使用指针，您可以加深对指针的理解。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值