Day06

类型说明符

• 长度说明符
  注意点: 书写长度说明符号可以省略int

int main()
{
    /*
     *
     * 1.说明长度的
     * short
     * long(不常用)
     * long long
     *
     *
     * char 1个字节 -2^7 ~ 2^7-1
     * short 2个字节
     * int  4个字节 -2^31 ~ 2^31-1
     * long int
     * 如果在32位编译器,long int 占用4个字节
     * 如果在64位编译器,long int 占用8个字节
     *
     * long long int 8个字节 -2^63 ~ 2^63-1
     *
     * 注意点:
     * 1. 如果存储的数据超出了类型所对应的取值范围,那么就会导致存储的数据不对
     * 2. 由于内存非常有限, 所以在编写程序的时候,尽量合理的定义变量
     * 3. 由于说明长度的类型说明符一般都是用于说明int类型,所以在使用的时候可以省略int
     * 4. 类型的取值:
     *    short---> %hi  long --> %li  long long --> %lli
     */

    char ch = 128; //超出char范围取出值不正确
    printf("%c\n", ch);

    int num = 123456789123; //超出int范围取出值不正确
    printf("%i\n", num);
    short num2 = 130;
    printf("%hi\n", num2);
    long long num1 = 132;
    printf("%lli", num1);
    return 0;
}

• 符号说明符
  注意点: 如果被变量unsigned修饰,那么取值的时候必须使用%u,%u就代表用无符号位的方式

int main()
{
    /*
     * 符号说明符
     * 1. signed : 有符号
     * C语言默认就是这种,二进制首位是符号位,一般用不上
     *
     * 2. unsigned: 无符号
     * 不把二进制的第一位当做符号位,所以只能存储零和正数,不能存储负数
     * 注意: 如果被变量unsigned修饰,那么取值的时候必须使用%u,%u就代表用无符号位的方式
     *
     * 默认情况下所有int类型都是有符号的,可以保存正数,零,负数
     *
     */

    unsigned int num2 = 15;
    unsigned int num3 = 0;
    unsigned int num4 = -12;

    printf("%u\n",num2);
    printf("%u\n",num3);
    printf("%u\n",num4);//不能用%i来取值,如果用%i取出是对的
    return 0;
}

---

数组

• 基本概念

int main()
{
    /*
     * 1. 数组:
     * 如果想要同时保存多个相同类型的数据的时候,就要使用数组
     *
     * 格式: 元素类型 数组名称[元素个数]
     *
     * 2. 元素:
     * 数组中保存的每一个数据就是元素
     * 元素个数: 这个数组保存了多少个数据
     *
     * 3. 索引(下标)
     * 从数组中取出数据: = 数组名称[索引]
     * 往数组中存储数据: 数组名称[索引] =
     */

    int score[4]; //数组定义
    score[0] = 20; //初始化
    score[1] = 60;
    score[2] = 50;
    score[3] = 35;

    printf("score[1] = %i\n", score[1]);//取出数组的元素
    return 0;
}

• 数组的初始化

  • 定义同时初始化

int main()
{
    /*
     * 数组的初始化
     *
     * 1.定义的同时初始化
     * 2.先定义后初始化
     *
     *
     */

    //1. 定义的同时初始化数组(完全初始化)
    int ages1[4] = {15, 15, 18, 23};

    //2. 定义的同时初始化(完全初始化)
    //注意点: 如果定义的同时初始化,并且没有指定数组元素的个数,那么元素的个数就是初始化的个数
    int ages2[] = {13,15,18,23};
    //printf("ages[0] = %i", ages1[0]);

    //3. 定义的同时初始化(部分初始化)
    //注意: 如果只进行了部分初始化,那么没有被初始化的元素就会赋值为0
    int ages3[4] = {15, 23};
    //printf("ages[3] = %i", ages2[3]); //没有被初始化的元素就会赋值为0

    //4. 定义的同时初始化(部分初始化)
    int ages4[] = {[0] = 2, [3] = 5};
    printf("ages[1] = %i", ages4[1]); //0
    return 0;
}

• 先定义后初始化
  重点; 如果数组定义的同时不初始化, 那么元素的个数不能省略

