C语言各个知识点的举例（持续更新）

作为一名正在学习C语言的新人，记录C语言学习心得

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stddef.h>
//二维数组
int main() {
    int arr[2][3]={{1,3,5},{5,6}};
    int i,j;
    for(i=0;i<2;i++){

        for(j=0;j<3;j++){

            printf("arr[%d][%d]=%p",i,j,&arr[i][j]);
            printf(" ");

        }

        printf("\n");

    }
    return 0;
}


int main() {
    char arr[5];
    int i;
    for( i=0;i<5;i++) {
        scanf("%c", &arr[i]);
    }
    for(i=0;i<5;i++){
        printf("%c",arr[i]);
    }
}

int main(){

    char i[]= " cao ";
    char j[]= " fuck you ";
    //strcpy(i,j);//复制数组
    //strlen(i);//计算数组长度
    strcat(i,j);//将j的数组连接在i后面
    printf("%s",i);

    return 0;
}

int main(){

    int arr[4]= {0,1,2,3};
    int *p = arr;
    printf("%d\n",*(p+2));
    *p = 10;
    printf("%p",p);
}

//自建计算char数组长度
int my_len(char* p){           
    char *start = p;
    char *end =p;
    while (*end != '\0'){
        end++;
    }
    int a = end - start;
    return a;

}

int main(){
    char str[]="fafsa";
    int len = my_len(str);
    printf("%d",len);
    return 0;

}

//指针
int main(){
    char i[]= "awdwadad";
    char j[]= "aefefsefsdf";
    char* k[]= {i,j};
    printf("%c",*k[0]);

    int q[]= {1,2,3};
    int a[]= {4,5,6};
    int* c[]= {q,a};//指针数组
    printf("%d",*c[0]);
    printf("\n");
    int q[2][3]={{1,2,3},{4,5,6}};

    int(*h)[]= q;//数组指针
    printf("%p",&q[1][2]);
    printf("\n");
    printf("%p\n",(*h+1));

	//一维数组的表达
    int arr[] = {1,2,3,4,5,6};
    int (*p)[]= &arr;                  
    printf("%p",(*p));
     const int* p[]= {0};

}

//指针函数的传参
 void test(int(*p)[]){


}
int main(){
    int arr[4][3]= {0};
    test(arr);

    return 0;
}

//函数指针

int test(int x,int y){
    return x+y;
}
int test1(int x,int y){
    return x-y;
}
int main(){
    int(*p)(int,int)= test;
    printf("%p\n",test);
    printf("%p\n",p);
    int x = (*p)(1,2);
    printf("%d",x);
    printf("\n");

    int(*d[])(int,int)= {test,test1};//函数指针数组
    printf("%d",d[0](1,1));
    printf("\n");
    printf("%d",d[1](1,1));
    printf("\n");
    int(*(*h)[])(int,int)=&d;//指向函数指针数组的指针
    printf("%d",(*h)[1](1,5));
    printf("\n");


    return 0;
}


//qsort用法
int cmp(const void* x,const void* y){

    return ((int)(*(float *)x-*(float*)y));
}

int main(){
    float arr[]={4.0,2.0,3.0,1.0,5.0,8.0,7.0,6.0,9.0};   
    int sz = sizeof(arr)/sizeof(arr[0]);
    qsort(arr,sz,sizeof(arr[0]),cmp);
    for (int i = 0; i < sz ; ++i) {
        printf("%f",arr[i]);
    }
}
 
 
int main(){
    char a[]= "adssa";
    int sz = sizeof(a)/sizeof(a[0]);
    printf("%d\n",sz);

}
 
//结构体

struct a
{
    int c;
};
struct x
{
    char a;
    struct a cx;
    int b;
};
int main(){
    struct x zc={'c',{5},3};
    printf("%c %d %d",zc.a,zc.cx.c,zc.b);
    return 0;
}


//更改默认对齐数
#pragma pack(1) 
struct x
{
    char a;
    int b;
};
#pragma pack()
int main(){
    struct x a = {'c',5};
    printf("%d\n",sizeof(a));
    printf("%d",offsetof(struct x,b));//头文件stdderf
    return 0;
}

