C-Base

2020-09-03

计算数组的大小

sizeof(数组名) 获得这个数组占用内存的总长度。二维数组是全部元素占用的总长度。

长度 = sizeof(数组名) / sizeof(数组类型)

元素个数 = 总的占用字节大小 / 每个元素占用的字节大小

64位指针占用8字节，8×8=64，内存寻址。

计算一维数组长度

例子1：

char *sc4[] ={"hello","world","Welcome","C"};
   printf("arr total byte = %ld\n",sizeof(sc4));
   printf("arr single element byte = %ld\n",sizeof(sc4[0]));
   printf("arr length = %ld\n",sizeof(sc4)/sizeof(sc4[0]));
   printf("arr length = %ld\n",sizeof(sc4)/sizeof(*sc4));

输出：

arr total byte = 32
arr single element byte = 8
arr length = 4
arr length = 4
arr total byte = 32

例子2：

int n[8] = {1,2,3,4,5};
  printf("arr total byte = %ld\n",sizeof(n));
  printf("arr single element byte = %ld\n",sizeof(n[0]));
  printf("arr length = %ld\n",sizeof(n)/sizeof(n[0]));
  printf("arr length = %ld\n",sizeof(n)/sizeof(*n));

输出：

arr total byte = 32
arr single element byte = 4
arr length = 8
arr length = 8

计算二维数组长度

例子1：

char* arr2[2][3];
   printf("total byte = %ld\n",sizeof(arr2));
   printf("row byte = %ld\n",sizeof(arr2[0]));
   printf("column byte = %ld\n",sizeof(arr2[0][0]));
   printf("rows = %ld\n",sizeof(arr2) / sizeof(arr2[0]));
   printf("rows = %ld\n",sizeof(arr2) / sizeof(*arr2));
   printf("columns = %ld\n",sizeof(arr2[0])/sizeof(arr2[0][0]));
   printf("columns = %ld\n",sizeof(*arr2)/sizeof(**arr2));

输出：

total byte = 48
row byte = 24
column byte = 8
rows = 2
rows = 2
columns = 3
columns = 3

例子2：

定义一个结构体：

typedef struct People_s {
    char *name;
    int age;
}People;

People arr3[3][9];
  printf("total byte = %ld\n",sizeof(arr3));
  printf("row byte = %ld\n",sizeof(arr3[0]));
  printf("column byte = %ld\n",sizeof(arr3[0][0]));
  printf("rows = %ld\n",sizeof(arr3) / sizeof(arr3[0]));
  printf("rows = %ld\n",sizeof(arr3) / sizeof(*arr3));
  printf("columns = %ld\n",sizeof(arr3[0])/sizeof(arr3[0][0]));
  printf("columns = %ld\n",sizeof(*arr3)/sizeof(**arr3));

输出：

total byte = 432
row byte = 144
column byte = 16
rows = 3
rows = 3
columns = 9
columns = 9

valgrind 检查内存泄漏

valgrind --leak-check=full --track-origin=yes ./test

C的字符串数组

第一种情况,每一个都是指针

char **arr = NULL;
// 10 个字符串
arr = calloc(10, sizeof(char *));
arr[0] = calloc(1, 100);
strcpy(arr[0], "Hello");
arr[1] = calloc(1, 100);
strcpy(arr[1], "World");

第二种情况,确定字符串的个数,但每个字符串长度不确定

char *print2[10];
for (int i = 0; i < 10; ++i) {
    print2[i] = calloc(1, i + 2);
    sprintf(print2[i], "%d", i);
}
for (int i = 0; i < 10; ++i) {
    printf("%s\n", print2[i]);
    free(print2[i]);
}

第三种情况,字符串的个数和字符串的长度已经确定

char print[2][10] = {"Hello", "World"};
for (int i = 0; i < 2; ++i) {
    printf("%s\n", print[i]);
}

Makefile相关

C的false和true

在C中,只有0是false,大于0和小于0, 其余都为true
NULL的定义:

1	#define NULL ((void *)0)

true/false的定义:

1 2	#define true 1 #define false 0

使用例子

