奇怪的C函数

 C语言传参

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

// argc 参数个数 
int main(int argc,char **argv)
{
    if(argc!=3)
    {
        printf("Usage: add x y");
        return -1;
    }
    else
    {
        printf("%d \n",atoi(argv[1])+atoi(argv[2]));
    }
    return 0;
}

C语言单引号与双引号

int quotes_test()
{
    // 单引号引起的字符代表整数 大小为1个字节
    printf("%d",'c');
    // 双引号引起的字符代表字符串 大小为字符串字节数+1 (/0)
    printf("%s","c");
}

fib

int fib(int n)
{
    return (n<2) ? n : (fib(n-1)+fib(n-2));
}

内存分配

int memory_test()
{
    // 局部变量在栈区开辟内存空间，由系统管理内存空间，函数结束之后释放,不需要malloc开辟空间
    // int *p;
    // int *p = malloc(sizeof(int));
    // malloc函数的返回值为 void* 类型，可强制类型转换
    int *p = (int *)malloc(sizeof(int));
    if(p == NULL)
        return -1;
    memset(p,0,sizeof(int));
    // calloc 在开辟空间的时候会将分配的内存初始化为0 `calloc()`==`malloc() + memset()`
    // int *p = (int *)calloc(1,sizeof(int));
    // malloc主要为数组和自定义数据结构分配内存
    // int *p = (int *)malloc(sizeof(int)*10);
    // 重新开辟更大的内存空间
    p = realloc(p,sizeof(int)*2);
    if(p == NULL)
        return -1;
    *p=10;
    printf("%d \n",*p);
    free(p);
    p=NULL;
    return 0;
}

断言

// 取消断言
// #define NDEBUG
#include<assert.h>
#define PI 3.14

static int assert_test()
{
    // assert(PI<3);
    int a;
    // 静态断言 补充输出错误提示
    static_assert(sizeof(a)==4,"Assertion `PI<3' failed");
    printf("%f \n",PI);
    return 0;
}

数据库操作

//  gcc consql.c -o sql -L/usr/lib64/mysql -lmysqlclient -lpthread -lm -lrt -ldl
 
 #include<stdio.h>
 #include<stdlib.h>
 #include<unistd.h>
 #include<string.h>
 #include<assert.h>
 #include<mysql/mysql.h>

int main()
{
    //初始化mysql
    MYSQL*mysql=mysql_init(NULL);
    if(mysql==NULL)
        return -1;

    //连接数据库
    mysql=mysql_real_connect(mysql,"127.0.0.1","root","123456","school",3306,NULL,0);
    if(mysql==NULL)
        return -1;

    // 执行sql语句

    char *sql=NULL;
    int res=0;

    // sql="insert into tb_student values(4557,'王五',1,'1999-02-01','四川成都',1)";
    // res=mysql_query(mysql,sql);
    // if(res!=0){
    //     return -1; 
    // }

    sql="select * from tb_student";
    res=mysql_query(mysql,sql);
    if(res!=0)
        return -1;

    //获取结果集
    MYSQL_RES *mysql_res=mysql_store_result(mysql);
    if(mysql_res==NULL)
        return -1;

    // 遍历数据库遍历
    for(int row=0;row<mysql_res->data->rows;row++){
        MYSQL_ROW mysql_row=mysql_fetch_row(mysql_res);
        for(int col=0;col<mysql_res->data->fields;col++){
            if(col==2){
                strcmp(mysql_row[col],"0") ? printf("男 \t") : printf("女 \t");
                continue;
            }
            printf("%s \t",mysql_row[col]);
        }
        printf("\n");
    }

    mysql_free_result(mysql_res);
    mysql_close(mysql);
    exit(0);
}

结构体指针构造静态链表

struct node
{
    int value;
    struct node* next; 
};

int main()
{
    struct node node1,node2,node3;
    node1.value=100;
    node2.value=200;
    node3.value=300;
    node1.next=&node2;
    node2.next=&node3;
    node3.next=NULL;
    struct node* current_node = &node1;
    while(current_node != NULL){
        printf("%d ",current_node->value);
        current_node=current_node->next;
    }
    return 0;
}

双向

struct node
{
    int value;
    struct node* next; 
    struct node* pre;
};

void node_init(struct node * head)
{
    head->pre=head;
    head->next=head;
}

void node_insert(struct node * head, struct node * element)
{
    element->pre=head;
    element->next=head->next;
    head->next->pre=element;
    head->next=element;
}

int main()
{
    struct node head,element1,element2,element3;
    head.value=1;
    element1.value=200;
    element2.value=300;
    element3.value=400;
    node_init(&head);
    node_insert(&head,&element1);
    node_insert(&head,&element2);
    node_insert(&head,&element3);
    struct node * current_node = &head;
    while(current_node->next!=&head){
        printf("%d ",current_node->next->value);
        current_node=current_node->next;
    }
    return 0;
}

