字符数组

#include <stdio.h>
#include <string.h>
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:4996)

int main() {

    printf("sizeof HelloWorld = %d\n",sizeof("Hello World")); // sizoof = 12

    // 初始化字符数组第一种方式：
    char str[20] = { 'H','e','l','l','o' };
    // 初始化字符数组第二种方式：
    char str2[20] = "hello"; // 字符串常量末尾会自动添加\0，其余地方会补0
    // 初始化字符数组第三种方式（省略数组中的大小）：
    char str3[] = "hello";

    // 打印数组的第一种方式：
    printf(str3);
    printf("\n%s\n", str3);

    // 测量字符串长度
    int len = 0;
    while (str[len] != '\0') {
        len++;
    }
    printf("len = %d\n",len);

    // 使用strlen测量字符串长度
    // 需要注意：strlen可以接受一个字符串作为参数
    // strlen返回值为这个字符串的长度
    // 使用strlen,需要包含头文件string.h
    int len1 = strlen(str3);
    printf("len1 = %d\n", len1);

    // 输入字符串
    char str5[20];
    scanf("%s\n", str5);
    printf(str5);

    // 输出单个字符putchar()
    // 输入单个字符getchar()
    char c;
    c = getchar();
    c = c - 32;
    putchar(c);


    return 0;
}

输出输出缓存

#include <stdio.h>
#include <Windows.h>


int main() {

    // 使用printf函数，输出十次“hello world”，但是每输出一次需要暂停500毫秒
    /*for (int i = 0;i < 10;i++) {
        printf("Hello World %d\n", i);
        Sleep(500);
    }*/

    // 输出缓存区
    // =================================
    // 行缓存：一行结束之后，必须刷新缓存
    // 完全缓存：等到缓存区被填满才刷新缓存
    //char c1, c2;
    //c1 = getchar();
    //putchar(c1);
    //// 缓冲区中还存在\n 此时需要使用getchar()将缓冲区的\n读取出来
    //getchar();
    //c2 = getchar();
    //putchar(c2);

    // 不带缓存的输入函数
    while (1) {
        char c;
        c = getch();
        putchar(c);
        if (c == 'q') {
            break;
        }
    }

    return 0;
}

函数

#include <stdio.h>


// 函数定义
//返回值类型 函数名(输入参数值) {
//    做点什么事情
//  retrun 返回值
//}
int add(int a,int b) {
    return a + b;
}

// 需要注意，如果函数的定义在调用函数之后，需要提前声明函数
// 函数声明：函数头 + 分号
// 例如：int add(int a,int b);

int main() {
    // 调用函数
    int result;
    result = add(2, 3);
    printf("%d",result);
    return 0;
}

函数递归

#include <stdio.h>

//void func(int n) {
//    if (n == 5) {
//        return;
//    }
//    printf("before %d\n", n);
//    func(n + 1); // 实现函数的递归操作
//    // 这里需要注意，如果在递归中出现递归函数，递归函数前的代码先执行，递归函数后的代码最后执行
//    printf("affter %d\n", n);
//}

// 递归求阶乘的方法
int f(int n) {
    if (n == 0 || n == 1) {
        return 1;
    }
    return n * f(n - 1);
}

int main() {
    //func(0); // 调用递归函数
    int result = f(4);
    printf("%d\n", result);
    return 0;
}

指针

#include <stdio.h>


int main() {
    // 取地址运算符:&
    // 声明指针类型变量：目标数据类型* 变量名
    // 例如
    //int n;
    //int* pn = &n;
    // int* 保存变量n首地址和所需空间大小
    // 指针类型的值是目标数据对象的首地址
    char c;
    char* pc = &c;

    // 取值运算符：*
    // *指针：根据指针中存储的首地址和空间大小找到目标数据对象
    int n = 123;
    int* pn = &n;
    printf("%u\n", pn);// 3602808
    printf("%d\n", *pn);// 123



    return 0;
}

指针运算

#include <stdio.h>

int main() {
    char* pc;
    short* ps;
    int* pn;
    long* pl;
    long long* pll;
    float* pf;
    double* pd;

    // 将指针的首地址设置为100
    pc = (char *)100;
    ps = (short *)100;
    pn = (int *)100;
    pl = (long *)100;
    pll = (long long *)100;
    pf = (float *)100;
    pd = (double *)100;

    // 将每一个指针的首地址都+1
    pc = pc + 1;
    ps = ps + 1;
    pn = pn + 1;
    pl = pl + 1;
    pll = pll + 1;
    pf = pf + 1;
    pd = pd + 1;

    // 从打印的结果可以看出 指针向后移动了sizeof(目标数据对象)个字节
    printf("pc = %u\n", pc); // 101
    printf("ps = %u\n", ps); // 102
    printf("pn = %u\n", pn); // 104
    printf("pl = %u\n", pl); // 104
    printf("pll = %u\n", pll);// 108
    printf("pf = %u\n", pf); // 104
    printf("pd = %u\n", pd); // 108

    // 第一：sizeof(目标数据对象)被称作步长
    // 第二：指针类型加n后，其首地址向后移动n*步长个字节
    // 第三：指针类型减n后，其首地址向前移动n*步长个字节


    // =======================指针的减法==========================
    // 开辟一段连续的空间
    int arr[10];
    printf("&arr[0] = %d\n", &arr[0]);// 3799168
    printf("&arr[5] = %d\n", &arr[1]);// 3799172
    printf("&arr[5] - &arr[0] = %d\n", &arr[5] - &arr[0]); // 5


    return 0;
}

指针与数组

#include <stdio.h>

int main() {
    // 数组元素内存是连续的
    int arr[5] = { 111,222,333,444,555 };
    printf("%d\n", arr[0]);
    printf("%d\n", arr[1]);
    printf("%d\n", arr[2]);
    printf("%d\n", arr[3]);
    printf("%d\n", arr[4]);
    // =======================================
    printf("=========================================\n");
    int* p = &arr[0]; // 指针p指向了第一个元素的首地址
    printf("%d\n", *p);
    printf("%d\n", *(p + 1));
    printf("%d\n", *(p + 2));
    printf("%d\n", *(p + 3));
    printf("%d\n", *(p + 4));
    // 注意：取值运算符的优先级高于算数运算符


    // ==================数组名获取数组首地址======================
    int* p1 = arr;
    printf("sizeof arr = %d\n", sizeof(arr)); // 20
    printf("sizeof p = %d\n", sizeof(p1)); // 4
    // 数组名出现在表达式中，数组名将会转换为指向数组第一个元素的指针
    printf("sizeof arr + 1= %d\n", sizeof(arr + 1)); // 4

    // ==================获取数组中元素的两种方式======================
    // 数组名[下标]
    // *(数组名 + 偏移量)  偏移量是指：指针指向地址与首地址相差几个元素
    // A[k] -> *(A + k)
    // 下标运算符 最终会展开为指针表达式
    // arr[2] -> *(arr + 2)
    // 2[arr] -> *(2 + arr)



    return 0;
}