void checkcond(int32_t cond){
    if (cond) {
        printf("cond %d is true\n", cond);
    }else {
        printf("cond %d is false\n", cond);
    }
}

int main(int argc, char *argv[]) {
    int32_t cond = 0;
    checkcond(cond);
    
    cond = -1;
    checkcond(cond);
    
    cond = -1000;
    checkcond(cond);
    
    cond = 1;
    checkcond(cond);
    
    cond = 100;
    checkcond(cond);
    
    checkcond(NULL);
    checkcond(true);
    checkcond(false);
    return 0;
}

// ouput
/*
cond 0 is false
cond -1 is true
cond -1000 is true
cond 1 is true
cond 100 is true
cond 0 is false
cond 1 is true
cond 0 is false
*/

易混淆点:
strcmp("Hello","Hello")相等返回0,所以
常见写法

// char *str
if (!strcmp("Hello", str)) {
    // str equal "Hello"
}else{
    // str !equal "Hello"
}

取非之后才是比较相等的

C语言大小端工具转化

// 大小端字节转换
int32_t bytes_to_int32_big_endian(char *byte) {
    return ((byte[3] << 0  & 0x000000FF)|
            (byte[2] << 8  & 0x0000FF00)|
            (byte[1] << 16 & 0x00FF0000)|
            (byte[0] << 24 & 0xFF000000));
}
int32_t int32_to_bytes_big_endian(const int32_t n, char *result) {
    result[3] = (char)(n);
    result[2] = (char)(n >> 8);
    result[1] = (char)(n >> 16);
    result[0] = (char)(n >> 24);
    return 0;
}

int32_t bytes_to_int32_little_endian(char *byte) {
    return ((byte[0] << 0  & 0x000000FF)|
            (byte[1] << 8  & 0x0000FF00)|
            (byte[2] << 16 & 0x00FF0000)|
            (byte[3] << 24 & 0xFF000000));
}

int32_t int32_to_bytes_little_endian(const int32_t n, char *result) {
    result[0] = (char)(n >> 0 );
    result[1] = (char)(n >> 8 );
    result[2] = (char)(n >> 16);
    result[3] = (char)(n >> 24);
    return 0;
}
int main(int argc, char *argv[]) {
    char byte[5] = {0};
    int32_t num = 43234325;
    int32_to_bytes_big_endian(num, byte);
    num = 0;
    num = bytes_to_int32_big_endian(byte);
    printf("test big endian num = %d\n", num);

    memset(byte, 0, sizeof(byte));
    num = -12345151;
    int32_to_bytes_little_endian(num, byte);
    num = 0;
    num = bytes_to_int32_little_endian(byte);
    printf("test little endian num = %d\n", num);
    return 0;
}
// output
/*
test big endian num = 43234325
test little endian num = -12345151
*/

C list

内核提供的list
简单的头文件
[linux_list.h]

需要一个哑结点作为整个链表的头部

#include "linux_list.h"
#include "stdlib.h"
#include "string.h"
#include "stdio.h"
#include "stdint.h"
typedef struct book_list_s {
    struct list_head list;
    // 自定义数据结构
    char data[12];
}book_list_t;
int main(int argc, char *argv[]) {
    // 哑结点
    book_list_t bookList;
    INIT_LIST_HEAD(&bookList.list);
    sprintf(bookList.data, "%d", -1);
    unsigned char number = 12;
    book_list_t *item = calloc(number, sizeof(book_list_t));
    
    // 添加
    if (NULL != item) {
        for (uint8_t i = 0;i < number;i ++) {
            INIT_LIST_HEAD(&item[i].list);
            sprintf(item[i].data, "%d", i);
            list_add_tail(&item[i].list, &bookList.list);
        }
    }
    // 查看顺序
    printf("list info\n");
    struct list_head  *pos;
    book_list_t *node;
    list_for_each(pos, &bookList.list) {
        node = list_entry(pos, book_list_t,list);
        printf("%s\t", node->data);
    }
    printf("\n");
    
    
    printf("Test Delete\n");
    // 删除节点,必须使用safe才能删除
    struct list_head *n = NULL;
    list_for_each_safe(pos, n,&bookList.list) {
        node = list_entry(pos, book_list_t,list);
        printf("%s\t", node->data);
        if (0 == strcmp("5", node->data)) {
            list_del(&node->list);
        }
    }
    printf("\n");
    
    printf("After Delete\n");
    list_for_each(pos, &bookList.list) {
        node = list_entry(pos, book_list_t,list);
        printf("%s\t", node->data);
    }
    printf("\n");
    
    // 重新构建连接
    printf("rebuild list\n");
    book_list_t *i5 = item + 5;
    printf("add item %s\n", i5->data);
    list_add_tail(&i5->list, &bookList.list);
    printf("info\n");
    list_for_each(pos, &bookList.list) {
        node = list_entry(pos, book_list_t,list);
        printf("%s\t", node->data);
    }
    printf("\n");
    
    free(item);
    return 0;
}


