C语言数组和结构体的使用

程序就是数据结构加算法

数据结构：就是数据再计算机中的存储方式
算法：对数据进行各种处理

数据的存储：
1、声明变量
2、数组和数组的排序
3、分配内存，使用指针、

课前回顾

货币牌价本版演变
1、Visual 1：一次获取一个指定货币的一个价格

#include <stdio.h>
#include <stdlib.h>
#include <D:/CR37/Data/libs/BOCRates/BOCRates.h>
#pragma comment(lib, "D:/CR37/Data/libs/BOCRates/BOCRates.lib")
int main()
{
    //visual 1：一次获取一个货币的一个价格
    /*
    double ConvertCurrency(bool real, const char* from, const char* to, double 
    amount);
    */
    double result = ConvertCurrency(true, "USD", "CNY", 100);
    printf("%f\r\n", result);
    return 0;
}

程序运行结果：

2、Visual 2：一次获取一个指定货币的多项数据(中文名、发布时间、以及5个价格)

#include <stdio.h>
#include <stdlib.h>
#include <D:/CR37/Data/libs/BOCRates/BOCRates.h>
#pragma comment(lib, "D:/CR37/Data/libs/BOCRates/BOCRates.lib")
int main()
{
    /*
    函数名：GetBOCRatesByCode
    用途：根据货币的代码获取这个货币最新的价格（5个）
    int GetBOCRatesByCode(const char* code, char* name, char* updateTime, double* 
    data);
    const char* code 要获取价格的货币代码(使用const是不希望传递进去的字符串被                GetBOCRatesByCode()这个函数无意的修改)
    char* name;           存储货币的中文名的内存地址
    char* updateTime;            存储发布时间的内存地址
    double* date；               存储5个价格的存储空间的首地址 
    返回值：获取成功返回1，获取失败返回0
    */
    //申请空间，存储对应的数据

    char* name = (char*)malloc(32);
    char* updateTime = (char*)malloc(20);
    double* rates = (double*)malloc(sizeof(double) * 5);
    /*
    //等价于上面的指针
    char name[32];
    char updateTime[20];
    double rates[5];
    */
    /*
    上面的两种做法都是在内存中分配一块内存空间，然后再使用它
    不同之处:
    malloc()函数是在堆上分配内存
    数组是在栈上分配内存
    声明方式不同，但是使用方式基本一致
    */
    
    //调用BOCRates头文件里的GetBOCRatesByCode()函数
    //添加判断条件 检查内存空间的申请情况
    if (name != NULL && updateTime != NULL && rates != NULL)
    {
        int result = GetBOCRatesByCode("USD", name, updateTime, rates);
    /*
    直接打印，VS会告诉我们 name、updataTome、rates都有可能分配内存失败 有可能为空值
    printf("%s\t%s\t%f\t%f\t%f\t%f\t%f\r\n", name, updataTime, *(rates), 
    *(rates + 1), *(rates + 2), *(rates + 3), *(rates + 4));
    */
        if (result == 1)
        {
            printf("%s\t%s\t%f\t%f\t%f\t%f\t%f\r\n", name, updateTime, *(rates), *(rates + 1), *(rates + 2), *(rates + 3), *(rates + 4));
        }
        else
        {
            printf("网络连接失败！");
        }
        free(name);//释放申请的内存空间
        free(updateTime);
        free(rates);
    }
    else
    {
        printf("内存不足或者超出系统限制！\r\n");
    }
    return 0;
}

程序运行结果：

数组和指针
数组和指针都是在内存中分配一块内存空间，然后使用它。所不同的是malloc()函数是在堆上分配内存，而数组是在栈上分配内存，数组名会自动被转换成数组空间的首地址。两者除了声明方式不同，使用方式基本一致：
指针：堆 屯
数组：栈 烫

    //指针表示
    char* name = (char*)malloc(32);
    char* updateTime = (char*)malloc(20);
    double* rates = (double*)malloc(sizeof(double) * 5);
    //数组表示 等价于上面的指针
    char name[32];
    char updateTime[20];
    double rates[5];

数组

数组就是为我们提供了一种在内存上方便的访问数据的方式，数组的数组的名称相当于数组第一个元素的首地址。字符数组是存储在栈上的，如果声明数组时没有初始化，数组内填的值和声明指针未初始化的值不一样的，指针的时屯，数组的是烫：

#include <stdio.h>
int main()
{
    char str[256];
    str[0] = 'H';         //*str = 'H';
    str[1] = 'e';
    printf("%s", str);
    //打印字符数组str，由于初始化了字符数组的第一、第二元素的值，所以其值会正常打印，未初始化的元素会打印烫烫烫烫烫烫烫烫烫···，知道遇到 '\0'才会结束打印。
    return 0;
}

