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种都可以:

  1. const dataType *ptrName;
  2. 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. 常指针(指针常量)

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

定义方式,以下方式都是可以的(必须要初始化设置值):

  1. dataType *const ptrName;
  2. 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的

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

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

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和别名去掉后,剩余部分就是别名代表的数据类型

Copyright © 2023 蚕鸣夏季 . All rights reserved. 备案号:苏ICP备19001383号-1