// output
/*
list info
0    1    2    3    4    5    6    7    8    9    10    11    
Test Delete
0    1    2    3    4    5    6    7    8    9    10    11    
After Delete
0    1    2    3    4    6    7    8    9    10    11    
rebuild list
add item 5
info
0    1    2    3    4    6    7    8    9    10    11    5    
*/

申请一段连续的内存,这一段连续的内存可以使用list进行跳转
好处:只用申请一次内存，避免重复申请和释放
坏处:不可扩展，只能固定大小

注意

必须使用list_for_each_safe才能在循环里面删除。如果想要使用list_for_each删除元素，需要找到之后再删除

book_list_t *deleteItem = NULL;
    list_for_each(pos, &bookList.list) {
        node = list_entry(pos, book_list_t, list);
        if (0 == strcmp("7", node->data)) {
            // 找到数据,外部删除
            deleteItem = node;
            break;
        }
    }
list_del(&deleteItem->list);

列表删除只是将索引关系删除，并不会对自定义数据做任何变更。只会处理list里面的next和prev。
初始化列表的head,将前向指针和后向指针

定义一个万能指针类型ptr

typedef void *ptr;

typedef void *ptr;
typedef struct {
    char name[12];
}Book;
void get_book(void **book) {
    Book *_book = calloc(1, sizeof(Book));
    strcpy(_book->name, "FF");
    *book = _book;
}
int main(int argc,char *argv[]) {
    char *data = "Hello World";
    ptr a;
    a = data;
    printf("%s\n", a);
    int32_t data2 = 12;
    a = &data2;
    printf("%d\n", *((int32_t *)(a)));
    Book book = {0};
    memset(book.name, 0, sizeof(book.name));
    strcpy(book.name, "LL");
    a = &book;
    printf("book name: %s\n", ((Book *)(a))->name);
    
    get_book(&a);
    printf("book name: %s\n", ((Book *)(a))->name);
    free(a);
    
    return 0;
}

输出:

Hello World
12
book name: LL
book name: FF

函数的注册与回调

函数的注册与回调,在多线程或某个函数中,完成相应的事件处理之后能够进行通知。
就像生命周期的钩子一样,开始,结束都会通知并可以处理。理解万能指针之后就会发现指针真是万能的,可以放参数、结构体、函数。

#include <stdlib.h>
#include <zconf.h>
#include "pthread.h"
#include "stdio.h"
#include "stddef.h"
#include "stdint.h"
#include "string.h"

// 定义一个函数模板
typedef int32_t opt_t(int32_t x, int32_t y);
int32_t option(int32_t x, int32_t y,  opt_t func) {
    return func(x,y);
}

// 直接是入参的
int32_t option2(int32_t x, int32_t y, int32_t(func(int32_t x, int32_t y))) {
    return func(x, y);
}

// 加减乘除的实现
int32_t add(int32_t x, int32_t y){return x+y;}
int32_t multi(int32_t x, int32_t y){return x *y;}

// 结构体指针返回的
typedef struct {
    char name[30];
    int32_t price;
}Book;

Book *getOneBook(char *name, Book* (generateBook(char *name, int32_t price))){
    // 其他处理
    return generateBook(name, 120);
}