int main()
{
    /*
        数组先定义后初始化
        注意点:
        1. 如果数组定义的同时不初始化, 那么元素的个数不能省略
        2. 如果先定义再初始化,那么不能一次性初始化

    */

//    int score[]; 没有指定数组个数,会报错
//    int score[4];
//    score = {1,4,6,5};  不能一次性初始化,会报错

    // 注意点: 如果只进行了部分初始化,那么没有被初始化的元素不会被赋值为0,随机数
    int score[3];
    score[0] = 10;
    printf("score[1] = %i", score[1]);
    return 0;
}

• 遍历数组
  注意点: 数组长度 = sizeof(数组) /sizeof (一个元素)

int main()
{
    /*
     * 如何遍历数组
     * 遍历数组就是依次取出数组中存储的数据
     *
     * 注意点: 遍历数组的时候循环结束条件不能写死
     */

    // 数组长度 = 数组的总字节数 / 每个元素的字节数 sizeof()
    int ages[5] = {20,15,48,32,45};

    // 求出数组的长度
    int length = sizeof(ages)/sizeof(ages[0]);
    printf("%i\n", length);
    //for循环遍历数组

    for(int i = 0; i < length; i++){
        printf("ages[%i] = %i\n", i, ages[i]);
    }

    return 0;
}

• 数组在内存中存储分析

int main()
{
    /*
     * 数组在内存当中存储的细节
     *
     * 定义数组分配内存的规则:
     * 1. 给整个数组分配内存的时候,和普通变量一样,从内存地址大的开始分配
     * 2. 给数组中每个元素分配内存空间的时候,是从已经分配好的内存地址最小的开始分配
     *
     * 往数组元素中存储数据的规则:
     * 和变量存储数据一样,从内存地址比较大的开始存储
     * 数组元素名指向地址小的位置
     *
     * 
     * 注意点:
     * 如果索引不在数组规定的索引范围内,那么有可能会报错,也可能会取出一个
     * 不是自己的值
     * 
     */

    int num[3] = {1,3,5};
    printf("&num[0] = %p\n", &num); //0028FEB4
    printf("&num[1] = %p\n", &num[0]); //0028FEB4
    printf("&num[2] = %p\n", &num[1]); //0028FEB8
    printf("&num[3] = %p\n", &num[2]); //0028FEBC
    return 0;
}

• 数组的内容补充

      数组定义注意点:
           在定义数组的时候,数组的元素个数只能放常量或者常量表达式
      
      常量: int arr[5];
      常量表达式: int arr[2+3];
      
      错误写法: int arr[num];

---

基本数据类型与函数

注意点: 基本数据类型作为函数的参数,在函数中修改形参的值不会影响到外界实参的值

#include <stdio.h>
void change(int);
int main()
{
    /*
     * 1. 基本数据类型与函数
     * int char short long float double
     *   基本数据类型作为函数的参数,在函数中修改形参的值不会影响到
     * 外界实参的值
     */

    //基本数据与函数
    int num = 5;
    printf("调用前:%i\n",num); //5
    change(num);
    printf("调用后:%i\n",num); //5

    return 0;
}

//基本数据类型的函数
void change(int value){
    value = 666;
}

---

数组与函数

注意点: 如果数组作为函数的参数,那么在函数中修改形参的值,会影响到外面实参的值

#include <stdio.h>

void change(int value[]);
int main()
{
    /*
     * 数组与函数
     *   如果数组作为函数的参数,那么在函数中修改形参的值,会影响到外面实参的值
     *
     *
     */

    int arr[3] = {1, 3, 5};
    // 传入到函数中的是该数组的存储地址, 所以通过value[1]可以找到对应数组arr[1]中的数据
    printf("%i\n", arr[1]); //3
    change(arr);
    printf("%i\n", arr[1]); //666

    // 结论: arr = &arr = arr[0]三个地址相同
    // 就是数组名称保存的是数组占用内存空间最小的那个地址

    printf("%p\n", arr);
    printf("%p\n", &arr);
    printf("%p\n", &arr[0]);

    return 0;
}

//接收参数为数组的函数
void change(int value[]){
    value[1] = 666;
}