C++如何定义自定义数据类型管理多个变量-C++-PHP中文网

C++中通过struct和class定义自定义数据类型来管理多个变量，struct适用于简单数据聚合，class更适合封装复杂行为和状态，二者本质功能相同但默认访问权限不同，推荐结合std::vector等标准库容器高效管理对象集合。

c++如何定义自定义数据类型管理多个变量

在C++中，要定义自定义数据类型来管理多个变量，我们主要依赖

struct

登录后复制

（结构体）和

class

登录后复制

（类）这两种机制。它们允许你将逻辑上相关的数据（以及操作这些数据的函数）打包在一起，形成一个有意义的整体，极大地提升了代码的组织性、可读性和可维护性。

解决方案

从我的经验来看，当你发现有多个变量总是需要一起出现，并且它们共同描述了一个“事物”时，比如一个人的姓名、年龄、身高，或者一本书的标题、作者、出版年份，那么这就是定义一个自定义数据类型的好时机。

使用

struct

登录后复制

来聚合数据

struct

登录后复制

是最直接的方式，它本质上就是一块内存区域的模板，里面包含了你定义的所有成员变量。默认情况下，

struct

登录后复制

的所有成员都是

public

登录后复制

的，这意味着你可以直接访问它们。这对于那些主要用于存储数据，行为比较简单的场景非常合适。

立即学习“C++免费学习笔记（深入）”；

#include <string>
#include <iostream>

// 定义一个表示“学生”的结构体
struct Student {
    std::string name;
    int age;
    double grade;

    // 结构体也可以有成员函数，尽管通常更倾向于用类
    void printInfo() {
        std::cout << "姓名: " << name << ", 年龄: " << age << ", 成绩: " << grade << std::endl;
    }
};

// 使用示例
// int main() {
//     Student s1;
//     s1.name = "张三";
//     s1.age = 20;
//     s1.grade = 88.5;
//     s1.printInfo();
//
//     Student s2 = {"李四", 22, 92.0}; // C++11 列表初始化
//     s2.printInfo();
//     return 0;
// }

登录后复制

使用

class

登录后复制

来封装数据和行为

class

登录后复制

比

struct

登录后复制

更强大，它引入了“封装”的概念。虽然语法上两者非常相似，但

class

登录后复制

的默认成员访问权限是

private

登录后复制

的。这意味着你通常会把数据成员声明为

private

登录后复制

，然后通过

public

登录后复制

的成员函数（方法）来访问和修改这些数据。这样做的好处是你可以更好地控制数据的有效性，隐藏实现细节，这在构建复杂系统时至关重要。

#include <string>
#include <iostream>

// 定义一个表示“书籍”的类
class Book {
private: // 数据通常是私有的，这是封装的核心
    std::string title;
    std::string author;
    int publicationYear;

public: // 公共接口，用于与类的对象交互
    // 构造函数：初始化对象时调用
    Book(const std::string& t, const std::string& a, int year)
        : title(t), author(a), publicationYear(year) {
        // 可以在这里添加一些验证逻辑，比如确保年份是合理的
        if (publicationYear < 1440 || publicationYear > 2024) {
            std::cerr << "警告：书籍 '" << title << "' 的出版年份可能不合理。" << std::endl;
        }
    }

    // Getter 方法：获取私有数据
    std::string getTitle() const { return title; }
    std::string getAuthor() const { return author; }
    int getPublicationYear() const { return publicationYear; }

    // Setter 方法：修改私有数据（如果允许的话）
    void setPublicationYear(int year) {
        if (year >= 1440 && year <= 2024) { // 再次进行验证
            publicationYear = year;
        } else {
            std::cerr << "错误：无效的出版年份。" << std::endl;
        }
    }

    // 其他行为方法
    void displayInfo() const {
        std::cout << "书名: " << title << ", 作者: " << author << ", 出版年份: " << publicationYear << std::endl;
    }
};

// 使用示例
// int main() {
//     Book b1("C++ Primer", "Stanley B. Lippman", 2012);
//     b1.displayInfo();
//
//     b1.setPublicationYear(2020); // 修改年份
//     b1.displayInfo();
//
//     b1.setPublicationYear(1000); // 尝试设置无效年份
//     b1.displayInfo(); // 年份不会改变，因为setter有校验
//     return 0;
// }

登录后复制

选择

struct

登录后复制

还是

class

登录后复制

，很多时候取决于你的设计意图：如果它只是一个简单的数据容器（Plain Old Data, POD-like），并且行为很少，

struct

登录后复制

通常是首选。如果它是一个复杂的对象，有自己的内部状态和复杂的行为，并且需要严格的封装，那么

