C语言-1

初始C语言

//    单行注释
/*    多行注释
    

    1.语言发展历程
        二进制的指令 --> 汇编指令 --> B语言 --> C语言(高级语言)

    2.C语言国际标准:
        ANSI C  ---  美国国家标准化组织 C
        C89  C90  C99  C11...

    3.C语言是一门编译型语言，而Python是一门解释型语言
*/

主函数

# include <stdio.h>    // 头文件，详情见下

// 主函数（标准的主函数写法），详情见下
int main(){
    printf("Hello World");    // 输出语句，详情见下
    return 0;
}

/*
    1.头文件，它就相当于一个工具箱，我们引用头文件，就相当于引用一个工具箱
        std    --->    standard
        i    --->    input
        o    --->    output
        因此,# include <stdio.h>的作用是：引入一个“标准输入输出”工具箱
        当我们引入了这个工具箱后，下面的 printf() 代码才能够正常运作 

    ---知识补充：
        # include <stdio.h>        <> 直接在系统目录进行查找，找不到会报错
        # include "stdint.h"    "" 先在当前目录下查找，找不到再在系统目录进行查找，还找不到会报错



    2.main函数，即主函数，也叫入口函数，是程序执行的入口，每一个项目有且仅有一个主函数。
        ---视野拓展：
            void main()        //这是古老的写法（不推荐）
            {
                return 0;
            }

*/

常量

/* 
    什么是常量？

        ---程序运行的过程中，值不会改变的量

    
    常量包括：

        整型常量     如:    123、100、0xa5
        实型常量     如:    3.14、-20.3f、6.23e5、8.12e-3
        符号常量     如:        # define PI 3.14
        地址常量     如:    内存编号，不可改变
        字符常量     如:        'a'    'A'    '@'    '1'    '9'    '\n'   '\\'   '\255'
        字符串常量　　如:     "ABC"    "Ac9"    "a"    ""
*/

变量

/* 
    什么是变量？
    ---1.程序运行的过程中，值可以改变的量
    ---2.代表着一个有名字的，具有特定属性的一段内存
    ---3.可以用来存储数据
    ---4.变量在使用前必须先定义（且有值）
    ---5.变量的命名必须是合法标识符
    ---6.变量名是具有特定属性的一段内存的名字


    变量的命名
        基本要求：
            1.由数字，字母，下划线组成
            2.开头不能是数字
            3.不能是关键字
        注意事项：
            1.区分大小写 
            2.养成好的命名习惯
            3.见名知义
*/

基本数据类型

/* 
    类型
    ---数据的种类（包括存储单元的长度，数据的存储形式等）

    什么是基本数据类型？
    ---最常用的，最基本的，最简单的数据类型

        整型    short、int、long
        实型    float、double
        字符型    char
        枚举型    enum
*/

int main(){
    int a;
    char b = "hello world";
    sizeof(b);    // 查看占了多少字节（1个字节：8位二进制数位）
}

/*
    <整型>

    1."整数"默认是int类型
    2.整型与整型进行运算，结果还是整型，如：3/2的结果为1，而不是1.5（小数部分直接去掉）
    3.    有符合的：signed
        无符号的：unsigned
    4.占用空间
        short        2字节
        int            2字节或者4字节（分别对应32位系统、64位系统）
        long        8字节
    5.取值范围
        例如：
            short        2字节(即：16位二进制数位)        2的8次方(共65536个值)
                signed short        -32767 --- +32768
                unsigned short        0 --- +65535



    <实型/浮点型>

    "小数"默认是double类型---------3.14(double类型)    3.14f(float类型)
        float    单精度    变量占4字节
        double    双精度    变量占8字节




    <字符型>

    注意事项
        1.实际上并没有存储字符，而是存储ASCII码中对应的数值编号
        2.用单引号界定字符    'A' 'a'
        3.区分数字和数字字符

    取值范围
        char类型的变量：  1字节(8位二进制数位)     --->    256个值
            signed char:    -127 --- +128
            unsigned char:    0 --- +255
*/

输入与输出