Book *generateBookDemo(char *name, int32_t price){
    Book *ptr = calloc(1, sizeof(Book));
    strcpy(ptr->name, name);
    ptr->price = price;
    return ptr;
}

typedef void task_cb_t(int num);

void *task(void *arg){
    task_cb_t *cb = arg;
    for (int i = 0; i < 5; ++i) {
        // 直接调用回调
        cb(i);
        sleep(1);
    }
    cb(2345);
    return NULL;
}

void finishTaskCallBack(int num) {
    printf("Task Call Back %d\n", num);
}

int main(int argc, char *argv[]) {
    //
    int32_t x = 12;
    int32_t y = 22;
    printf("%d + %d = %d\n", x, y, option(x, y, add));
    printf("%d * %d = %d\n", x, y, option(x,y, multi));

    printf("%d + %d = %d\n", x, y, option2(x, y, add));
    printf("%d * %d = %d\n", x, y, option2(x,y, multi));

    Book *book = getOneBook("CPLUS", generateBookDemo);
    printf("book name:%s, price:%d\n", book->name, book->price);
    free(book);

    pthread_t handle;
    pthread_create(&handle, NULL, task, finishTaskCallBack);

    sleep(20000);

    return 0;

}

使用C语言实现一个环形缓冲区

RingBuffer.h


#ifndef SIMPLE_RINGBUFF_RINGBUFFER_H
#define SIMPLE_RINGBUFF_RINGBUFFER_H

#define RING_BUFF_MAX_SIZE 10
#include "stddef.h"
#include "stdint.h"

typedef enum {
    RING_BUFFER_SUCCESS                  = 0,
    RING_BUFFER_ERR_NOT_INIT                ,
    RING_BUFFER_ERR_MALLOC_BUFF_FAILED      ,
    RING_BUFFER_ERR_HEAD_INVALID            ,
    RING_BUFFER_ERR_READ_SIZE_OVER_MAX_SIZE ,
    RING_BUFFER_ERR_READ_SIZE_INVALID       ,
    RING_BUFFER_ERR_READ_SIZE_NOT_SUITE_SIZE,
    RING_BUFFER_ERR_WRITE_SIZE_INVALID      ,
    RING_BUFFER_ERR_WRITE_NOT_SPACE         ,
}RingBufferError_E;


int32_t RingBufferInit();

void RingBufferFree();

int32_t ReadRingBuffer(char *buff, int32_t len);

int32_t WriteRingBuffer(const char *buff, const int32_t len);

typedef void* (*RingBufferMallocCBFunc(size_t size));
void RingBufferSetMallocCBFunc(RingBufferMallocCBFunc func);

typedef void* (*RingBufferMemsetSafeCBFunc(void *s, size_t max, int c, size_t n));
void RingBufferSetMemsetSafeCBFunc(RingBufferMemsetSafeCBFunc func);

typedef void* (*RingBufferMemcpySafeCBFunc(void *des, size_t max, void *src, size_t n));
void RingBufferSetMemcpySafeCBFunc(RingBufferMemcpySafeCBFunc func);

typedef void (*RingBufferFreeCBFunc(void *ptr));
void RingBufferSetFreeCBFunc(RingBufferFreeCBFunc func);

#endif //SIMPLE_RINGBUFF_RINGBUFFER_H

RingBuffer.h

#include <stdio.h>
#include "stdint.h"
#include "stddef.h"
#include "string.h"
#include "stdlib.h"
#include "RingBuffer.h"


typedef struct {
    size_t size;
    char *pHead;
    char *pValidRead;
    char *pValidWrite;
    char *pTail;
}RingBuffer;
static RingBuffer buffer;
// mem opt hook
static RingBufferMallocCBFunc     *bufferMallocFunc = NULL;
static RingBufferMemsetSafeCBFunc *bufferMemsetFunc = NULL;
static RingBufferMemcpySafeCBFunc *bufferMemcpyFunc = NULL;
static RingBufferFreeCBFunc       *bufferFreeFunc   = NULL;