程序运行结果如下：

数组的内存空间无需手动释放，因为栈的空间比较小(1MB/2MB)多以数组不能定义的很大

#include <stdio.h>
int main()
{
    char str[1024 *1024 *1024];
    str[0] = 'H';         //*str = 'H';
    str[1] = 'e';
    printf("%s", str);
    return 0;
}

程序运行结果如下：

数组是一种存储多个相同类型数据的数据结构，相对于之前的直接分配内存，数组这种存储方式使用的更加简单，不容易出错，数组的大小必须在声明的到时候就确实，不可以通过变量来确定数组的大小

将数组中最大元素的值保存到第一个数组元素中

分析：

代码实现：
Visual 1：初级版

#include <stdio.h>
int main()
{
    //数组的名称相当于数组第一个元素的地址
    int arr[5];
    arr[0] = 10;//*str = 10;
    arr[1] = 2;
    arr[2] = -3;
    arr[3] = 13;
    arr[4] = 23;
    //交换数值
    if (arr[0] < arr[1]) 
    {
        int Temp = arr[0];
        arr[0] = arr[1];
        arr[1] = Temp;
    }
    if (arr[0] < arr[2])
    {
        int Temp = arr[0];
        arr[0] = arr[2];
        arr[2] = Temp;
    }
    if (arr[0] < arr[3]) 
    {
        int Temp = arr[0];
        arr[0] = arr[3];
        arr[3] = Temp;
    }
    if (arr[0] < arr[4]) 
    {
        int Temp = arr[0];
        arr[0] = arr[4];
        arr[4] = Temp;
    }
    printf("%d %d %d %d %d\r\n", arr[0], arr[1], arr[2], arr[3], arr[4]);
    return 0;
}

程序运行结果：

Visual 2：指针版

#include <stdio.h>
void swap(int* a, int* b) 
{
    int Temp = *a;
    *a = *b;
    *b = Temp;
}
int main() 
{
    //数组的名称相当于数组第一个元素的地址
    int arr[5];
    arr[0] = 10;//*str = 10;
    arr[1] = 2;
    arr[2] = -3;
    arr[3] = 13;
    arr[4] = 23;
    //交换数值
    if (arr[0] < arr[1]) swap(&arr[0], &arr[1]);
    if (arr[0] < arr[2]) swap(&arr[0], &arr[2]);
    if (arr[0] < arr[3]) swap(&arr[0], &arr[3]);
    if (arr[0] < arr[4]) swap(&arr[0], &arr[4]);
    printf("arr[0] = %d\r\n", arr[0]);
    return 0;
}

程序运行结果：

使用for()循依次比较数组元素的值，最后将最大值存储到arr[0]里，并输出

#include <stdio.h>
void swap(int* a, int* b) {
    int Temp = *a;
    *a = *b;
    *b = Temp;
}
int main() {
    //数组的名称相当于数组第一个元素的地址
    int arr[5] = {10, 2, -3, 13, 23};
    /*
    arr[0] = 10;//*str = 10;
    arr[1] = 2;
    arr[2] = -3;
    arr[3] = 13;
    arr[4] = 23;
    */
    //使用for()循环依次遍历交换数值
    for (int i = 1; i <=4; i++) {
        if (arr[0] < arr[i]) swap(&arr[0], &arr[i]);
    }
    printf("arr[0] = %d\r\n", arr[0]);
    return 0;
}

程序运行结果为：

将数组内的所有元素按从大到小的顺序输出

Visual 1：入门版

#include <stdio.h>
void swap(int* a, int* b) {
    int Temp = *a;
    *a = *b;
    *b = Temp;
}
int main() {
    //数组的名称相当于数组第一个元素的地址
    int arr[5];
    arr[0] = 10;
    //*str = 10;
    arr[1] = 23;
    arr[2] = -3;
    arr[3] = 13;
    arr[4] = 2;
    //交换数值
    //1、将数组内最大的数值存储到arr[0]里面
    for (int i = 1; i <=4; i++) {
        if (arr[0] < arr[i]) swap(&arr[0], &arr[i]);
    }
    //2、将数组内第2大的数值存储到arr[1]里面
    for (int i = 2; i <= 4; i++) {
        if (arr[1] < arr[i]) swap(&arr[1], &arr[i]);
    }
    //3、将数组内第3大的数值存储到arr[2]里面
    for (int i = 3; i <= 4; i++) {
        if (arr[2] < arr[i]) swap(&arr[2], &arr[i]);
    }
    //4、将数组内第4大的数值存储到arr[3]里面
    for (int i = 4; i <= 4; i++) {
        if (arr[3] < arr[4]) swap(&arr[3], &arr[4]);
    }
    printf("%d %d %d %d %d\r\n", arr[0], arr[1], arr[2], arr[3], arr[4]);
    return 0;
}

