c语言3月13日学习总结

1.整型变量的修饰符

short 类型占 2 个字节，打印使用格式 %hd
int 类型占 4 个字节，打印使用格式 %d
long 类型占 8 个字节，打印格式使用 %ld
long long 类型占 8 个字节，打印格式使用 %lld （注意：处理 32 位机）

2.变量的内存结构

取地址的运算符:
int num;
scanf(“%d”, &num);
- 将一个变量(基本数据类型)作为参数传递给函数,是值传递 此处的&表示取地址运算符,是引用传递

• 如果需要打印地址,就是用%p格式控制字符

• 函数中,定义的变量在内存中是按照地址从高到底进行分配的 每一个函数都应该有一个段栈内存,栈内存是从高往低处分配变量的

• 取值运算符*,表示取某一个地址表示的内存中的数据 变量在内存中会按照定义的顺序从栈地址的较高位子到较低位子进行分配

    // 声明一个char类型的指针(地址)类型
    unsigned char *p;
    p = &num4; // 此时的含义表示 p 指向 0x0003
    // 将p指向的内存中的数据打印出来
    // 指针的类型决定了取值的时候访问多少内存
    // 0000 0001 0000 0001
    // char * 获取数据, 0000 0001
    // short * 获取数据, 0000 0001 0000 0001

    // 指针可以参与运算,但是仅限于+和-
    // p+1表示指针向后移动类型单位长度

3.类型的取值范围

整型的取值范围:

    // 考虑范围
    unsigned int iNum;  // 如果不考虑符号 0, 0-1
    iNum = (unsigned int)0 - 1;   // 无符号类型与有符号类型的运算自动转为无符号类型
    // 1111 1111
    printf("无符号类型的最大值:%u\n", iNum);
    // 1111 1111
    // iNum >> 1
    // 0111 1111
    printf("有符号的最大值 %d\n", iNum >> 1);
    // 1 << 31
    // 1000 0000
    printf("有符号的最小值: %d\n", 1 << 31);

4.字符的本质

// char c = 'a';
// 字符本质实际上是一个数字
// 就是ascii码上的数组
   共 0 - 127 128个
// 0-31 为控制符号 打印无法看到
// 32-127 常用的符号

5.一维数组

• 数组中的每一个元素都不是数组，那么这个数组称为一维数组，即维度为一
  数组定义注意事项:
  1）数组长度不可以变量
  2）数组长度可以使用宏定义（#define M 10）
  3）数组名标识规则与变量名一样
  4）数组的定义可以放在变量中（int num, array[4];）

/*
    数组的定义与初始化:
        数组的定义语法:
            类型 名字[长度];
     */

    // 定义存储10个int数字的数组
    // int nums[10];
    // 定义存储7个char数据的数组
    // char chs[7];


    /*
        所谓初始化:就是赋初值

        1,全部初始化
        1)定义的时候初始化(int num = 10)
            int nums[5] = { 1, 2, 3, 4, 6 };
            可以省略数组后面方括号的数字,编译器会自动根据初始化的数据个数来确定这个数字
            int nums[] = { 1, 2, 3, 4, 6 };
            int nums[] = { 1, 2, 3 };

            int nums[0] = {1, 2, 3};
        2)定义完成后初始化
            int nums[5];
            就是为每一个元素赋值
            引用数组中元素的语法:
                数组名[下标];
            nums[0] = 1;
            nums[1] = 2;
            ...

        2,部分初始化
            int nums[5] = {1, 2, 3};
            会按照数据的顺序进行初始化数组,然后没有数据的地方补零
            int nums[5] = {1, 2, 3, 0, 0};

            int nums[10] = {0};
     */

        int nums1[5] = { 1, 2, 3, 4, 6 };
        int nums2[] = {1, 2, 3, 4, 5};
        int nums3[] = {1, 2, 3};
        // int nums[0] = {1, 2, 3};

        int nums4[3];
        nums4[0] = 1;
        nums4[1] = 2;
        nums4[2] = 3;

        // nums4[4] = 5;

        // int nums5[10] = {[3]=1,2,3};

• 数组的使用说明:

  // 定义数组的使用,常常使用的是宏来设置数组的长度
  // 宏名一般采用大写的单词简写形式

    // #define LEN 256
    // int length = 256;
    int nums[length]; // 在其他编译器中不合法,在 Mac OS 下
    // 代码中使用了宏,在编译的时候,会进行宏替换
    // int nums[LEN];
    // --> int nums[256];
    // --> int nums[256][889];