//结构体应用

struct ab
{
    int a;
};
void x(struct ab *p){
    p->a = 5;
}
int main(){
    struct ab e = {0};
    x(&e);
    printf("%d",e.a);
}
 
//枚举

enum xz{
    X = 5,Y = 6,Z = 7
};
int main (){
    printf("%d %d %d",X,Y,Z);
}

//大小端判断，联合体、共用体的使用

int check(int a){
    union sb{
        char x;
        int c;
    }h;
    h.c = a;
    return h.x;

}

int main(){
    int a = 1;
    int c = check(a);
    printf("%d",c);
    if (c == 1){
        printf("小端");
    }else{
        printf("大端");
    }
    return 0;
}

//位段

struct sb{
    int x:5;//指int类型x占位5bit，意思是从分配的四字节中降为32bit，然后开始排序
    int y:6;//位段的开辟是而且只能是四个字节或一个字节
};
int main(){
    struct sb x;
    printf("%d",sizeof(x));//4
}

//构造体指针用法

struct sb{
    int age;
    char name[0];//各种编译器所呈现的柔性数组不一样，可以用[]或[0]测试，
                 //柔性数组前面至少得有一个其他类型数据
                 //sizeof返回大小不包含柔性数组
                 //柔性数组必须在结构体最后一个成员
};
struct sm{
    struct sb date[5];
    int size;
};
void test(const struct sm *p){
    p->date[p->size].name = "fuck";
}
int main(){
    int a = 0;
    scanf("%d",a);
}

//动态内存头文件strlib

int main(){
    int* p = (int*)malloc(10*sizeof(int));//申请内存空间，不初始化值，效率高
    int* pp = (int*)calloc(10,sizeof(int));//申请内存空间，初始化值为0，效率比malloc低
    free(p);//释放内存
}

struct sb{
    int* a;
    //构造体函数中有指针类型，须开辟一个内存空间，使指针指向该空间，可以等价于一个数组
    //这种类似于柔性数组有劣势就是cpu读取数据的时候没有连续性，数据的传输是硬盘>内存>cache>寄读器，cpu首先
    //会从最高处的寄读器读取数据，没有数据再依次向下读取，有个局部性原理是再传输数据的时候会将周围的数据也一起
    // 传输到寄读器，使之效率变高，柔性数组就解决了这个问题，但是int* a这个会使内存之间的地址出现断层，使cpu
    // 读取数据效率变低

};
int main(){
    struct sb* p = (struct sb*)malloc(sizeof(struct sb)+5*40);
    p->a = malloc(sizeof(struct sb));
    if(p->a != NULL) {
        p->a[1] = 5;
    }
    free(p->a);
    p->a = NULL;
    free(p);
    p = NULL;
}    

//fgetc用法
int main(){
    FILE *p = fopen("test.txt","r");
    //int a = fgetc(p);
    //printf("%c",a);
    char arr[1024];
    fgets(arr,1024,p);
    printf("%s",arr);
    fclose(p);
    p = NULL;
}

//fgets用法

int main(){
    FILE *p = fopen("test.txt","r");
    char arr[1024];
    fgets(arr,1024,p);
    printf("%s",arr);
    fclose(p);
    p = NULL;
}

//fprintf用法/格式化的形式写入文件
struct s{
    int a;
    char b;
};
int main(){
    struct s s={4,'c'};
    FILE *p = fopen("test.txt","w");
    if (p == NULL){
        return 0;
    }
    fprintf(p,"%d %c",s.a,s.b);
    fclose(p);
    p == NULL;
    return 0;
}


//如果想直接从键盘读取数据，指针为stdin
// 从屏幕打印数据，指针为stdout

//格式化的形式写入文件数据
struct s{
    int a;
    char b;
};
int main(){
    struct s s={0};
    FILE *p = fopen("test.txt","r");
    if (p == NULL){
        return 0;
    }
    fscanf(p,"%d %c",&(s.a),&(s.b));
    fclose(p);
    printf("%d %c",s.a,s.b);
    p == NULL;
    return 0;
}

如有出错，请大家指点