C语言 – 蚕鸣夏季

C语言安全地释放指针

安全释放指针

最近在读有关C语言指针方面的书籍，看到有关malloc系列函数申请内存释放使用宏定义的方式。自己也动手试了一下，感觉还不错记录一下分享给小伙伴们。

实现和应用

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

void safeFreePtr(void **p_ptr)
{
    if (p_ptr != NULL && *p_ptr != NULL)
    {
        free(*p_ptr);
        *p_ptr = NULL;
    }
}

/** 宏定义 */
#define safeFree(ptr)  safeFreePtr((void **)&(ptr))

int main(int argc, char const *argv[])
{
    int *a = (int *)malloc(sizeof(int));
    *a = 10;
    printf("Before: %p\n", a);
    safeFree(a);
    printf("After: %p\n", a);
    safeFree(a);
    return 0;
}

运行结果：

Before: 0x5634b2e342a0
After: (nil)

可以看出第二次safeFree时打印是：nil，程序没有出错。

对于申请的指针，使用free函数释放时只能free一次，第二次free会报错。

指针free释放后，一定要记得把指针置为NULL，防止悬挂指针。

好处

如果程序中是直接调用safeFreePtr函数是需要显示转换为 void** 指针，若不显示转换则会报警告。在使用宏调用safeFreePtr函数可以避免强制转换。

查看系统默认内存对齐字节数

本文使用C语言查看系统默认内存对齐字节数。

#pragma pack(show)

实现当前系统默认对齐字节数，是以警告的方式显示。

使用vscode编辑器，写入以下代码：

// 默认是8
#pragma pack(show)

int main(int argc, char const *argv[])
{
   return 0;
}

运行上面的代码后，会在vscode的控制台【PROBLEMS】tab中显示下面的警告提示信息。

value of #pragma pack(show) == 8 [Semantic Issue]

表示当前内存对齐字节数8.

C基于链表实现栈

本篇内容中的链表是之前的文章中实现的，请参阅文章 C-单链表的实现。

栈的特性

先进后出（First-In-Last-Out, FILO）.

像队列实现一样，有2个主要的操作：

一）push 操作将元素入栈。

二）pop 操作将元素出栈。

栈的实现

基于单链表实现，push 入栈操作就是往链表的头部添加数据元素，pop 出栈操作就是从链表的头部删除数据元素。

以下是栈的定义以及主要操作：

// 定义栈
typedef LinkedList Stack;
// 初始化栈
void initStack(Stack *stack)
{
    init_linkedlist(stack);
}
// 入栈，在链表头部添加元素
void push(Stack *stack, void *data)
{
    addHead(stack, data);
}
// 出栈，从链表头部删除元素
void* pop(Stack *stack)
{
    pNode node = stack->head;
    void* data;
    if (stack->head == NULL) {
        data = NULL;
    } else if (stack->head == stack->tail) {
        stack->head = stack->tail = NULL;
        data = node->data;
        free(node);
    } else {
        stack->head = node->next;
        data = node->data;
        free(node);
    }

    return data;
}

示例说明

    Stack stack;
    // 初始化
    initStack(&stack);
    int a = 20;
    int b = 30;
    int c = 40;
    int *ptr_1 = &a;
    int *ptr_2 = &b;
    int *ptr_3 = &c;

    push(&stack, ptr_1);
    push(&stack, ptr_2);
    push(&stack, ptr_3);

    int *ptr = NULL;
    for (int i = 0; i < 3; i++)
    {
        ptr = (int *)pop(&stack);
        printf("Popped %d\n", *ptr);
    }

运行结果：

Popped 40
Popped 30
Popped 20

以上内容如有错误，欢迎留言指出交流或者关注公众号交流。

C基于链表实现队列

本章内容是基于上一篇文章单链表的实现 C-单链表的实现。

队列是先进先出（First in First out）的线性数据结构. 通常有2个主要的操作：enqueue 和 dequeue。

enqueue操作是将元素添加到列队中。

dequeue操作是将元素从队列中移除。

链表经常用于队列的实现。enqueue 操作是从链表的头部（head）添加元素，dequeue 操作是从链表的尾部（tail）移除元素。

队列定义

定义队列和相关操作

// 定义队列
typedef LinkedList Queue;
// 初始化队列
void initQueue(Queue *queue)
{
    init_linkedlist(queue);
}

// 添加元素
void enqueue(Queue *queue, void *data) {
    addHead(queue, data);
}

// 移除元素
void* dequeue(Queue *queue) 
{
    pNode node = queue->head;
    void* data;
    if (queue->head == NULL){
        data = NULL;
    } else if (queue->head == queue->tail) {
        queue->head = queue->tail = NULL;
        data = node->data;
        free(node);
    } else {
        // 找到倒数第二个节点，由于之前实现的链表是单链表，只能这么找
        while (node->next != queue->tail)
        {
            node = node->next;
        }
        queue->tail= node;
        node = node->next;
        queue->tail->next = NULL;

        data = node->data;
        free(node);
    }

    return data;   
}