• 数组遍历
  所谓遍历就是从数组的第0个元素,依次访问数组的每一个元素,直到访问完所有的数组元素

    // 每一个数组元素使用数组名+下标就可以进行访问
    int nums[10] = {1,23,34,45,56,67,78,89,90,100};
    // 遍历这些元素

    printf("%d\n", nums[0]);
    printf("%d\n", nums[1]);
    for (int i = 0; i < 10; i++) {
        printf("%4d", nums[i]);
    }

    printf("\n");
    // 遍历每一个元素,然后给每一个元素扩大两倍
    for(int i = 0; i < 10; i++) {
        // 每一个元素都乘以2即可
        nums[i] *= 2;

        nums[i] <<= 1;
    }

练习1:从键盘输入数据，存入数组，然后遍历求和、平均值、最大值以及最小值,输入q判断为输入结束

#define LEN 256
    // 首先是要输入数组
    int nums[LEN];
    int input, i = 0;
    char ch;
    double sum = 0, avg, max, min;
    do{
        scanf("%d", &input);
        scanf("%c", &ch);

        if(ch != 'q') {
            nums[i++] = input;
        }
    }while(ch != 'q');


    /*
    // 统计出,和\平均\最大和最小
    //1,求和求平均
    // sum就是循环累加,sum / i
    for(int index = 0; index < i; index++) {
        sum += nums[index];
    }
    avg = sum / i;
    printf("sum = %.4f, avg = %.4f\n", sum, avg);

    // 2,求最大求最小
    // 假定第0个元素是最大的,遍历数组,依次作比较,将大的存起来
    // 遍历结束,最大的也就求出来了
    max = min = nums[0];
    for (int index = 1; index < i; index++) {
        if(nums[index] > max) {
            max = nums[index];
        }
        if(nums[index] < min) {
            min = nums[index];
        }
    }
    printf("max = %.2f, min = %.2f\n", max, min);
    */
        min = max = nums[0];
        // min 取该数据范围的最大值
        // max 取该数据范围的最小值
    for (int index = 0; index < i; index++) {
        // 求和
        sum += nums[index];
        // 筛选最大与最小
        if(nums[index] > max) {
            max = nums[index];
        }
        if(nums[index] < min) {
            min = nums[index];
        }
        // min = (nums[index] < min) ? nums[index] : min;
    }
        avg = sum / i;

    printf("sum = %.4f\n", sum);
    printf("avg = %.4f\n", avg);
    printf("min = %.4f\n", min);
    printf("max = %.4f\n", max);

练习2:使用数组实现打印输入的二进制格式

    int nums[LEN], i = 0;
    //          1001001000011100
    //          1001001000011100
    int num = 0b1001001000011100; // 101
    // 00000000 00000000 00000000 00000011
    // 从左往右获取每一个二进制位的数据

    // num & 1
    // 最简单的时讲数字与1做按位与运算符
    // 0000 1011
    // 0:   1   0000 0101
    // 1:   1   0000 0010
    // 2:   0   0000 0001
    // 3:   1   0000 0000

    // 1011

    // int nums[32];
    // int i = 0;

    // nums[i++] = ...;
    // for(i = len-1; i>=0; i--) {

    // }

    do {
        nums[i++] = num & 1;
        num >>= 1;
    } while (num != 0);

    // for (int index = i - 1; index >= 0; index--) {
    //     printf("%d", nums[index]);
    // }
    //  012345
    //  011011

    // i = 6
    // 0: i=5
    // 1: i=4
    // 2: i=3
    // 3: i=2
    // 4: i=1
    // 5: i=0

    //    1,0
    while(i--) printf("%d", nums[i]);

    printf("\n%d\n", i);

    printf("\n");

• 数组在内存中的存储方式

• /*
  数组的定义是什么?
  数组是同一类型的变量,连续的存储在内存中
  &变量 取地址运算符
  *存地址变量 取值运算,将地址中指向的内存中的数据读取出来

  数组的名字,表示数组的首地址
  

  */
  // 变量是从高往低
  // 数据的内存存储是从低往高

• 计算数组长度
  // sizeof
  int num1[10];
  // printf(“%d\n”, sizeof(num1) / sizeof(int));
  // 数组的首地址与数组元素第0项元素的首地址相同
  // 数组的名字就表示数组的首地址
  // 打印数组首地址:
  // printf(“%p”, nums); 正确
  // printf(“%p”, &nums); 错误