static void *bufferMalloc(size_t n) {
    if (NULL != bufferMallocFunc) {
        return bufferMallocFunc(n);
    }else{
       return malloc(n);
    }
}
static void *bufferMemset(void *ptr, size_t max, int32_t n, size_t size) {
    if (NULL != bufferMallocFunc) {
        return bufferMemsetFunc(ptr, max, n, size);
    }else{
        return memset(ptr, n, size);
    }
}
static void *bufferMemcpy(void *des, size_t max, void *src, size_t n) {
    if (NULL != bufferMemcpyFunc) {
        return bufferMemcpyFunc(des, max, src, n);
    }
    return memcpy(des, src, n);
}

static void bufferFree(void *ptr) {
    if (NULL != bufferFreeFunc) {
        bufferFreeFunc(ptr);
    }else{
        free(ptr);
    }
}

int32_t RingBufferInit() {
    bufferMemset(&buffer,sizeof(buffer), 0, sizeof(buffer));
    if (NULL == buffer.pHead) {
        buffer.pHead = bufferMalloc(RING_BUFF_MAX_SIZE);
        if (NULL != buffer.pHead) {
            bufferMemset(buffer.pHead, RING_BUFF_MAX_SIZE, 0, RING_BUFF_MAX_SIZE);
        }else{
            return RING_BUFFER_ERR_MALLOC_BUFF_FAILED;
        }
    }
    buffer.size = 0;
    buffer.pValidRead = buffer.pHead;
    buffer.pValidWrite = buffer.pHead;
    buffer.pTail = buffer.pHead + RING_BUFF_MAX_SIZE;
    memset(buffer.pHead, 0, RING_BUFF_MAX_SIZE);
    return RING_BUFFER_SUCCESS;
}
void RingBufferFree() {
    if (NULL != buffer.pHead) {
        bufferFree(buffer.pHead);
    }
    buffer.size = 0;
    buffer.pHead = NULL;
    buffer.pValidRead = NULL;
    buffer.pValidWrite = NULL;
    buffer.pTail = NULL;
}

int32_t ReadRingBuffer(char *buff, int32_t len) {
    if (NULL == buffer.pHead) {
        return RING_BUFFER_ERR_HEAD_INVALID;
    }
    if (len < 0) {
        return RING_BUFFER_ERR_READ_SIZE_INVALID;
    }
    if (0 == len) {
        return RING_BUFFER_SUCCESS;
    }
    if (len > RING_BUFF_MAX_SIZE) {
        return RING_BUFFER_ERR_READ_SIZE_OVER_MAX_SIZE;
    }
    uint32_t useSpaceSize = buffer.size;
    if (len > useSpaceSize) {
        return RING_BUFFER_ERR_READ_SIZE_NOT_SUITE_SIZE;
    }
    // 取值,可能分段取
    uint32_t firstSegmentLen = buffer.pTail - buffer.pValidRead;
    if (len <= firstSegmentLen) {
        bufferMemcpy(buff, len, buffer.pValidRead, len);
        buffer.pValidRead += len;
    }else{
        // 分两段取
        bufferMemcpy(buff, firstSegmentLen, buffer.pValidRead, firstSegmentLen);
        uint32_t secondSegmentLen = len - firstSegmentLen;
        bufferMemcpy(buff + firstSegmentLen, secondSegmentLen, buffer.pHead, secondSegmentLen);
        buffer.pValidRead = buffer.pHead + secondSegmentLen;
    }
    buffer.size -= len;
    return 0;
}