/* 
    注意事项：
        1.输入的格式非常重要！
        2.输出的时候可能会发生——数据的溢出
*/

# include <stdio.h>
int main(){
    int a,b;
    scanf("%d,%d", &a, &b);    // 输入的时候，一定要按照左边代码的输入格式
    printf("Hello World!  a = %d  and  b = %d.\n", a, b);    // 输出
    return 0;
}

格式化输出

/*

      %a(%A)        [浮点数]、[十六进制数字] 和 [p - 记数法（C99）]
      %c            字符
      %d            有符号十进制整数
      %f            浮点数(包括float和doulbe)
      %e(%E)        浮点数指数输出[e(E)记数法]
      %g(%G)        浮点数不显无意义的零"0"
      %i            有符号十进制整数(与%d相同)
      %u            无符号十进制整数
      %o            八进制整数（e.g.    0112）
      %x(%X)        十六进制整数（e.g.    0x1213）
      %p            指针
      %s            字符串
      %%            "%"

*/

运算符||表达式||语句

/* 
    <运算符>

    1.算术运算符
        加减乘除： + - * /
        求余数：%
        自增自减：++ --


    2.关系运算符
        大于 >        大于等于 >=
        小于 <        小于等于 <=
        等于 =


    3.逻辑运算符
        逻辑与 &&
        逻辑或 ||
        逻辑非 ！


    4.条件运算符
        条件？操作1：操作2（如果条件为真，执行操作1，如果条件为假，执行操作2）
        例如： x > y ? x : y
        补充：可以嵌套使用


    5.位运算符(计算机中的数据按补码形式存储，因此在进行位运算时，直接操作的是补码)
        按位与 &        同1为1
        按位或 |        有1为1
        按位非 ~        取反
        按位异或 ^        同则为0，异则为1（同性相斥，异性相吸）
        左移 <<            向左移动，低位补零
        右移 >>            向右移动，高位补符号位

        ---例如：3 & 5 = 1        -3 & 5 = 5


        -----原码、反码、补码的知识：

            正数的二进制xxx码：
                原码、反码、补码都相同

            负数的二进制xxx码：
                原码 -> 反码：    原码的“符号位”不变，其他的“位”全部取反。
                反码 -> 补码：    反码 + 1 即可得到补码


    6.赋值运算符
        1.简单赋值            =
        2.复合算术赋值        +=  -=  *=  %=
        3.复合位运算赋值    &=  |=  ^=  >>=  <<=


    7.逗号运算符（英文输入法的逗号）
        ---起连接作用
        第一部分, 第二部分, ……, 第n部分
        上面的所有内容是依次运算，但最终取值为：第n部分的值


    8.指针运算符
    ---用于指针运算
        1.取内容        *
        2.取(首)地址    &


    9.求字节运算符
        用于计算所占的字节数
        sizeof()


    10.其他运算符
        ()        强调优先级 或 强制转换类型--------如：int n = (int) 3.14
        []        下标
        + -        数学规则    如：+8、-9
        ::        范围解析
        ->        成员运算符




    <表达式>
        一种有值的语法结构
        由运算符将变量，常量函数调用返回值结合而成
        例如：a + b




    <语句>
        当程序运行时，执行某个动作的语法结构
        它改变变量的值，产生输出或处理输入
        以分号“;”结尾，(注意是英文输入法)

        空语句            只有一个分号的语句，什么也不做
        表达式语句        在表达式的后面加个分号
        语句块            {  z = a + b;  z = z + 1; }
        控制语句        循环语句、条件语句、转移语句

*/

if-else 语句

int main()
{
    int a = 2;

    if (a > 1)
    {
        printf("a > 1");
    }
    else if (a = 1)
    {
        printf("a = 1");
    }
    else
    {
        printf("a < 1");
    }

    return 0;
}

switch 语句

int main()
{
    switch (2 * 0)
    {
    case 0:
        printf("This is a case 0.\n");    // 结果：执行case 0的代码，如果不加上 break 将继续向下执行
        break;

    case 1:
        printf("This is a case 1.\n");
        break;

    case 2:
        printf("This is a case 2.\n");
        switch (0 / 1)    // switch 语句可以嵌套使用
        {
        case 0:
            printf("aaa");
            break;
        case 1:
            printf("bbb");
            break;
        default:
            printf("ccc");
            break;
        }
        break;

    default:
        printf("This is a default.\n");
        break;
    }

    return 0;
}

