结构、枚举和类型

您可能已经问过如何创建具有不同数据类型的数组。像一个元组。这是不可能的，但我们可以创建数据结构！

结构

struct <identifier> {
    <type> <identifier>; // attribute 1
    <type> <identifier>; // attribute 2
    ...
};

这是一个创建结构对象的示例：

#include <assert.h>

struct s_user {
    char* name;
    int age;
};

int main(void) {
    struct s_user user1 = { "John", 34 };
    assert(user1.age == 34);

    return 0;
}

如您所见，我们可以使用以下语法访问对象的元素：

<object identifier>.<attribute identifier>

类型定义

typedef struct <struct identifier> <type identifier>;

我们通常为我们创建的结构定义一个类型。

typedef struct s_user {
    char* name;
    int age;
} User;

struct s_user {
    char* name;
    int age;
};
typedef struct s_user User;

也可以在使用第一种方法时创建一个匿名结构：

typedef struct {
    char* name;
    int age;
} User;

枚举

想象一下，我们想要存储用户的工作，我们可以将它存储到一个字符串中。但是存在更好的方法：枚举

typedef enum e_job {
    Builder,
    Dentist,
    Engineer,
    Fireman,
    Lawyer,
    Teacher,
    Waiter
} Job;

我们可以为我们的结构添加一个Job属性：User

typedef struct s_user {
    char* name;
    int age;
    Job job;
} User;

在某些语言中，可以通过Enum::Element语法检索枚举元素。但是在 C 中，您可以直接访问元素，而无需使用枚举标识符进行后固定。

与字符串对象相比，使用枚举是一种更智能的定义方式，而且它占用的内存空间更少。

int main(void) {
    User user1 = { "John", 34, Builder };
    printf("sizeof(User user1) == %li\n", sizeof(user1));
    printf("sizeof(Job Builder) == %li\n", sizeof(Builder));
    printf("sizeof(char* \"builder\") == %li\n", sizeof("builder"));

    return 0;
}

sizeof(User user1) == 16
sizeof(Job Builder) == 4
sizeof(char* "builder") == 8

使用枚举，可以为声明中的元素设置一个值：

typedef enum {
    Working = 1,
    Failed = 0,
    Freezed = -1
} State;

具有结构的方法

C 语言不嵌入类，因此没有方法。但是，我们可以通过指针重新创建这个原理

User new_user(char* name, int age, Job job) {
    User temp = { name, age, job };
    return temp;
}

void print_user(User user) {
    printf("User(%s, %i, %s)\n", user.name, user.age, job_to_string(user.job));
}

void change_user_job(User* user, Job job) {
    user->job = job;
}

void free_user(User* user) {
    user->name = (char*) NULL;
    user->age = -1;
    user->job = Null;
    user = (User*) NULL;
}

是什么user-><attribute>意思？为什么我们有时使用它而不是user.<attribute>？

当我们操作结构对象的指针时，我们不能直接访问属性。

int n = 5;
int* ptr_n = &n;
assert(*ptr_n == 5); // pointed value retrieved

所以，我们应该这样做：

(*user).job

我们必须拥抱user，因为*user.job无法做到，因为这意味着我们要检索 的指向值job。

但是，这是一种无聊的语法，所以 C 语言允许使用->符号来代替，以使事情变得更容易。

(*user).job = user->job

---

练习

1. 使用 switch 语句将 aJob元素转换器写入字符串函数

2. 使用一周中的 7 天创建一个枚举，每个元素都必须按其天数分配。除此之外，创建以下函数：

   int is_weekend(DayWeek day_week);
   
   

---

解决方案

1. 使用 switch 语句将 aJob元素转换器写入字符串函数

   char* job_to_string(Job job) {
      switch (job) {
          case Builder:
              return "Builder";
          case Dentist:
              return "Dentist";
          case Engineer:
              return "Engineer";
          case Fireman:
              return "Fireman";
          case Lawyer:
              return "Lawyer";
          case Teacher:
              return "Teacher";
          case Waiter:
              return "Waiter";
          case Null:
              return "(null)";
      }
   }
   
   

2. 使用一周中的 7 天创建一个枚举，每个元素都必须按其一周中的天数分配。除此之外，创建以下函数：

   int is_weekend(DayWeek day_week);
   
   

   #include <assert.h>
   
   typedef enum {
      Monday = 1,
      Tuesday = 2,
      Wednesday = 3,
      Thursday = 4,
      Friday = 5,
      Saturday = 6,
      Sunday = 7
   } DayWeek;
   
   int is_weekend(DayWeek day_week) {
      // A weekday, not a day of the weekend
      if (day_week != 6 && day_week != 7) {
          return 0;
      }
      return 1;
   }
   
   int main() {
      assert(Monday == 1);
      assert(Sunday == 7);
      assert(is_weekend(Wednesday) != 1);
      assert(is_weekend(Saturday) == 1);
   
      return 0;
   }