栈区(局部变量尽量创建在堆区（malloc开辟内存空间）或者全局区（static修饰）)

char * get_str()
{
    char * str="asdfgh";//字符常量首先开辟到全局区，再拷贝到栈区
    return str;
}

int main(int argc, char ** argv)
{
    // char buf[128];
    // strcpy(buf,get_str());//内存空间销毁之前拷贝到新的内存区域
    // printf("%s",buf);
    char * p = get_str();//栈区的内存空间在函数结束的时候释放
    printf("%s", *p);//该段内存空间已经释放，读取非法空间会引发段错误
    return 0;
}

union

/* 
   可以存放多种不同类型的成员变量，所有成员引用的是内存中的相同位置，
   以最大的成员的内存长度作为union的内存大小，所有的数据成员具
   有相同的起始地址。
*/
union Data {
    int a;
    char b;
};

int main()
{
    union Data data;
    data.a=1; 
    if(data.b==1){ // 01 00 00 00
        printf("小端存储 \n");
    }else{ // 00 00 00 01
        printf("大端存储 \n");
    }
    return 0;
}

数独

void show(int num[][9])
{
    for(int i=0;i<9;i++)
    {
        for(int j=0;j<9;j++)
        {
            printf("%d  ",num[i][j]);
        }
        printf("\n");
    }
}


int findvalue(int sudoku[9][9], int i, int j)
{
    int m, n, k;
    int temp[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
    for(k=1; k<10; k++)
    {
        if(temp[sudoku[i][k-1]]==0)
            temp[sudoku[i][k-1]] = sudoku[i][k-1];
        if(temp[sudoku[k-1][j]]==0)
            temp[sudoku[k-1][j]] = sudoku[k-1][j];
    }
    for(m=0; m<3; m++)
        for(n=0; n<3; n++)
            if(temp[sudoku[i/3*3+m][j/3*3+n]]==0)
                temp[sudoku[i/3*3+m][j/3*3+n]] = sudoku[i/3*3+m][j/3*3+n];
    for(k=1; k<10; k++)
        if(temp[k]==0)
        {
            temp[0]++;
            m=k;
        }
    if(temp[0]==0)
        return -1;
    else if(temp[0]==1)
        return m;
    else
        return 0;
}


int main(void)

{
    int sudoku[9][9] = {{8, 3, 0, 0, 0, 7, 0, 0, 0},
                        {1, 2, 5, 0, 0, 9, 4, 0, 0},
                        {0, 7, 9, 1, 0, 0, 0, 3, 0},
                        {0, 0, 6, 0, 8, 0, 0, 9, 1},
                        {0, 0, 0, 9, 5, 1, 0, 0, 0},
                        {9, 1, 0, 0, 7, 0, 5, 0, 0},
                        {0, 9, 0, 0, 0, 5, 7, 4, 0},
                        {0, 0, 8, 7, 0, 0, 2, 6, 9},
                        {0, 0, 0, 4, 0, 0, 0, 5, 0} };
    // int sudoku[9][9]={0};
    // init(sudoku);
    printf("question: \n");
    show(sudoku);
    int i, j, temp, empty = 0;
    for(i=0; i<9; i++)
    {
        for(j=0; j<9; j++)
            if(sudoku[i][j]==0)
                empty++;
    }
    while(empty)
    {
        for(i=0; i<9; i++)
        {
            for(j=0; j<9; j++)
            {
                if(sudoku[i][j]==0)
                {
                    temp = findvalue(sudoku, i, j);
                    if(temp==-1)
                    {
                        printf("无解！\n");
                        return 1;
                    }
                    sudoku[i][j] = temp;
                    if(temp!=0)
                        empty--;
                }
            }
        }
    }
    printf("answer: \n");
    show(sudoku);
    return 0;
}

整型转换成二进制

#include<stdio.h>

static int getComplement_2(const int number, int* result)
{
    int index = 0;
    unsigned int num = number;
    while(num != 0)
    {
        result[index++] = num%2;
        num = num / 2;
    }
    return 1;
}

int main()
{
    int result[32] = {0};
    int i = 32;
    if(1 == getComplement_2(-1,result))
    {
        while(--i >= 0)
        {
            (i+1)%4 == 0 ? printf(" ") : 1;
            printf("%d",result[i]);
        }
    }
    return 0;
}

my_strncpy

#include<stdio.h>

static char* my_strncpy(char* dst, const char* src, size_t n)
{
    char* ret = dst;
    // 自拷贝会覆盖 需要分情况讨论 
    if(dst<src)
    {
        while(n--)
        {
            *dst++ = *src++;
        }
    }
    else
    {
        int i = 0;
        while(i++<n)
        {
            dst[n-i] = src[n-i];
        }
    }
    return ret;
}

int main()
{
    char arr1[] = "abcdef";
    char arr2[] = "gh";
    printf("%s\n", my_strncpy(arr1,arr2,2));
    return 0;
}