// 能写缓冲区的条件是,剩余可用的缓冲区可以放下
int32_t WriteRingBuffer(const char *buff, const int32_t len) {
    if (NULL == buffer.pHead) {
        return RING_BUFFER_ERR_NOT_INIT;
    }
    if (len < 0) {
        return RING_BUFFER_ERR_WRITE_SIZE_INVALID;
    }
    if (len == 0) {
        return RING_BUFFER_SUCCESS;
    }
    uint32_t emptySpaceSize = RING_BUFF_MAX_SIZE - buffer.size;
    if (emptySpaceSize < len) {
        return RING_BUFFER_ERR_WRITE_NOT_SPACE;
    }
    uint32_t firstSegmentLen = buffer.pTail - buffer.pValidWrite;
    if (len <= firstSegmentLen) {
        // 一段可存
        bufferMemcpy(buffer.pValidWrite, firstSegmentLen,  buff, len);
        buffer.pValidWrite += len;
    }else{
        // 分段存储
        bufferMemcpy(buffer.pValidWrite,firstSegmentLen, buff, firstSegmentLen);
        uint32_t secondSegmentLen = len - firstSegmentLen;
        bufferMemcpy(buffer.pHead, secondSegmentLen, buff + firstSegmentLen, secondSegmentLen);
        buffer.pValidWrite = buffer.pHead + secondSegmentLen;
    }
    buffer.size += len;
    return 0;
}

void RingBufferSetMallocCBFunc(RingBufferMallocCBFunc func) {
    bufferMallocFunc = func;
}

void RingBufferSetMemsetSafeCBFunc(RingBufferMemsetSafeCBFunc func) {
    bufferMemsetFunc = func;
}

void RingBufferSetMemcpySafeCBFunc(RingBufferMemcpySafeCBFunc func) {
    bufferMemcpyFunc = func;
}

void RingBufferSetFreeCBFunc(RingBufferFreeCBFunc func) {
    bufferFreeFunc = func;
}

use demo

#include <zconf.h>
#include "RingBuffer.h"
#include "stdlib.h"
#include "string.h"
#include "stdio.h"

static void *my_memcpy_s(void *des, size_t max, void *src, size_t n) {
    printf("cpy: from %p to %p , %lu bytes\n",src, des, n);
    return memcpy(des, src, n);
}
static void *my_memset_s(void *s, size_t max, int32_t c, size_t n) {
    printf("memset: %p\n", s);
    return memset(s, c, n);
}
static void *my_malloc(size_t n) {
    void *ptr = malloc(n);
    printf("malloc %lu bytes in %p\n", n, ptr);
    return ptr;
}
static void my_free(void *ptr) {
    printf("free:%p\n", ptr);
    return free(ptr);
}

int main(int argc, char *argv[]) {
    RingBufferSetMallocCBFunc(my_malloc);
    RingBufferSetFreeCBFunc(my_free);
    RingBufferSetMemsetSafeCBFunc(my_memset_s);
    RingBufferSetMemcpySafeCBFunc(my_memcpy_s);
    RingBufferInit();
    char buff[12] = {0};
    int32_t ret = 0;
    for (int i = 0; i < 1000000; ++i) {
        printf("test count[%lu]\n", i);
        WriteRingBuffer("abcdef", 6);
        memset(buff, 0, sizeof(buff));
        ReadRingBuffer(buff, 6);
        printf("%s\n", buff);

        WriteRingBuffer("ghijkl", 6);
        memset(buff, 0, sizeof(buff));
        ReadRingBuffer(buff, 6);
        printf("%s\n", buff);

        ret = WriteRingBuffer("0123456789", 10);
        if (ret != 0) {
            printf("Write failed\n");
        }else{
            printf("Write success\n");
            memset(buff, 0, sizeof(buff));
            ret = ReadRingBuffer(buff, 10);
            if (0 != ret) {
                printf("read 0123456789 failed[%d]\n", ret);
            }else{
                printf("%s\n", buff);
            }
        }
        sleep(1);
    }
    
    RingBufferFree();
    return 0;
}

C-Meessage-Queue使用Demo

#include <zconf.h>
#include <string.h>
#include <errno.h>
#include "message_queue.h"
#include "stdio.h"
#include "pthread.h"
#include "stdbool.h"

static struct message_queue queue;
typedef struct {
    char name[20];
}queue_data_t;
volatile bool exit_thread = false;

void *consumer_thread(void *arg) {
    while (!exit_thread) {
        queue_data_t *data = message_queue_tryread(&queue);
        if (NULL != data) {
            printf("consumer id = %s\n", data->name);
        }
        sleep(3);
    }
    pthread_exit(NULL);
}