for 循环

int main()
{
    for (int i = 0; i < 10; i++)
    {
        printf("第%d次循环\n", i);
    }

    return 0;
}

while 循环

int main()
{    
    int i = 0;
    while (i < 10)
    {
        printf("第%d次循环\n", i++);
    }

    return 0;
}

do…while 循环

int main()
{    
    int i = 1;

    do
    {
        printf("现在do第%d次\n", i++);

    } while (i < 10);

    return 0;
}

break||continue

int main()
{    
    for (int i = 0; i < 10; i++)
    {
        if (i == 2)
        {
            continue;
        }
        printf("第%d次循环\n", i);
        if (i == 6)
        {
            break;
        }
    }

    return 0;
}

goto 语句

/*
    1.作用：无条件转移
    2.建议：谨慎使用！！如果用的不好可能会破坏程序的逻辑性和安全性！！
        很多书籍上在提及goto语句时都会提醒读者并不推荐使用它。
        但我们还是推荐读者可以合理的使用goto语句。
        下面为了学习使用goto，我们可以通过goto语句来实现一个“类while语句”的循环功能：
*/
int main()
{
    int day = 1;
    loop:
    if (day <= 28)
    {
        printf("now is day %d\n", day++);
            goto loop;
    }
    return 0;
}
/*
    上面程序就是利用了goto和if语句来实现了循环功能，
    它与while实现的循环功能一样，
    其中loop为我们定义的一个label（标签）。
*/

数组

/*
    1.数组长度：整数，常量表达式，自动获取长度
    ---但是不可以用小数
    ---也不可以是变量，数组在定义时系统会根据数组类型和大小为其分配内存空间
    ---对于这种情况的初始化操作，可以省略不写数组长度，它会自动识别：int c[] = {30, 31, 32, 33};

    2.数组内存是连续的
*/

int main()
{
    int a[5] = {1,2,3};    // 数组的初始化，左边代码只初始化了3个，剩下的2个使用默认值0
    int b[4];    // 由“数组名[下标]”组成，下标从零开始
    b[0] = 10;
    b[1] = 20;
    b[2] = 30;
    b[3] = 40;

    int num[100];

    // 遍历赋值
    for (int i = 0; i < 100; i++)
    {
        num[i] = i;
    }

    // 遍历读取
    for (int i = 0; i < 100; i++)
    {    
        if (i % 10 == 0)    // 每10个数就换一次行
            printf("\n");

        printf("%-3d", num[i]);    // 左对齐，共3位，“数据的位”不足就用空格补位
    }

    return 0;
}

/*
    二维数组的定义形式：
        类型  数组名[行数][列数];
        char a[5][3];


    二维数组的初始化
        按行初始化
            int arr[2][3] = {
                {0, 1},        // 初始化过程中，遇到没有值的，就默认为0（下面同理）
                {10, 11, 12}
            };
        顺序初始化
            int arr[2][3] = {0, 1, 2, 10, 11, 12};

        int arr[][3] = {        // 行可以省略，列不能省略！！
            {0, 1},
            {10, 11, 12}
        };

        ____________________________________________________________________________
        假如你省略行数，但是确定了列数，
        计算机会根据你的列数的数值以及你初始化时给的数据，自动确定行数，
        因此行数可以省略。
        但是如果给了行数但没有确定列数，
        对于你初始化的数据，计算机不知道怎么划分，是平均分呢？还是其他方式分呢？
        这是没有规定的，这样子会出现错误。
        ____________________________________________________________________________
        1、可以同时指定第一维和第二维的长度
        2、可以只指定第二维的长度
        3、不可以只指定第一维的长度
        4、不可以第一维和第二维的长度都不指定
        综上所述，至少指定第二维的长度
        ____________________________________________________________________________

*/