class

登录后复制

无疑是更好的选择。

为什么不直接用数组或

std::tuple

登录后复制

来管理多个变量？

这是一个很好的问题，我个人在初学C++时也曾有过类似的疑惑。确实，数组可以管理多个同类型变量，

std::tuple

登录后复制

也能管理多个不同类型变量。但它们和自定义数据类型（

struct

登录后复制

或

class

登录后复制

）的哲学是完全不同的。

首先，数组是为同质数据设计的。如果你想存储一个班级所有学生的年龄，

int ages[50];

登录后复制

就很好。但如果你想存储一个学生的姓名、年龄和成绩，这些是不同类型的数据，强行塞进数组会非常别扭，你需要用索引来区分它们，比如

data[0]

登录后复制

是姓名，

data[1]

登录后复制

是年龄——这很快就会变成一场维护噩梦，代码可读性极差，而且类型安全也无从谈起。

其次，

std::tuple

登录后复制

确实可以管理异构数据，比如

std::tuple<std::string, int, double> studentInfo;

登录后复制

。这看起来很方便，尤其是在一些临时性的、小范围的数据组合场景。但是，它的问题在于缺乏语义。当你看到

std::get<0>(studentInfo)

登录后复制

时，你知道这是什么吗？你可能需要翻看定义才知道

登录后复制

代表姓名。这种基于索引的访问方式，在代码量变大、数据结构复杂后，会使得代码难以理解和维护。想象一下，如果一个

tuple

登录后复制

里有十几个元素，那简直是灾难。

而

struct

登录后复制

或

class

登录后复制

，它们为你的数据组合赋予了明确的名称和语义。

student.name

登录后复制

、

book.getTitle()

登录后复制

，这些表达方式清晰直观，一眼就能明白变量的用途。它们提供了类型安全，编译器会在你尝试访问不存在的成员或错误地使用成员时报错。更重要的是，自定义类型允许你将数据和操作数据的方法紧密结合在一起，形成一个内聚的单元，这正是面向对象编程的核心思想，也是构建健壮、可扩展软件的关键。在我看来，

std::tuple

登录后复制

更像是一个轻量级的、无名的临时容器，而

struct

登录后复制

class

登录后复制

则是你构建应用逻辑和数据模型的基石。

通义万相

通义万相，一个不断进化的AI艺术创作大模型

596

查看详情

struct

登录后复制

和

class

登录后复制

在C++中到底有什么本质区别？

这个问题常常困扰初学者，甚至一些有经验的开发者也会偶尔混淆。但说实话，在C++中，

struct

登录后复制

和

class

登录后复制

的本质区别微乎其微，更多的是一种约定俗成和默认行为上的差异，而非功能上的根本不同。

唯一的、真正的语法区别在于：

默认成员访问权限：
- ```
struct
```
  登录后复制
  的成员（包括数据成员和成员函数）默认是
```
public
```
  登录后复制
  的。
- ```
class
```
  登录后复制
  的成员默认是
```
private
```
  登录后复制
  的。这意味着，如果你在
```
struct
```
  登录后复制
  中不显式指定访问权限，所有成员都可以从外部直接访问；而在
```
class
```
  登录后复制
  中，你需要显式地将希望外部访问的成员声明为
```
public
```
  登录后复制
  。
默认继承访问权限：
- 当一个
```
struct
```
  登录后复制
  继承另一个
```
struct
```
  登录后复制
  或
```
class
```
  登录后复制
  时，默认的继承方式是
```
public
```
  登录后复制
  继承。
- 当一个
```
class
```
  登录后复制
  继承另一个
```
struct
```
  登录后复制
  或
```
class
```
  登录后复制
  时，默认的继承方式是
```
private
```
  登录后复制
  继承。这个区别在实际开发中，由于我们通常会显式地指定继承方式（如
```
class Derived : public Base
```
  登录后复制
  ），所以其影响相对较小。

除了这两点，

struct

登录后复制

和

class

登录后复制

在C++中是完全等价的。你可以给

struct

登录后复制

添加成员函数、构造函数、析构函数、继承、多态等等，它拥有

class

登录后复制

的所有功能。反之亦然。

那么，既然功能一样，为什么C++要保留两种关键字呢？这主要是出于历史原因（

struct

登录后复制

来自C语言）和语义约定。