void *producer_thread(void *arg) {
    int32_t id = 0;
    while (!exit_thread) {
        queue_data_t *data = message_queue_message_alloc(&queue);
        if (NULL != data) {
            sprintf(data->name, "%d", ++id);
            printf("producer id = %d\n", id);
            message_queue_write(&queue, data);
            if (id == 10) {
                break;
            }
        }
        sleep(2);
    }
    exit_thread = true;
    pthread_exit(NULL);
}

int main(int argc, char *argv[]) {
    memset(&queue, 0 ,sizeof(queue));
    int32_t ret = message_queue_init(&queue, sizeof(queue_data_t), 30);
    if (ret != 0) {
        printf("message_queue_init init failed\n");
    }
    pthread_t producer_handle;
    pthread_t consumer_handler;
    exit_thread = false;
    if (0 != pthread_create(&producer_handle, NULL, producer_thread, NULL)) {
        printf("create producer thread failed[%s]\n", strerror(errno));
        return -1;
    }
    if (0 != pthread_create(&consumer_handler, NULL, consumer_thread, NULL)) {
        printf("create consumer thread failed[%s]\n", strerror(errno));
        
        exit_thread = true;
        pthread_join(producer_handle,NULL);
        message_queue_destroy(&queue);
        return -1;
    }
    
    printf("waitting to exit....\n");
    pthread_join(producer_handle, NULL);
    pthread_join(consumer_handler,NULL);
    message_queue_destroy(&queue);
    printf("exit....\n");
    return 0;
}

信号与事件

linux系统下一共有64个信号,可以通过发送或者捕获特定的信号完成特定的动作,在ctl+c之后完成资源的释放等。

#include <stdbool.h>
#include <zconf.h>
#include "signal.h"
#include "stdlib.h"
#include "stdio.h"
#include "pthread.h"

static bool stop = false;
void exit_sig(int32_t sig) {
    printf("Exit sign %d\n", sig);
    stop = true;
}
void *wait(void *arg) {
    while (!stop) {
        printf("running\n");
        sleep(1);
    }
    printf("waiting exit..\n");
    return NULL;
}

int main(int argc, char *argv[]) {
    signal(SIGINT, &exit_sig);
    signal(SIGTERM, &exit_sig);
    
    pthread_t handle;
    if (0 != pthread_create(&handle, NULL, wait, NULL)) {
        printf("create thread failed\n");
        return -1;
    }
    pthread_join(handle, NULL);
    return 0;
}

获得系统开机时间

#include <stdio.h>
#include <sys/sysinfo.h>
#include <time.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
int main(void)
{
    struct sysinfo info;
    char run_time[128];
 
    if (sysinfo(&info)) {
        fprintf(stderr, "Failed to get sysinfo, errno:%u, reason:%s\n",errno, strerror(errno));
        return -1;
    }
 
    long timenum=info.uptime;
    int runday=timenum/86400;
    int runhour=(timenum%86400)/3600;
    int runmin=(timenum%3600)/60;
    int runsec=timenum%60;
    bzero(run_time, 128);
 
    sprintf(run_time,"系统开机已运行：%d天%d时%d分%d秒",runday,runhour,runmin,runsec);
    printf("--->%s\n",run_time);
    return 0;

c语言得UTC时间戳

1
2
3

time_t utc_time;
time(&utc_time);
printf("timestamp %ld\n", utc_time);

未定义的行为引发的问题:memcpy能不能用作移动数据的函数,不能。
比如想要将data数据往前移动2个字节memcpy(data, data+2, data_size -2)
这样会出现什么问题?有些编译器是支持的,但是有些编译器是将data的值清空之后再赋值。这个是未定义的行为。

关于函数引用问题

两个.c文件里面的函数里面可以相互引用吗？可以。
a.c

1
2
3

int add(int x, int y ) {
    return x + y;
}

b.c

int add(int x, int y);
int main(int argc, char *argv[]) {
    printf("%d\n", add(3, 4));
}

声明和定义的具体区别。

读写锁

为了并发读不受影响,使用读写锁进行共享变量的处理。

int pthread_rwlock_init(pthread_rwlock_t *rwlock);
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);

int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);