程序循行结果：

VIsual 2：进阶版

#include <stdio.h>
void swap(int* a, int* b)
{
    int Temp = *a;
    *a = *b;
    *b = Temp;
}
int main()
{
    //数组的名称相当于数组第一个元素的地址
    int arr[5];
    arr[0] = 10;          //*str = 10;
    arr[1] = 23;
    arr[2] = -3;
    arr[3] = 13;
    arr[4] = 2;
    for (int i = 0; i <= 3; i++)
    {
        for (int j = i + 1; j <= 4; j ++)
        {
            if (arr[i] < arr[j]) swap(&arr[i], &arr[j]);
        }
    }
    printf("%d %d %d %d %d\r\n", arr[0], arr[1], arr[2], arr[3], arr[4]);
    return 0;
}

程序运行结果：

Visual 3：迭代版
如果数组内的元素不确定，且考虑到程序的移植性，所以还需要在上面的代码中进行如下改动

#include <stdio.h>
void swap(int* a, int* b)
{
    int Temp = *a;
    *a = *b;
    *b = Temp;
}
int main()
{
    //数组的名称相当于数组第一个元素的地址
    int arr[8] = { 10, 78, 23, -34, 25, 77, -233, 20 };
    int count = sizeof(arr) / sizeof(int);  //添加这句代码
    for (int i = 0; i <= count -2; i++)
    {
        for (int j = i + 1; j <= count-1; j ++)
        {
            if (arr[i] < arr[j]) swap(&arr[i], &arr[j]);
        }
    }
    printf("%d %d %d %d %d\r\n", arr[0], arr[1], arr[2], arr[3], arr[4]);
    return 0;
}

程序运行结果如下：

结构体

使用数组、指针只能存储同种类型的数据。如何将不同类型的数据化零为整？只能通过自定义数据类型（结构体）。
使用结构体可以存储不同类型的多项数据。
结构体就是一个由多个变量多个数组组成的大的数据类型
数组是将相同类型的多项数据集合在一起的方式，而结构体是将多种不同类型的数据项集合到一起的方法。
在此之前我们使用的整型，浮点型都是C语言的内置数据类型，一个变量只能存储一项数据。但是在很多时候我们还需要把多项不同类型的数据合并成一个整体来进行操作。
例如：
存储一个人的个人信息，需要定义下面的变量：

char name[32];  //该字符数组用于存储个人姓名
char id[32];    //该字符数组用于存储个人的身份证
int gender = 1; //该整型变量可以用来存储该人的性别
int age;    //该整型变量用来存储年龄

上面的四个变量和数组在程序上可以说是独立的，如果需要像一个函数传递某个人的个人信息，这个函数就需要对应的四个参数，这就会让写的程序变得很冗长，有时候增加一个需求，比如增添个人的手机号，户籍地等，就需要在函数内添加参数，而同时还需要再程序中需改多处，就会显得特别麻烦。
而结构体变量就可以将多个有关联的变量、数组合并成一个变量，这个变量可以分成多个部分，用于存储不同信息。
结构体的定义形式为：

struct 结构体名
{    
    结构体所包含的变量或数组
};
//例如：外汇币种的对应信息
struct EXCHANGE_RATE
{
    char CurrencyCode[4];
    char CurrencyName[32];
    char PublishTime[20];
    double BuyingRate = 0;
    double CashBuyingRate = 0;
    double SellingRate;
    double CashSellingRate;
    double MiddleRate;
};
/*
typedef struct EXCHANGE_RATE ExchangeRate
使用typedef 可以给结构体变量起一个别名 基于这个结构体为结构体定义一个类型名
*/
//调用
int main()
{
    struct EXCHANGE_RATE r; // r为EXCHANGE_RATE结构体的变量名
    ReadBOCRatesByCode("HKD", &r);
    printf("%s\t", r.CurrencyCode);
    printf("%s\t", r.CurrencyName);
    printf("%s\t", r.PublishTime);
    printf("%f\t", r.BuyingRate);
    printf("%f\t", r.SellingRate);
    printf("%f\t", r.CashBuyingRate);
    printf("%f\t", r.CashSellingRate);
    printf("%f\t\n", r.MiddleRate);
    return 0;
}

程序运行结果：