C语言练习代码

概述
常规操作
1. 数据表达
1.1 量
1.1.1 常量
1.1.2 变量
1.2 数据类型
1.2.1 基本数据类型
1.2.2 扩展数据类型
2. 控制结构
2.1 条件控制
2.2 循环控制
指针操作

概述

本篇博客(笔记）主要是根据自己对编程语言和C编程语言的理解，总结复习所创作的，包括简单的概述和主要的实现代码。
不同于另外一篇博客《关于编程.md》中介绍的内容 ，本篇博客主要是代码干货。

常规操作

1. 数据表达

数据表达主要包括：量的概念，数据类型，数据运算，表达式 ，返回值，共5部分内容（目前暂且总结如此）。

1.1 量

1.1.1 常量

常量是直接指定的字面量。
示例代码段：

/*
 *本段程序代理主要在于:量-常量的学习和使用
 */
#include
int main(){
    printf("I am number:100\n");    //通过printf函数，打印字符串常量，整型常量，转义字符(字符常量)
    return 0;
}

1.1.2 变量

变量是某块约定大小（约定大小可以理解为数据类型）的内存区域的标签。
变量=内存区域，变量值=内存存放值，变量地址=内存地址，变量声明=编译器开辟内存
取值操作=取内存地址，解引地址=取内存值
示例代码段：

/*
 *本段程序代理主要在于:量-变量的学习和使用
 */
#include
int main(){
    //整型变量
    int int_var_001 = 100;
    printf("int_var_001 is :%d\n",int_var_001);
    //字符变量
    char char_var_001 = 'A';
    printf("char_var_001 is :%c\n",char_var_001);
    //字符串变量
    char * string_var_001 = "liwanliang";
    printf("string_var_001:%s\n",string_var_001);
    return 0;
}

1.2 数据类型

编程语言的数据类型都可以分为两大类：基本数据类型，扩展数据类型（或者构造数据类型）
同时任何数据都只有两种表现方式：数，字符，这是数据的基本组成元素。基本元素组成基本数据类型。
C语言基本数据类型包括：整型，字符，字符串，枚举，空类型

1.2.1 基本数据类型

/*
 * 本程序段主要打印内置的数据类型，取值范围，最值等
 */
#include
#include
#include
int main(){
    printf("----------size------------\n");
    printf("1 byte,sizeof(char):%d\n",sizeof(char));
    printf("2 byte,sizeofof(short int):%d\n",sizeof(short));
    printf("4 byte,sizeofof(int):%d\n",sizeof(int));
    printf("4 byte,sizeofof(float):%d\n",sizeof(float));
    printf("8 byte,sizeofof(long int):%d\n",sizeof(long));
    printf("8 byte,sizeofof(double):%d\n",sizeof(double));
    printf("--------max and min------\n");
    printf("char max:%d,char min:%d\n",CHAR_MAX,CHAR_MIN);
    printf("unsign char max:%d,char min:%d\n",UCHAR_MAX,0);
    printf("short max:%d,short min:%d\n",SHRT_MAX,SHRT_MIN);
    printf("unsign short max:%d,short min:%d\n",USHRT_MAX,0);
    printf("int max:%d,int min:%d\n",INT_MAX,INT_MIN);
    printf("unsign int max:%ld,int min:%ld\n",UINT_MAX,0);
    printf("long max:%ld,long min:%ld\n",LONG_MAX,LONG_MIN);
    printf("unsign long max:%lld,long min:%ld\n",ULONG_MAX,0);
    printf("FLT_MAX:%f,FLT_MIN:%f\n",FLT_MAX,FLT_MIN);
    printf("DBL_MAX:%f\n,DBL_MIN:%f\n",DBL_MAX,DBL_MIN);
    return 0;
}

1.2.2 扩展数据类型

/*
 * 扩展数据类型:数组
 * 整型数组的定义，初始化，值运算
 * 字符数组和字符串
 */
#include
#define SIZE 4
int main(){
    //未初始化整型数组
    int int_array_001[SIZE];
    //初始化整型数组
    int int_array_002[SIZE] = {1,2,3,4};
    //循环进行数组初始化
    for ( int i = 0; i < SIZE; i++ )
    {
        int_array_001[i] = i;
        printf("int_array_001[%d] is : %d\n",i,i);
    }
    //循环输出数组值
    for ( int i = 0; i < SIZE; i++ )
    {
        printf("int_array_002[%d] + 100 = %d\n",i,i+100);
    }
    //字符数组
    char char_array_001[SIZE] = {'l','i','w','l'};
    for ( int i = 0; i < SIZE; i++ )
    {
        printf("%c",char_array_001[i]);
    }
    printf("\n");
    //字符数组初始化
    char char_array_002[SIZE];
    for ( int i = 0; i < SIZE; i++ )
    {
        char_array_002[i] = 'A';
        printf("char_array_002[%d]:%c\n",i,char_array_002[i]);
    }
    //字符串
    char *name = "liwanliang";
    //printf("%s\n",name);
    char char_array_003[sizeof("liwanliang")];
    //printf("%d\n",sizeof("liwanliang"));
    for ( int i = 0; i < sizeof("liwanliang"); i++ )
    {
        printf("%c ",*name++);
    }
    printf("\n");

    return 0;
}

扩展数据类型-数组

/*
 * 本代码段主要学习二位数组
 * 主要是整型，字符，字符串型二维数组
 */
#include
#define SIZE_C 2
#define SIZE_K 2
int main(){
    //int型二维数组，未赋初值
    int int_array_001[SIZE_C][SIZE_K];
    int i,j;
    for ( j = 0; j < SIZE_K; j++ )
    {
        for ( i = 0; i < SIZE_C; i++ )
        {
            int_array_001[i][j]=i+j;
            printf("int_array_001[%d][%d]:%d\n",j,i,int_array_001[i][j]);
        }
    }
    //int型二位数组
    printf("\n");
    int int_array_002[SIZE_C][SIZE_K] = {{1,2},{3,4}};
    int m,n;
    for ( n = 0; n < SIZE_K; n++ )
    {
        for ( m = 0; m < SIZE_C; m++ )
        {
            printf("int_array_002[%d][%d]:%d\n",n,m,int_array_002[n][m]);
        }
    }
    //char型二维数组，未赋初值
    printf("\n");
    char char_array_001[SIZE_C][SIZE_K];
    int k,t;
    for ( t = 0; t < SIZE_K; t++ )
    {
        for ( k = 0; k < SIZE_C; k++ )
        {
            char_array_001[k][t] = 'A'+k+t;
            printf("char_array_001[%d][%d]:%c\n",t,k,char_array_001[k][t]);
        }
    }
    return 0;
}

扩展数据类型-结构体

/*
 * 本段代码主要用于学习结构体的实践
 * 结构体是基于基本数据结构扩展的数据类型
 * 因为数组也是数据类型，相互结合就会存在结构体数组和数组结构体的概念
 * 结构体实际上相当于自己定义了一个静态类型数据类型
 */
#include
int main(){
/*
 * 结构体内部只用于定义数据类型，不能初始化
 * 定义数据类型知识告诉编译器其存储结构
 */
    struct struct_001{
        //ID
        unsigned int id;
        //字符串型
        char *name;
        //int型
        int age;
        //字符型
        char sex;
    };

    struct struct_001 str_liwl_001 = { 9, "liwanliang", 28, 'M' };
    //重命名struct_001数据类型
    //typedef struct struct_001 str_001;
    //声明变量
    //str_001 str_liwl_001;
    //str_001 str_liwl_001 = { 0,"liwanliang01",28,'M'};
    printf("str_liwl_001.id:%d\n",str_liwl_001.id);
    printf("str_liwl_001.name:%s\n",str_liwl_001.name);
    printf("str_liwl_001.age:%d\n",str_liwl_001.age);
    printf("str_liwl_001.sex:%c\n",str_liwl_001.sex);
    printf("\n");

    //结构体数组.其初始化可以在声明时进行，也可以单独进行(for循环)。
    struct struct_001 struct_array_001[3] = {{0,"liwanliang01",21,'M'},{1,"liwanliang02",22,'F'},{2,"liwanliang03",23,'N'},};
    int i = 0;
    for ( i = 0; i < 3; i++ )
        printf("%d,%s,%d,%c\n",struct_array_001[i].id,struct_array_001[i].name,struct_array_001[i].age,struct_array_001[i].sex);
    //结构体元素包括数组，结构体
    struct struct_002 {
        int int_array_001[3];
        struct struct_001 struct_liwl_01;
        struct struct_001 struct_liwl_02[3];
    };
    struct struct_002 struct_liwl_002 = { {1,2,3},{0,"liwanliang1",21,'M'}, };
    printf("%d\n",struct_liwl_002.int_array_001[2]);
    printf("%d,%s,%c\n",struct_liwl_002.struct_liwl_01.id,struct_liwl_002.struct_liwl_01.name,struct_liwl_002.struct_liwl_01.sex);

    return 0;
}

2. 控制结构

2.1 条件控制

/*
 * 本程序片段主要学习控制结构-条件控制
 * 条件控制
 * 是对if语句后的(条件)表达式的返回值进行真值判断,根据不同的真值结果执行不同的语句模块
 * if 语句的三种模型:
 * 1.如果，那么
 * 2.如何就，否则就
 * 3.嵌套
 */
#include
int main(){
    //if 基本原理:表达式结果为真时执行.大多是条件表达式，很少是量(常量或者变量)，或者运算表达式
    if ( ! 0 ) //表达式结果非零,执行语句
        printf("This line cat be print,because of !0\n");
    if ( 0 ) //表达式结果零，不执行
        printf("This line can't be print\n");
    if ( 1 )
        printf("1\n"); //非零值执行


    //如果，那么 | 单条件，单分支
    int int_var_001 = 100;
    //if ( 1 )
    if ( int_var_001 > 1 )
        printf("int_var_001:%d > 1\n",int_var_001);
    printf("\n");

    //如果就，否则就 | 单条件，双分支
    if ( int_var_001 > 101 )
        printf("int_var_001:%d > 101\n",int_var_001);
    else
        printf("int_var_001:%d < 101\n",int_var_001);
    printf("\n");
    //如果,就;否则如果,就;否则如果,就;否则,就 | 单条件，多分支
    if ( int_var_001 > 50 )
        printf("int_var_001:%d >= 100\n",int_var_001);
    else if ( 50 < int_var_001 < 100 )
        printf("50 < int_var_001:%d < 100\n",int_var_001);
    else if ( int_var_001 >= 100 )
        printf("int_var_001:%d >= 100\n",int_var_001);
    else
        printf("int_var_001:%d < 50\n",int_var_001);
    //如果:如果,就:就 | 嵌套
    if ( int_var_001 > 50 )
    {
        printf("int_var_001:%d > 50\n",int_var_001);
        if ( int_var_001 > 80 )
        //{
            printf("int_var_001:%d > 80\n",int_var_001);
        //}
    }
    else
    //{
        printf("int_var_001:%d < 50\n",int_var_001);
    //}
    printf("\n");
    /*多个条件的情况*/
    int int_var_002 = 200;
    int int_var_003 = 300;
    //如果，那么 | 多个条件，单分支
    if ( int_var_003 > int_var_002 && int_var_001 > 50 )
    {
        printf("int_var_003:%d > int_var_002:%d\n",int_var_003,int_var_002);
        printf("int_var_003:%d - int_var_002:%d = %d\n",int_var_003,int_var_002,int_var_003 - int_var_002);
    }
    //如果就，否则就 | 多个条件，双分支
    if ( int_var_003 < int_var_002 || int_var_001 != 100 )
        printf("int_var_003:%d < intt_var_002:%d 或者 int_var_001 = %d\n",int_var_003,int_var_002,int_var_001);
    else
        printf("判断失败\n");
    //嵌套 | 多个条件，多分支
    if ( int_var_003 < int_var_002 && int_var_001 == 100 )
        printf("首个条件判断成立\n");
    else if ( int_var_003 == 300 && int_var_002 == 200 && int_var_001 == 100 )
        printf("第二个条件判断成立\n");
    else
        printf("判断失败\n");
    // 三元表达式：等价于双分支
    printf("%d\n",int_var_003 > int_var_002 ? int_var_003 : int_var_002);
    // swtich语句: 等价于多分支
    switch (int_var_003 - int_var_002) { //switch后跟表达式:赋值表达式,运算表达式,条件表达式,逻辑表达式等
        case 1: //case是表达式的返回值
            printf("1\n");
            break;
        case 10:
            printf("10\n");
            break;
        case 100:
            printf("100\n");
            break;
        default: //无匹配值时的默认值
            printf("no\n");
    }
    // 条件跳转和返回
    int int_var_004 = 0;
    int int_var_005 = 5;
    for ( int_var_004 = 0; int_var_004 < 10; int_var_004++ )
    {
        if ( int_var_004 == int_var_005 )
            return; //结束函数，退出(本段代码会直接跳出主函数，不执行Last line
            //break; //跳出循环，执行Last line
            //continue; //跳过本次循环，执行Last line
        printf("run at:%d\n",int_var_004);
    }
    printf("Last line\n");
    return 0;
}

2.2 循环控制

#include
int main(){
    /*for*/ //根据条件遍历一次
    int int_var_001 = 0;
    for ( int_var_001 = 0; int_var_001 < 10; int_var_001++ )
    {
        //printf("int_var_001:%d\n",int_var_001);
        printf("int_var_001:%d,是%c\n",int_var_001,int_var_001%2?'A':'B');
    }
    printf("\n");

    /*while*/ //先遍历条件判断,后操作
    int int_var_002 = 10 ;
    while ( int_var_002 != 0 )
    {
        printf("int_var_002:%d\n",int_var_002);
        int_var_002--;
    }
    printf("\n");
    /*do-while*/ //先操作,后遍历条件判断
    int int_var_003 = 10;
    do {
        printf("int_var_003:%d\n",int_var_003);
        int_var_003--;
    } while ( int_var_003 != 0 );

    return 0;
}

指针操作

/*
 * 本代码段主要学习指针内容
 */
#include
int main(){
    /*
    *数据类型指针
    */

    //量
    ////常量指针

    ////变量指针
    //////整型变量指针
    int int_a = 100;
    int *p_int_a = &int_a; //*表示指针的声明
    printf("%d\n",*p_int_a); //*表示解引指针=获取内存值
    //////字符变量指针
    char char_a = 'A';
    char *p_char_a = &char_a;
    printf("%c\n",*p_char_a);
    //////字符串变量指针
    char *string_a = "liwanliang";
    char **p_string_a = &string_a;
    printf("%s\n",*p_string_a);
    printf("\n");

    ////数组指针
    //////整型数组指针
    int array_001[4] = {1,2,3,4};
    int *p_array_001 = array_001; //数组名就是数组首地址,也是第一个元素的地址
    /*上行代码等效 int *p_array_001 = &array_001[0] */
    printf("array_001[2]:%d\n",*(p_array_001+2));
    int i001 = 0;
    for ( i001 = 0; i001 < 4; i001++ ) //for循环体中只有一行语句时，括号可省略
    //{
        printf("array_001[%d]:%d\n",i001,*p_array_001++); //*p_array_001++，指针运算，取值后指针+1xsize
    // printf("array_001[%d]:%d\n",i001,array_001[i001]); //等效于上一行
    //}
    printf("\n");
    //////字符数组指针,同上
    //////字符串数组指针
    char *array_002[3] = {"lwl","liwl","liwanliang"};
    char **p_array_002 = array_002;
    int i002 = 0;
    for ( i002 = 0; i002 < 3; i002++ )
    //{
        printf("%s\n",*p_array_002++);
    // printf("%s\n",array_002[i002]); //等效于上一行
    //};
    ////二维数组指针
    //在二维数组中，一维数组可以看成是基本数据类型，关系同字符和字符串
    /*二维数组需要定义一个指向扩展类型的指针，而不是指向基本数据类型的指针*/
    //////整型二维数组
    int array_005 [4][4] = {{1,2,3,4},{5,6,7,8},{11,12,13,14},{15,16,17,18}};
    printf("%d,%d,%d,%d\n",array_005,&array_005[0],&array_005[0][0],*array_005); //二维数组首地址的四种表示方式
    int (*p_array_005)[4] = array_005; //定义一个数组指针(基本数据类型指针，扩展数据类型指针),这里是扩展数据类型指针-数组指针
    printf("%d\n",*(*(p_array_005+3)+1));
    int i004,i005 = 0;
    for ( i004 = 0; i004 < 4; i004++ )
    {
        for ( i005 = 0; i005 < 4; i005++ )
            printf("%d ",*(*(p_array_005+i004)+i005));
    }
    printf("---------\n");
    //////字符串二维数组
    ////结构体指针
    struct struct_var_001{
        int id;
        char sex;
        char *name;
    }; //定义普通结构体
    struct struct_var_001 str_liwl_001 = {1,'M',"liwanliang"}; //声明结构体变量
    struct struct_var_001 *p_str_liwl_001 = &str_liwl_001;
    printf("%d,%c,%s\n",p_str_liwl_001->id,p_str_liwl_001->sex,p_str_liwl_001->name); //不需要解引符号的取值操作
    printf("\n");

    struct struct_var_002{
        int array_int_002[4];
        char array_char_002[4];
    }; //带数组元素的结构体
    struct struct_var_002 str_liwl_002 = {{1,2,3,4},{'A','B','C','D'}};
    struct struct_var_002 *p_str_liwl_002 = &str_liwl_002;
    printf("%d,%c\n",p_str_liwl_002->array_int_002[3],p_str_liwl_002->array_char_002[3]); //数组还是以普通方式索引
    printf("\n");

    struct struct_var_003{
        int array_int_003[4];
        int *p_array_int;
        char array_char_003[4];
        char *p_array_char;
    }; //带指针元素的结构体
    struct struct_var_003 str_liwl_003 = {{1,2,3,4},NULL,{'A','B','C','D'},NULL};
    struct struct_var_003 *p_str_liwl_003 = &str_liwl_003;
    p_str_liwl_003->p_array_int = (int *)&(p_str_liwl_003->array_int_003); //将结构体的第一个元素地址赋值给第二个元素,需要强制类型转换
    p_str_liwl_003->p_array_char = (char *)&(p_str_liwl_003->array_char_003);
    int i003 = 0;
    for ( i003 = 0; i003 < 4; i003++ )
        printf("%d,%c\n",p_str_liwl_003->p_array_int[i003],p_str_liwl_003->p_array_char[i003]);
    printf("\n");
    for ( i003 = 0; i003 < 4; i003++ )
        printf("%d,%c\n",*(p_str_liwl_003->p_array_int)+i003,*(p_str_liwl_003->p_array_char)+i003);
    ////函数指针
    ////指针的指针

    return 0;
}

参考教程：
http://c.biancheng.net/cpp/html/2930.html
https://blog.csdn.net/jhcconan614/article/category/6486327