struct
登录后复制
的语义：习惯上，我们用
```
struct
```
登录后复制
来定义那些主要用于聚合数据、行为较少或没有、且数据成员可以直接访问的“简单”数据结构。它们往往被视为“值类型”，或者说，它们更接近C语言中的结构体，代表着一种“数据容器”的概念。
class
登录后复制
的语义：我们通常用
```
class
```
登录后复制
来定义那些具有复杂行为、需要严格封装内部状态、提供清晰公共接口的“对象”。它们更强调“行为”和“责任”，代表着面向对象编程中的“对象”概念。

所以，选择

struct

登录后复制

还是

class

登录后复制

，更多的是一种代码风格和设计意图的表达。在我看来，如果你只是想简单地把几个变量捆绑在一起，并且不打算有复杂的封装逻辑，用

struct

登录后复制

会显得更轻量、更直接。如果你的类型需要维护一些内部不变量、提供受控的接口，或者未来可能会有继承和多态的需求，那么

class

登录后复制

无疑是更符合面向对象原则的选择。

如何高效管理这些自定义类型对象的集合？

定义了自定义数据类型之后，我们通常不会只创建一个对象，而是会创建大量这样的对象，并将它们组织起来。C++标准库为我们提供了非常强大的容器，它们是管理对象集合的利器。

最常用、也是最推荐的容器是

std::vector

登录后复制

。它就像一个动态数组，可以存储任意数量的你的自定义类型对象，并且在需要时自动扩容。

#include <vector>
#include <string>
#include <iostream>
#include <algorithm> // 用于 std::sort

// 假设我们有之前定义的 Student 结构体
struct Student {
    std::string name;
    int age;
    double grade;

    void printInfo() const { // 注意这里加了 const
        std::cout << "姓名: " << name << ", 年龄: " << age << ", 成绩: " << grade << std::endl;
    }
};

// 假设我们有之前定义的 Book 类
class Book {
private:
    std::string title;
    std::string author;
    int publicationYear;
public:
    Book(const std::string& t, const std::string& a, int year)
        : title(t), author(a), publicationYear(year) {}
    std::string getTitle() const { return title; }
    std::string getAuthor() const { return author; }
    int getPublicationYear() const { return publicationYear; }
    void displayInfo() const {
        std::cout << "书名: " << title << ", 作者: " << author << ", 出版年份: " << publicationYear << std::endl;
    }
};

int main() {
    // 管理 Student 对象的集合
    std::vector<Student> students;

    // 添加学生对象
    students.push_back({"张三", 20, 88.5});
    students.push_back({"李四", 22, 92.0});
    students.emplace_back("王五", 21, 78.0); // emplace_back 可以直接在容器内部构造对象，更高效

    std::cout << "--- 学生列表 ---" << std::endl;
    for (const auto& s : students) { // 使用范围for循环遍历
        s.printInfo();
    }

    // 对学生按成绩排序（需要提供比较函数）
    std::sort(students.begin(), students.end(), [](const Student& a, const Student& b) {
        return a.grade > b.grade; // 降序排列
    });

    std::cout << "\n--- 按成绩排序后的学生列表 ---" << std::endl;
    for (const auto& s : students) {
        s.printInfo();
    }

    // 管理 Book 对象的集合
    std::vector<Book> library;
    library.emplace_back("Effective C++", "Scott Meyers", 1991);
    library.emplace_back("Clean Code", "Robert C. Martin", 2008);

    std::cout << "\n--- 图书馆藏书 ---" << std::endl;
    for (const auto& book : library) {
        book.displayInfo();
    }

    // 查找特定书籍
    std::string searchTitle = "Clean Code";
    auto it = std::find_if(library.begin(), library.end(), [&](const Book& b){
        return b.getTitle() == searchTitle;
    });

    if (it != library.end()) {
        std::cout << "\n找到书籍: ";
        it->displayInfo();
    } else {
        std::cout << "\n未找到书籍: " << searchTitle << std::endl;
    }

    return 0;
}

登录后复制

除了

std::vector

登录后复制

，还有其他一些容器可以根据你的具体需求选择：

std::list
登录后复制
: 如果你需要频繁在序列的任意位置进行插入和删除操作，并且对随机访问性能要求不高，
```
std::list
```
登录后复制
（双向链表）会是更好的选择。
std::map
登录后复制
/
std::unordered_map
登录后复制
: 如果你需要根据一个键（key）来快速查找你的自定义对象，那么映射容器是理想的。
```
std::map
```
登录后复制
提供有序存储和对数时间复杂度查找，
```
std::unordered_map
```
登录后复制
提供无序存储和平均常数时间复杂度查找。
std::set
登录后复制
/
std::unordered_set
登录后复制
: 如果你只需要存储自定义对象的唯一实例，并且希望能够快速检查某个对象是否存在，集合容器就非常有用。