示例说明

    Queue queue;
    // 初始化
    initQueue(&queue);
    int a = 20;
    int b = 30;
    int c = 40;
    int *ptr_1 = &a;
    int *ptr_2 = &b;
    int *ptr_3 = &c;

    enqueue(&queue, ptr_1);
    enqueue(&queue, ptr_2);
    enqueue(&queue, ptr_3);

    void *data = dequeue(&queue);
    printf("Dequeued %d\n", *((int*) data));

    data = dequeue(&queue);
    printf("Dequeued %d\n", *((int*) data));

    data = dequeue(&queue);
    printf("Dequeued %d\n", *((int*) data));

结构打印：

Dequeued 20
Dequeued 30
Dequeued 40

以上内容，如有错误，欢迎留言交流或添加公众号交流。

对C中const修饰指针的使用和理解

const用于定义常量类型，限定某些变量不允许修改。

const修饰指针时的原则：先忽略掉类型说明符，离谁近就修饰谁。

1. 常量指针

常量指针：是指向常量的指针，指针指向地址中的内容是不可修改的，但是指针的指向是可以修改。

定义方式，以下2种都可以：

const dataType *ptrName;
dataType const *ptrName;

int a = 20;
int b = 30;
const int *ptr_i = &a;
// *ptr_i = 30; // 报错：read-only variable is not assignable 只读变量不可赋值
ptr_i = &b; // OK的

指针指向的内容不可修改，即：*ptrName（解引用时）表示的值不修改。

const修饰的是*ptr_i，所以不能修改的是就是 *ptr_i 的值。

2. 常指针（指针常量）

常指针：是指针类型的常量，即指针本身的值不可以修改，始终指向一个地址。因此常指针初始化需要给定一个地址值。但是指向地址的内容可以修改

定义方式，以下方式都是可以的（必须要初始化设置值）：

dataType *const ptrName;
const *dataType ptrName;

int a = 20;
int *const ptr1 = &a;
//ptr1 = NULL; // 报错：cannot assign to variable 'ptr1' with const-qualified type 'int *const' 
*ptr1 = 30; // OK的

// 使用 typedef 定义一个别名
typedef int * intp_t;
int b = 30;
const intp_t p2 = &b;
p2 = &a; // 报错：表达式必须是可修改的左值

指针本身的值不可以修改，ptr1的值是&a，不可以修改，指针指向地址的内容可以修改即*ptr1（解引用时）表示的值可以修改。

const修饰的是ptr1，所以ptr1的值不能修改。

通过 typedef 定义指针类型别名intp_t后，再使用const 修饰 intp_t 变量，修饰的是指针本身，即指针本身的指向不可以修改。

3. 常指针&常量指针的复合使用

int a = 30;
const int *const ptr_a = &a;

指针的地址值和地址值的内容都不可以修改。

第一个const 修饰的是 *ptr_a，所以 *ptr_a 的值不能修改。

第二个const 修饰的是 ptr_a，所以 ptr_a的值也不能修改。

4. 其他

const 常用于修饰函数的参数，防止函数内部修改外部变量。

对C中typedef的使用和理解

typedef声明为已存在的数据类型取一个别名，可以用于替换复杂的类型名。

typedef是存储类型说明符（typedef、auto、register、static、extern、_Thread_local）,由于声明中只允许一个存储类型说明符，因此typedef不能和他的存储类型说明符一起使用。

使用代码示例说明

// 为整型定义一个别名int32
typedef int int32;

// 为 int* 指针定义一个别名
typedef int* int_ptr;

// 1.为 char 定义一个类型别名 char_t
// 2.为 char* 定义一个类型别名 char_p（char类型指针）
// 3.为 char (*)(void) 定义一个类型别名 fptr（函数指针）
typedef char char_t, *char_p, (*fptr)(void);

// 定义可变长度数组
typedef int A[];
// 使用时确定具体长度，a的类型是int[2], b的类型是 int[3]
A a = {1, 2}, b = {3,4,5};

// 为 int[5] 定义一个别名为arr
typedef int arr[5];

// 为结构体取别名
// 1.为 _node 定义一个别名 Node
// 2.为 _node* 定义一个别名 P_Node (指针)
typedef struct _node
{
   void* data;
   struct _node *pNext;  // 结构体自引用
} Node, *P_Node;

// 为 tageNode* 定义一个别名 pNode
typedef struct tagNode *pNode;
struct tageNode
{
    char *pItem;
    pNode pNext; // 结构体自引用
};

注意：结构体的自引用只能通过指针来引用。

通过上面的代码和说明可以看出：把typedef和别名去掉后，剩余部分就是别名代表的数据类型。