/*
    字符数组

    1.功能类别即可，例如：
        char a[4] = { 'g', 'o', 'o', 'd' };
        char b[] = { 'h', 'e', 'l', 'l', 'o' };

    2.由于C语言没有专门的字符串类型，所以我们把字符数组当成字符串类型去使用：
        char str[30] = { "Hello World" };
        char str[30] = "Hello World";    // 这种形式更加简洁，实际开发中常用

    3.字符串结束标志：'\0'
        例如："hello" ==> 'h', 'e', 'l', 'l', 'o', '\0'    (5字节 + 1字节 = 6字节)

        ---非自动补上“结束标志”：
            char a[4] = { 'g', 'o', 'o', 'd' };
            printf("%s", a)        // 结果是：good???...  因为没有结束符，所以一直输出直到遇到"\0"

        ---自动补上“结束标志”：
            char str[30] = "Hello World";    // 它会自动补上一个结束标志"\0"
            printf("%s", str)    // 结果是：Hello World
*/

函数

/*
    函数的形式：

        返回值类型 函数名(变量1，变量2，...，变量n)    // 形式参数
        {
            函数体;
        }
*/

# include <stdio.h>

// 声明函数---由于代码是从上往下执行的，而 add 函数的定义位于代码最底部，不写声明的话，执行“使用函数”的时候，将不认识 add 函数
int add(int x, int y);

int main()
{
    int a, b;
    printf("Please inter first number>>>");
    scanf("%d",&a);
    printf("Please inter second number>>>");
    scanf("%d",&b);

    // 使用函数
    printf("%d\n", add(a, b));    // 实参(实际参数)拷贝给形参(形式参数)
    return 0;
}

// 定义函数
int add(int x, int y)
{
    return x + y;
}

函数的递归

// 求n的阶乘
#include <stdio.h>

// 声明函数
int test(int x);

int main()
{
    int n;
    printf("Please inter a number>>>");
    scanf("%d",&n);
    printf("%d\n", test(n));
    return 0;
}

int test(int x)
{
    if (x == 0||x == 1)
    {
        return 1;
    };
    return x * test(x-1);
}

字符串处理函数

/*
    对于输入和输出的字符串函数，如 printf、puts、scanf、gets使用时要包含头文件 stdio.h
    而对于其它字符串函数，使用时要包含头文件 string.h
    它是一个专门用来处理字符串的头文件，里面包含了很多字符串处理函数


    常用的字符串函数：
        1.strcpy（字符串复制）
        2.strcat（字符串连接）
        3.strcmp（字符串比较）
        4.strlen（获取字符串长度）
        5.strupr & strlwr（字符串大小写转换）

        详细介绍：
            char a[10] = "happy";
            char b[10] = "good";

            1.strcpy（字符串复制）
                strcpy(a, b);    // 结果        a数组的内容：good    b数组的内容:good

            2.strcat（字符串连接）
                strcat(a, b);    // 结果        a数组的内容：happygood        b数组的内容:good

            3.strcmp（字符串比较）
                strcmp(a, b)    // 按照 ASCII码 顺序比较两个字符数组中的字符串，该函数的返回值无法确定，但是可以与零进行比较

                ---该函数返回值如下：
                        如果返回值大于 0，则表示 a 大于 b。
                        如果返回值小于 0，则表示 a 小于 b。
                        如果返回值等于 0，则表示 a 等于 b。
                    e.g.
                        if (strcmp(a, b) > 0)    // a 大于 b
                        if (strcmp(a, b) < 0)    // a 小于 b
                        if (strcmp(a, b) = 0)    // a 等于 b

            4.strlen（获取字符串长度）
                strlen( a )        // 计算字符串的实际长度（不含字符串结束标志“\0”）,"函数返回值"为字符串的实际长度

            5.strupr（字符串大小写转换）

                    char str[18] = {"HELLO world"};

                1.strupr(字符串数组名) 功能：将字符串中（小写 --> 大写）
                    strupr(str);    // printf(str) =》"HELLO WORLD"


                2.strlwr(字符串数组名) 功能：将字符串中（大写 --> 小写）
                    strlwr(str);    // printf(str) =》"hello world"
*/