AI 助理
文档备案控制台
开发者社区 开发与运维 文章 正文

C语言-结构、联合、枚举

2023-03-06 235
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： C语言-结构、联合、枚举

结构

使用struct关键词，可以创造新的类型。
关键词struct取自structure，中文翻译为结构。
这种由多个不同的数据类型组成的类型，被称为结构。

struct {
    char name[20];
    int gender;
    double height;
    double weight;
}

上面这一串结构类型虽然很长，但是，就相当于 int 类型一样。
如同在 int 后填变量名可以声明一个整型变量。
在结构类型后面填写变量名可以声明一个结构变量。

结构别名

现在，我们想定义多个人员信息结构变量。

struct {
    char name[20];
    int gender;
    double height;
    double weight;
}timmy;
struct {
    char name[20];
    int gender;
    double height;
    double weight;
}david;
struct {
    char name[20];
    int gender;
    double height;
    double weight;
}jane;
在第一次声明结构变量时，在 struct与 {之间可以填写一个结构别名。若以后再次需要使用这种结构，仅需要使用 struct加 别名即可声明这种结构的变量。 
struct person {
    char name[20];
    int gender;
    double height;
    double weight;
}timmy;
struct person david;
struct person jane;
可以将结构类型声明提取到最开头。让所有的结构变量均由别名来声明。相当于我们先造了一个模板，然后，用这个模板生成各个变量。 
struct person {
    char name[20];
    int gender;
    double height;
    double weight;
};
struct person timmy;
struct person david;
struct person jane;
如果结构类型声明在一个函数中，那么别名只能在函数内部使用。 
void func1()
{
    struct person {
        char name[20];
        int gender;
        double height;
        double weight;
    };
    struct person timmy;
}
void func2()
{
    // 别名person无法在func2中使用
    struct person david;
}
如果需要在多个函数中使用结构别名，那么可以把它放到函数外面。 
// 结构声明放到函数外
struct person {
    char name[20];
    int gender;
    double height;
    double weight;
};
void func1()
{
    struct person timmy;
}
void func2()
{
    struct person david;
}

初始化结构

类似于数组可以在声明时被初始化。
int arr[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
结构也能在声明时初始化。

struct person {
    char name[20];
    int gender;
    double height;
    double weight;
};
struct person timmy = { "timmy", 1, 170.00, 60.00 };
printf("%s\n", timmy.name);
printf("%d\n", timmy.gender);
printf("%.2f\n", timmy.height);
printf("%.2f\n", timmy.weight);

结构变量初始化的形式和数组初始化的形式类似。
在声明时，其后跟等号与初始化列表。
结构的初始化列表的写法需要注意如下4点：

  1. 初始化列表由花括号包括。
  2. 花括号内为结构成员需要被初始化的值。
  3. 初始化值按照结构成员声明时的顺序依次排列
  4. 每个初始化值之间由逗号分隔。

结构数组

struct person {
    char name[20];
    int gender;
    double height;
    double weight;
};
struct person people[3] = {
{"timmy", 1, 170.00, 60.00},
{"david", 1, 175.00, 65.00},
{"jane", 2, 165.00, 55.00}
};
for (int i = 0; i < 3; i++)
{
    struct person per = people[i];
    printf("%s ", per.name);
    printf("%d ", per.gender);
    printf("%.2f ", per.height);
    printf("%.2f\n", per.weight);
}

结构数组与基本变量数组类似，使用方括号内填数组元素个数进行声明。
struct person people[3];
初始化列表也可用于初始化结构数组，初始化列表中依次填每个结构的初始化列表，每个结构的初始化列表之间由逗号分隔。

{
{"timmy", 1, 170.00, 60.00},
{"david", 1, 175.00, 65.00},
{"jane", 2, 165.00, 55.00}
};

使用方括号内填下标可以访问结构数组中的元素。同样地，下标也是从0开始的。
people[i]
不同于数组，可以对结构使用赋值，或使用一个结构初始化一个结构。

struct person per = people[i];
//
struct person per;
per = people[i];

嵌套结构

一个结构可以作为另一个结构的成员。
例如，我们声明一个结构，用于存储通讯方式。通讯方式由电话号码，邮箱组成。
现在，我们需要记录每个人员的通讯方式。可以把这个结构作为人员结构的成员

#include<stdio.h>
int main()
{
    struct contact {
        char phone[20];
        char email[20];
    };
    struct person {
        char name[20];
        int gender;
        double height;
        double weight;
        struct contact c;
    };
    struct person timmy = {
    "timmy", 1, 170.00, 60.00, {"130123456678", "timmy@xxx.com"}
    };
    printf("%s ", timmy.name);
    printf("%d ", timmy.gender);
    printf("%.2f ", timmy.height);
    printf("%.2f\n", timmy.weight);
    printf("%s\n", timmy.c.phone);
    printf("%s\n", timmy.c.email);
    return 0;
}

使用.加字段名可以访问到通讯方式结构。再次使用.加字段名即可访问其内部的成员

输出结果 
timmy 1 170.00 60.00
130123456678
timmy@xxx.com

指向结构的指针

指针可以指向基本数据类型或者是数组。当然，指针也可以指向结构。

struct person {
    char name[20];
    int gender;
    double height;
    double weight;
};
struct person timmy = { "timmy", 1, 170.00, 60.00 };
struct person* pTimmy = &timmy;

和往常一样，加上星号* 用于声明一个指针。使用取地址运算符& ，可以获取指针。
那么怎样使用指向结构的指针呢？
由于取地址& 与取值* 它们具有可逆关系，我们可以把指针先转为结构再使用。

printf("%s\n", (*pTimmy).name);
printf("%d\n", (*pTimmy).gender);
printf("%.2f\n", (*pTimmy).height);
printf("%.2f\n", (*pTimmy).weight);

由于成员运算符**.**的优先级高于取值运算符*****。为了让取值*先运算符，必须使用括号包括* pTimmy 。
另外，C语言中提供了更加方便的写法，成员间接运算符**->**
(*pTimmy).name等价于pTimmy->name

printf("%s\n", pTimmy->name);
printf("%d\n", pTimmy->gender);
printf("%.2f\n", pTimmy->height);
printf("%.2f\n", pTimmy->weight);

结构在函数中传递

现在，我们将结构当作参数传入函数。在函数内部修改传入的参数。

#include<stdio.h>
#include<string.h>
struct person {
    char name[20];
    int gender;
    double height;
    double weight;
};
void change(struct person per)
{
    strcpy(per.name, "david");
    per.gender = 1;
    per.height = 175.00;
    per.weight = 65.00;
}
int main()
{
    struct person timmy = { "timmy", 1, 170.00, 60.00 };
    change(timmy);
    printf("%s\n", timmy.name);
    printf("%d\n", timmy.gender);
    printf("%.2f\n", timmy.height);
    printf("%.2f\n", timmy.weight);
    return 0;
}

由于实参timmy与实参per是相互独立的。修改函数change内的 per 无法改动实参timmy

timmy
1
170.00
60.00

利用指针修改结构

在函数change内部可以通过指针，找到结构变量timmy。并且，对其进行修改。

#include<stdio.h>
#include<string.h>
struct person {
    char name[20];
    int gender;
    double height;
    double weight;
};
void change(struct person* per)
{
    strcpy(per->name, "david");
    per->gender = 1;
    per->height = 175.00;
    per->weight = 65.00;
}
int main()
{
    struct person timmy = { "timmy", 1, 170.00, 60.00 };
    change(&timmy);
    printf("%s\n", timmy.name);
    printf("%d\n", timmy.gender);
    printf("%.2f\n", timmy.height);
    printf("%.2f\n", timmy.weight);
    return 0;
}
输出结果 
david
1
175.00
65.00

将一个结构从函数返回

从函数返回了david的数据，并且在将其赋值给了timmy。

#include<stdio.h>
#include<string.h>
struct person {
    char name[20];
    int gender;
    double height;
    double weight;
};
struct person change()
{
    struct person per;
    strcpy(per.name, "david");
    per.gender = 1;
    per.height = 175.00;
    per.weight = 65.00;
    return per;
}
int main()
{
    struct person timmy = { "timmy", 1, 170.00, 60.00 };
    timmy = change();
    printf("%s\n", timmy.name);
    printf("%d\n", timmy.gender);
    printf("%.2f\n", timmy.height);
    printf("%.2f\n", timmy.weight);
    return 0;
}

联合

联合与结构

联合的语法非常类似于结构的语法，几乎仅仅换了一个关键词而已。
想组合char、short、long long，可以像如下代码写法:

struct {
    char c;
    short s;
    long long ll;
}s;

联合char、short、long long，可以像如下代码写法:

union {
    char c;
    short s;
    long long ll;
}u;

联合，关键词为**union**

测量一下联合与结构的大小 
#include<stdio.h>
int main()
{
    struct {
        char c;
        short s;
        long long ll;
    }s;
    union {
        char c;
        short s;
        long long ll;
    }u;
    printf("sizeof s %d\n", sizeof(s));
    printf("sizeof u %d\n", sizeof(u));
}
结构 s 测得大小为16，而联合 u 测得大小为8 
sizeof s 16
sizeof u 8

对于结构来说，char占用1字节，short占用2个字节。long long占用8字节。如果它们相邻紧密排列，按理说会占用11个字节。

#include<stdio.h>
int main()
{
    struct {
        char c;
        short s;
        long long ll;
    }s;
    union {
        char c;
        short s;
        long long ll;
    }u;
    printf("&s.c %d \n", &s.c);
    printf("&s.s %d \n", &s.s);
    printf("&s.ll %d \n\n", &s.ll);
    printf("&u.c %d \n", &u.c);
    printf("&u.s %d \n", &u.s);
    printf("&u.ll %d \n", &u.ll);
}
输出地址 
&s.c 3537784
&s.s 3537786
&s.ll 3537792

&u.c 3537768
&u.s 3537768
&u.ll 3537768

根据地址，画出结构s各个成员的内存排布情况。char与short只留空了一个字节，而short与long long之间留空了4个字节。

这种现象被称为内存对齐，虽然会浪费一些内存空间，对齐后的数据能够被更快的访问。

画出联合

联合中的成员首地址是重叠的，这意味着联合的大小为联合中最大成员的大小。

联合的性质

既然各成员之间有重叠的部分，那么存储一个成员后，将覆盖掉其他成员的数据。

#include<stdio.h>
int main()
{
    struct {
        char c;
        short s;
        long long ll;
    }s;
    union {
        char c;
        short s;
        long long ll;
    }u;
    u.c = 123;
    printf("u.c = %d\n", u.c);
    u.s = 0;
    printf("u.c = %d\n", u.c);
}
输出结果 
u.c = 123
u.c = 0


由于共用了一段内存，存储一个成员后，将覆盖其他成员的数据。所以，联合也被翻译为共用。

联合应用举例

有一种信息，它只有3种形态：

  1. 整数
  2. 浮点数
  3. 字符串

并且，一次只能出现一种形态。
如果用结构struct来存储这种信息。而这个信息可能是整型，可能是浮点数，也可能是字符串。那么，需要准备三个不同类型的成员。由于一次只会出现一种形态，所以，每次仅用一个成员，另外两个
留空。
另外，需要一个整型的type成员来标记这一次是什么类型。例如：1代表整型，2代表浮点，3代表字符串。

#include <stdio.h>
struct message
{
    int type;
    int n;
    float f;
    char* str;
};
void printMsg(struct message msg)
{
    switch (msg.type)
    {
    case 1:
        printf("%d\n", msg.n);
        break;
    case 2:
        printf("%f\n", msg.f);
        break;
    case 3:
        printf("%s\n", msg.str);
        break;
    }
}
int main()
{
    struct message msg[3];
    // 第一个信息为整型，type为1
    msg[0].type = 1;
    msg[0].n = 123;
    // 第二个信息为浮点型，type为2
    msg[1].type = 2;
    msg[1].f = 3.1415926;
    // 第三个信息为字符串，type为3
    msg[2].type = 3;
    msg[2].str = "HelloWorld";
    for (int i = 0; i < 3; i++)
    {
        printMsg(msg[i]);
    }
    return 0;
}
输出结果 
123
3.141593
HelloWorld

很显然，每一个信息中，都有两个成员变量是空置的。但是，如果使用联合 union 就能将这三个不同类型的成员所占空间合而为一。

type成员是一定需要有的，否则无法判断是什么类型的信息。所以，它不能合并进入union。
拿到消息后，同样也需要根据消息的type用不同的方式处理。确定type后，再从msg中找到union成员u，再根据类型，选择对应的成员进行处理。

#include <stdio.h>
struct message
{
    int type;
    union {
        int n;
        float f;
        char* str;
    }u;
};
void printMsg(struct message msg)
{
    switch (msg.type)
    {
    case 1:
        printf("%d\n", msg.u.n);
        break;
    case 2:
        printf("%f\n", msg.u.f);
        break;
    case 3:
        printf("%s\n", msg.u.str);
        break;
    }
}
int main()
{
    struct message msg[3];
    // 第一个信息为整型，type为1
    msg[0].type = 1;
    msg[0].u.n = 123;
    // 第二个信息为浮点型，type为2
    msg[1].type = 2;
    msg[1].u.f = 3.14159;
    // 第三个信息为字符串，type为3
    msg[2].type = 3;
    msg[2].u.str = "HelloWorld";
    for (int i = 0; i < 3; i++)
    {
        printMsg(msg[i]);
    }
    return 0;
}
输出结果 
123
3.141590
HelloWorld

还有一种匿名嵌套的写法。嵌套的union中没必要写明成员名u。在其后的使用中，union中的成员当做message的成员一样处理。

#include <stdio.h>
struct message
{
    int type;
    union {
        int n;
        float f;
        char* str;
    }; // 这里省去成员名u，作为匿名嵌套成员。
};
void printMsg(struct message msg)
{
    switch (msg.type)
    {
    case 1:
        printf("%d\n", msg.n); // msg.u.n省略为msg.n
        break;
    case 2:
        printf("%f\n", msg.f); // msg.u.f省略为msg.f
        break;
    case 3:
        printf("%s\n", msg.str); // msg.u.str省略为msg.str
        break;
    }
}
int main()
{
    struct message msg[3];
    // 第一个信息为整型，type为1
    msg[0].type = 1;
    msg[0].n = 123;
    // 第二个信息为浮点型，type为2
    msg[1].type = 2;
    msg[1].f = 3.14159;
    // 第三个信息为字符串，type为3
    msg[2].type = 3;
    msg[2].str = "HelloWorld";
    for (int i = 0; i < 3; i++)
    {
        printMsg(msg[i]);
    }
    return 0;
}
输出结果 
123
3.141590
HelloWorld

枚举

枚举只是为整形取了一个别名，让代码中不要出现数值。
在之前的例子中，我们使用数字来代表消息的类别。1代表整型，2代表浮点，3代表字符串。
使用数字虽然功能上完全可以达到需要的效果。但是，如果类型越来越多的情况下，人很难记住哪一个数字对应哪一种类型。
所以，C语言中提供了一种特殊的整型，枚举类型。其关键词为enum。
我们把数字1，2，3用有意义的英文替代，这些英文都是可以随意命名的，只要你能看到并认识它对应着什么类型就行。
例如：

  • 1对应eInteger
  • 2对应eFloat
  • 3对应eString

接着，把它们像结构struct类似的形式，声明在一个花括号里面。不过，关键词改为枚举enum。

#include <stdio.h>
enum msgType {
    eInteger,
    eFloat,
    eString
};
int main()
{
    printf("%d\n", eInteger);
    printf("%d\n", eFloat);
    printf("%d\n", eString);
    return 0;
}
输出结果 
0
1
2

eInteger 的值为0， eFloat 的值为1， eString 的值为2

让枚举从1开始

#include <stdio.h>
enum msgType {
    eInteger = 1, // 让枚举符从1开始
    eFloat,
    eString
};
int main()
{
    printf("%d\n", eInteger);
    printf("%d\n", eFloat);
    printf("%d\n", eString);
    return 0;
}

输出结果

1
2
3

指定每一个枚举中每一个成员对应的数值。

#include <stdio.h>
enum msgType {
    eInteger = 1,
    eFloat = 3,
    eString = 5
};
int main()
{
    printf("%d\n", eInteger);
    printf("%d\n", eFloat);
    printf("%d\n", eString);
    return 0;
}
输出结果 
1
3
5

枚举应用

#include <stdio.h>
enum msgType {
    eInteger,
    eFloat,
    eString
};
struct message
{
    enum msgType type;
    union {
        int n;
        float f;
        char* str;
    };
};
void printMsg(struct message msg)
{
    switch (msg.type)
    {
    case eInteger:  //等价于case 0
        printf("%d\n", msg.n);
        break;
    case eFloat:    //等价于case 1
        printf("%f\n", msg.f);
        break;
    case eString:   //等价于case 2
        printf("%s\n", msg.str);
        break;
    }
}
int main()
{
    struct message msg[3];
    // 第一个信息为整型，type为eInteger
    msg[0].type = eInteger;
    msg[0].n = 123;
    // 第二个信息为浮点型，type为eFloat
    msg[1].type = eFloat;
    msg[1].f = 3.14159;
    // 第三个信息为字符串，type为eString
    msg[2].type = eString;
    msg[2].str = "HelloWorld";
    for (int i = 0; i < 3; i++)
    {
        printMsg(msg[i]);
    }
    return 0;
}
  1. 使用枚举替代数字
  2. 拿到信息后，判断是哪一个枚举值
  3. 使用枚举值进行赋值
输出结果 
123
3.141590
HelloWorld
文章标签：
C语言
存储
关键词：
C语言结构
C语言枚举
C语言结构枚举
WuShF
目录
相关文章
RossyYan
|
C语言
【C语言程序设计——循环程序设计】枚举法换硬币（头歌实践教学平台习题）【合集】
本文档介绍了编程任务的详细内容，旨在运用枚举法求解硬币等额 - 循环控制语句（`for`、`while`）及跳转语句（`break`、`continue`）的使用。 - 循环嵌套语句的基本概念和应用，如双重`for`循环、`while`嵌套等。 3. **编程要求**：根据提示在指定区域内补充代码。 4. **测试说明**：平台将对编写的代码进行测试，并给出预期输出结果。 5. **通关代码**：提供完整的代码示例，帮助理解并完成任务。 6. **测试结果**：展示代码运行后的实际输出，验证正确性。 文档结构清晰，逐步引导读者掌握循环结构与嵌套的应用，最终实现硬币兑换的程序设计。
RossyYan
236 19
RossyYan
|
存储 安全 C语言
【C语言程序设计——选择结构程序设计】预测你的身高（头歌实践教学平台习题）【合集】
分支的语句，这可能不是预期的行为，这种现象被称为“case穿透”，在某些特定情况下可以利用这一特性来简化代码，但在大多数情况下，需要谨慎使用。编写一个程序，该程序需输入个人数据，进而预测其成年后的身高。根据提示，在右侧编辑器补充代码，计算并输出最终预测的身高。分支下的语句，提示用户输入无效。常量的值必须是唯一的，且在同一个。语句的作用至关重要，如果遗漏。开始你的任务吧，祝你成功！，程序将会继续执行下一个。常量都不匹配，就会执行。来确保程序的正确性。
RossyYan
514 10
RossyYan
|
小程序 C语言
【C语言程序设计——基础】顺序结构程序设计（头歌实践教学平台习题）【合集】
目录 任务描述 相关知识 编程要求 测试说明 我的通关代码: 测试结果： 任务描述 相关知识 编程编写一个程序，从键盘输入3个变量的值，例如a=5，b=6，c=7，然后将3个变量的值进行交换，使得a=6，b=7，c=5。面积=sqrt(s(s−a)(s−b)(s−c))，s=(a+b+c)/2。使用输入函数获取半径，格式指示符与数据类型一致，实验一下，不一致会如何。根据提示，在右侧编辑器补充代码，计算并输出圆的周长和面积。
RossyYan
398 10
RossyYan
|
存储 编译器 C语言
【C语言程序设计——选择结构程序设计】求一元二次方程的根（头歌实践教学平台习题）【合集】
本任务要求根据求根公式计算并输出一元二次方程的两个实根，精确到小数点后两位。若方程无实根，则输出提示信息。主要内容包括： - **任务描述**：使用求根公式计算一元二次方程的实根。 - **相关知识**：掌握 `sqrt()` 函数的基本使用方法，判断方程是否有实根。 - **编程要求**：根据输入的系数，计算并输出方程的根或提示无实根。 - **测试说明**：提供两组测试数据及预期输出，确保代码正确性。 - **通关代码**：包含完整的 C 语言代码示例，实现上述功能。 通过本任务，你将学会如何处理一元二次方程的求解问题，并熟悉 `sqrt()` 函数的使用。
RossyYan
325 5
RossyYan
|
C语言
【C语言程序设计——枚举】得到 3 种不同颜色的球的可能取法（头歌实践教学平台习题）【合集】
本关任务要求从红、黄、蓝、白、黑五种颜色的球中，每次取出3个不同颜色的球，列举所有可能的排列情况。通过定义枚举类型和使用嵌套循环语句实现。枚举类型用于表示球的颜色，循环语句用于生成并输出所有符合条件的排列 编程要求：在指定区域内补充代码，确保输出格式正确且完整。测试说明：平台将验证代码输出是否与预期一致，包括每种排列的具体顺序和总数。 示例输出： ``` Output: 1 red yellow blue 2 red yellow white ... 60 black white blue total: 60 ```
RossyYan
336 4
RossyYan
|
存储 算法 安全
【C语言程序设计——选择结构程序设计】按从小到大排序三个数（头歌实践教学平台习题）【合集】
本任务要求从键盘输入三个数，并按从小到大的顺序排序后输出。主要内容包括： - **任务描述**：实现三个数的排序并输出。 - **编程要求**：根据提示在编辑器中补充代码。 - **相关知识**： - 选择结构（if、if-else、switch） - 主要语句类型（条件语句） - 比较操作与交换操作 - **测试说明**：提供两组测试数据及预期输出。 - **通关代码**：完整代码示例。 - **测试结果**：展示测试通过的结果。 通过本任务，你将掌握基本的选择结构和排序算法的应用。祝你成功！
RossyYan
285 4
ephemerals__
|
存储 搜索推荐 算法
【数据结构】树型结构详解 + 堆的实现（c语言）（附源码）
本文介绍了树和二叉树的基本概念及结构，重点讲解了堆这一重要的数据结构。堆是一种特殊的完全二叉树，常用于实现优先队列和高效的排序算法（如堆排序）。文章详细描述了堆的性质、存储方式及其实现方法，包括插入、删除和取堆顶数据等操作的具体实现。通过这些内容，读者可以全面了解堆的原理和应用。
ephemerals__
780 16
RossyYan
|
存储 算法 安全
【C语言程序设计——选择结构程序设计】求阶跃函数的值（头歌实践教学平台习题）【合集】
本任务要求输入x的值，计算并输出特定阶跃函数的结果。主要内容包括： 1. **选择结构基本概念**：介绍if、if-else、switch语句。 2. **主要语句类型**：详细解释if、if-else、switch语句的使用方法。 3. **跃迁函数中变量的取值范围**：说明如何根据条件判断变量范围。 4. **计算阶跃函数的值**：通过示例展示如何根据给定条件计算函数值。 编程要求：在右侧编辑器Begin-End之间补充代码，实现阶跃函数的计算和输出。测试说明提供了多个输入及其预期输出，确保代码正确性。最后提供通关代码和测试结果，帮助理解整个过程。
RossyYan
337 0
RossyYan
|
存储 算法 安全
【C语言程序设计——选择结构程序设计】判断一个数是不是5和7的倍数（头歌实践教学平台习题）【合集】
本任务要求输入一个正整数，判断其是否同时是5和7的倍数，若是输出&quot;Yes&quot;，否则输出&quot;No&quot;。内容涵盖选择结构的基本概念、主要语句类型（if、if-else、switch）及条件判断逻辑，帮助理解编程中的分支执行与条件表达式。测试用例包括正数、负数及非倍数情况，确保代码逻辑严谨。通关代码示例如下： ```cpp #include &quot;stdio.h&quot; int main(){ int a; scanf(&quot;%d&quot;, &a); if (a &lt;= 0){ printf(&quo
RossyYan
667 0
RossyYan
|
编译器 C语言 C++
【C语言程序设计——选择结构程序设计】求输入的日期是该年的第几天（头歌实践教学平台习题）【合集】
本任务要求编写程序，根据用户输入的年月日（以空格或回车分隔），计算并输出该天是该年的第几天，需注意判断闰年。主要内容包括： 1. **任务描述**：实现从键盘输入年月日，计算该天是当年的第几天。 2. **相关知识**： - `switch` 结构的基本语法及使用注意事项。 - 判断闰年的条件：能被4整除但不能被100整除，或能被400整除的年份为闰年。 3. **编程要求**：根据提示补充代码，确保程序正确处理输入并输出结果。 4. **测试说 示例代码展示了如何使用 `switch` 语句和闰年判断逻辑来完成任务。通过此练习，掌握 `switch` 语句的应用及闰年判断方法。
RossyYan
600 0