C++学习之结构体

什么是C++结构体

C++结构体（Struct）是一种用户自定义的数据类型，用于存储多个不同类型的数据项。结构体可以包含一个或多个成员变量，并可根据需求定义自己的操作（函数）。

在C++中，结构体可以像类一样定义成员变量和成员函数，并可以使用访问修饰符指定成员的可见性（public、private、protected）。与类不同的是，默认情况下结构体的成员变量和成员函数是公共的（public），即任何地方都能直接访问。

结构体通常用于组织相关的数据，例如表示一个人（姓名、年龄、性别等信息）、表示一个点（x坐标、y坐标）、表示一个日期（年、月、日）等。通过定义结构体，可以将相关数据打包在一起，方便进行操作和传递。

C++结构体是一种自定义类型

是的，你说得对。C++结构体是一种自定义类型，它允许程序员创建一个包含不同类型成员的数据结构。通过定义结构体，可以将多个相关的数据项组合在一起，并且可以通过结构体变量来访问和操作这些数据项。

和C语言中的结构体类似，C++结构体也可以包含不同数据类型的成员变量。不同的是，C++结构体还可以包含成员函数（即方法），使其更接近于类的概念。

因为C++中的结构体更接近于类的概念，所以在C++中可以使用面向对象的编程思想来操作结构体。这使得结构体在C++中不仅仅是一种简单的数据类型，更具有更多的灵活性和功能。

C++结构体的定义、声明、使用

C++中结构体的定义、声明和使用可以参考以下步骤：

1. 定义结构体：
   在适当的位置（通常是头文件或源文件）使用 struct 关键字定义结构体，并为其命名。在结构体内部定义成员变量和成员函数。

// 结构体的定义
struct Person {
    std::string name;
    int age;
    void introduce() {
        std::cout << "My name is " << name << ", I'm " << age << " years old." << std::endl;
    }
};

1. 声明结构体变量：
   在程序中可以通过声明结构体变量来创建该结构体类型的对象。

// 结构体变量的声明
Person p1;

1. 初始化和访问结构体变量的成员：
   可以通过点操作符对结构体变量的成员进行初始化、赋值和访问。

// 初始化和赋值结构体变量的成员
p1.name = "Alice";
p1.age = 25;
// 访问结构体变量的成员并调用结构体的成员函数
std::cout << "Name: " << p1.name << std::endl;
std::cout << "Age: " << p1.age << std::endl;
p1.introduce();

注意事项：

• 结构体变量的声明必须在使用之前，可以在函数内部或全局作用域中声明结构体变量。
• 结构体内部可以定义成员变量和成员函数，它们默认为公有（public），也可以通过访问修饰符进行限制。
• 结构体变量的成员访问使用点操作符（.）。
• 可以通过结构体变量名和点操作符来调用结构体的成员函数。

定义结构体时使用 struct 关键字，在结构体内部定义成员变量和成员函数。声明结构体变量时提供结构体的名称，然后通过结构体变量来访问和操作成员变量和成员函数。

使用结构体的场景

结构体在C++中的使用场景有很多，主要包括以下几个方面：

1. 表示和操作复杂数据结构：
   结构体可以用于表示和操作复杂的数据结构，如树、图等。通过将相关的数据项打包在一个结构体中，可以更方便地进行操作和传递。
   
2. 组织相关的数据：
   结构体可以用于组织相关的数据项，将它们作为一个整体来处理。例如，表示一个人的姓名、年龄、性别等信息，可以使用一个Person结构体来组织这些数据。
   
3. 作为函数参数传递：
   结构体可以作为函数的参数，用于传递多个数据项。这样可以避免使用大量的参数，使函数调用更简洁和可读。
   
4. 定义数据类型：
   结构体可以作为一种自定义数据类型，用于表示具有特定属性和行为的对象。通过为结构体添加成员变量和成员函数，可以更加灵活地定义和使用数据类型。
   
5. 文件或网络数据传输：
   结构体可以用于在文件或网络上进行数据传输。通过将数据打包成结构体，可以方便地进行读写和解析，确保数据的完整性和一致性。
   

C++中还提供了更强大的类（Class）概念，类可以实现更复杂的封装和继承特性。所以如果需要更多的面向对象的特性，可以考虑使用类代替结构体。但对于简单的数据封装和组织，结构体是一种更简单和轻量级的选择。

结论：复杂的数据封装用类，简单的数据封装用结构体。

类和结构体的区别

让我们通过以下示例来展示类和结构体的区别：

// 使用类定义一个人的信息
class Person {
private:
    std::string name;
    int age;
public:
    void setName(std::string n) {
        name = n;
    }
    void setAge(int a) {
        age = a;
    }
    void introduce() {
        std::cout << "My name is " << name << ", I am " << age << " years old." << std::endl;
    }
};
// 使用结构体定义一个人的信息
struct PersonStruct {
    std::string name;
    int age;
    void introduce() {
        std::cout << "My name is " << name << ", I am " << age << " years old." << std::endl;
    }
};
int main() {
    // 使用类
    Person p;
    p.setName("Alice");
    p.setAge(25);
    p.introduce();
    // 使用结构体
    PersonStruct ps;
    ps.name = "Bob";
    ps.age = 30;
    ps.introduce();
    return 0;
}

在上面的示例中，我们定义了一个类 Person 和一个结构体 PersonStruct 来表示一个人的信息。类和结构体都有姓名（name）和年龄（age）两个成员变量，并且都有一个介绍自己的成员函数（introduce）。

在 main 函数中，我们首先创建一个类对象 p 和一个结构体对象 ps。然后分别使用类的成员函数和结构体的成员变量对它们进行初始化和赋值，并调用介绍自己的成员函数来输出信息。

这里展示了类和结构体在代码实现上的使用区别。注意到类中，成员变量和成员函数都默认为私有访问级别，需要通过公有成员函数来访问；而结构体中，成员变量默认为公有，可以直接在外部访问。此外，类也支持私有继承，默认的继承方式是私有继承，而结构体的默认继承方式是公有继承。

结构体的继承：我甚至可以认为结构体就是类的前身

在C++中，结构体是支持继承的，可以通过使用关键字 struct 或 class 来定义派生结构体（或派生类）。这意味着结构体可以从其他的结构体或类派生出来，继承它们的成员变量和成员函数。

以下是一个示例代码：

// 基类结构体
struct BaseStruct {
    int baseVar;
};
// 派生结构体
struct DerivedStruct : BaseStruct {
    int derivedVar;
};
int main() {
    DerivedStruct d;
    d.baseVar = 10;      // 继承自基类结构体的成员变量
    d.derivedVar = 20;   // 派生结构体自己的成员变量
    return 0;
}

在上述示例中，基类结构体 BaseStruct 定义了一个整型成员变量 baseVar。然后，派生结构体 DerivedStruct 使用 : BaseStruct 表示继承自基类结构体。因此，派生结构体继承了基类的成员变量。

通过创建派生结构体对象 d，我们可以访问和操作基类的成员变量 baseVar，以及派生结构体自己的成员变量 derivedVar。

结构体和类之间的继承机制本质上是相同的。在C++中，结构体和类除了默认的成员访问级别、默认的继承方式和默认的构造函数外，在语法上没有太大的区别。因此，结构体可以像类一样使用继承机制。

成员的变量访问和指针访问

在C++中，成员变量的访问可以通过成员访问操作符.（点操作符）来实现，也可以使用指向对象的指针以及箭头操作符->来进行访问。

以下是对两种方式的说明和示例：

1. 成员访问操作符.：
   使用.操作符可以直接访问对象的成员变量或成员函数。这种方式适用于直接操作对象本身。

示例：

class MyClass {
public:
    int memberVar;
    void memberMethod() {
        // 成员函数的定义
    }
};
int main() {
    MyClass obj;
    obj.memberVar = 10;       // 访问和修改成员变量
    obj.memberMethod();       // 调用成员函数
    return 0;
}

2. 指针访问和箭头操作符 ->：
   如果要通过指针间接访问对象的成员变量或成员函数，需要使用指向对象的指针，并使用箭头操作符 -> 来访问对象的成员。

示例：

class MyClass {
public:
    int memberVar;
    void memberMethod() {
        // 成员函数的定义
    }
};
int main() {
    MyClass obj;
    MyClass* ptr = &obj;      // 创建指向对象的指针
    ptr->memberVar = 10;      // 通过指针访问和修改成员变量
    ptr->memberMethod();      // 通过指针调用成员函数
    return 0;
}

在这个示例中，我们定义了一个类 MyClass，其中包含一个成员变量 memberVar 和一个成员函数 memberMethod。在 main 函数中，我们创建了一个对象 obj 和一个指向对象的指针 ptr。通过对象和指针分别使用.操作符或箭头操作符 -> 来访问对象的成员。

如果使用指针访问成员变量或成员函数，必须确保指针不为空，否则会导致未定义的行为。

结构体不被放弃的理由

在C++中，结构体仍然有其存在的理由，除了兼容性之外还有其他因素。尽管C++的类和结构体非常相似，但它们在一些方面仍然具有不同的特性和用途：

1. 历史原因：
   结构体在早期的C语言中就已经存在，并且被广泛使用。为了保持向后兼容性，C++保留了结构体这种数据集合的概念，并将其扩展为拥有更多面向对象功能的构造。因此，结构体的存在可以使得使用C语言编写的旧代码更容易迁移到C++环境中。
   
2. 数据组织：
   结构体通常被用来组织相关的数据字段，并且成员变量通常被放置在结构体内部。这使得结构体在表示简单数据结构时具有许多方便的特性，比如可以直接通过.操作符访问成员变量。
   
3. 默认访问级别：
   在类中，默认的成员访问级别是私有的，需要通过公有的成员函数来访问。而在结构体中，默认的访问级别是公有的，成员变量可以直接在外部访问。因此，结构体更适合表示一种数据的集合，而不关注封装和隐藏数据的实现细节。
   
4. 语义的区别：
   尽管在C++中，结构体和类在语法上并没有太大的区别，但是它们的语义不完全相同。从设计的角度来看，结构体更偏向于表示数据的集合，而类则更注重封装数据和行为，并支持面向对象的特性，比如封装、继承和多态等。
   

总的来说，尽管类和结构体在C++中具有相似的语法和功能，但它们仍然具有一些不同的特性和历史背景。结构体在表示简单数据结构、与旧代码的兼容性和默认访问级别方面有其优势，因此在特定的场景中仍然有其存在和使用价值。

结构体数组

结构体数组是一种常用的数据结构，它可以存储多个结构体对象，并且每个对象都具有相同的结构和类型。下面是一个使用结构体数组的示例代码：

#include <iostream>
#include <string>
struct Person {
    std::string name;
    int age;
};
int main() {
    const int size = 3;
    Person people[size];
    // 初始化结构体数组
    people[0] = {"Alice", 25};
    people[1] = {"Bob", 30};
    people[2] = {"Charlie", 35};
    // 遍历结构体数组并输出信息
    for (int i = 0; i < size; ++i) {
        std::cout << "Person " << i + 1 << ": "
                  << "Name: " << people[i].name << ", "
                  << "Age: " << people[i].age << std::endl;
    }
    return 0;
}

我们定义了一个名为 Person 的结构体，该结构体包含了一个姓名（name）和一个年龄（age）成员变量。

然后，我们在 main 函数中声明了一个大小为 3 的结构体数组 people，用于存储三个人的信息。

接下来，我们使用大括号初始化语法初始化结构体数组中的每个元素，依次设置姓名和年龄。

最后，通过遍历结构体数组并输出每个人的信息，我们可以看到结构体数组的使用方式。

注意：结构体数组的下标从 0 开始，因此在遍历结构体数组时，需要将索引值与实际序号相对应。

结构体指针

结构体指针是指向结构体的指针变量。通过结构体指针，可以间接地访问和操作结构体的成员变量和成员函数。下面是一个使用结构体指针的示例代码：

#include <iostream>
#include <string>
struct Person {
    std::string name;
    int age;
};
int main() {
    // 创建结构体对象
    Person person;
    person.name = "Alice";
    person.age = 25;
    // 创建结构体指针并指向已有的结构体对象
    Person* ptr = &person;
    // 通过指针访问结构体成员
    std::cout << "Name: " << ptr->name << std::endl;
    std::cout << "Age: " << ptr->age << std::endl;
    return 0;
}

我们首先定义了一个名为 Person 的结构体。然后，创建了一个结构体对象 person，并设置了该对象的成员变量。

接下来，我们声明了一个名为 ptr 的结构体指针，并将其指向 person 结构体对象的地址。这样，ptr 现在指向了该结构体对象。

通过箭头操作符 ->，我们可以通过结构体指针间接访问并输出结构体成员的值。

需要注意的是，在使用结构体指针访问结构体成员时，箭头操作符 -> 替代了点操作符 .。这是因为结构体指针并非直接引用结构体对象，而是间接引用它们。因此，箭头操作符 -> 用于解引用结构体指针并访问其成员。

结构体指针在需要动态创建和操作结构体对象时非常有用，例如在函数参数传递、链表和树等数据结构中。通过结构体指针，可以减少对复制和内存开销的需求，提高代码的效率。

结构体嵌套

在C++中，结构体可以嵌套定义在另一个结构体内部。这种嵌套结构体的使用可以帮助我们组织和管理更复杂的数据结构和对象。下面是一个示例代码，演示了结构体的嵌套使用：

#include <iostream>
#include <string>
struct Address {
    std::string city;
    std::string street;
    int zipCode;
};
struct Person {
    std::string name;
    int age;
    Address address; // 嵌套的结构体
};
int main() {
    Person person;
    person.name = "Alice";
    person.age = 25;
    person.address.city = "Beijing";
    person.address.street = "Main Street";
    person.address.zipCode = 100000;
    std::cout << "Name: " << person.name << std::endl;
    std::cout << "Age: " << person.age << std::endl;
    std::cout << "Address: " << person.address.city << ", "
              << person.address.street << ", "
              << person.address.zipCode << std::endl;
    return 0;
}

我们定义了两个结构体：Address 和 Person。Address 结构体表示一个地址，它包含了城市（city）、街道（street）和邮政编码（zipCode）三个成员变量。Person 结构体表示一个人的信息，它包含了姓名（name）、年龄（age）和一个嵌套的 Address 结构体。

在 main 函数中，我们创建了一个 Person 类型的对象 person，并通过结构体点操作符 . 来设置和访问其成员变量。注意到通过嵌套结构体的方式，我们可以在 Person 结构体内直接访问和管理地址信息。

最后，我们通过输出语句打印出 person 对象的各个成员的值。

结构体嵌套提供了一种更灵活的数据组织方式，可以使用多层次的结构体来描述和存储复杂的数据结构。通过嵌套结构体，可以将相关的数据组织在一起，使代码更易读、更具可理解性。

结构体做函数参数

在 C++ 中，结构体作为函数参数时，默认情况下，函数会传递结构体的副本，而不是原始结构体本身。因此，如果在函数中修改结构体的成员属性，实际上只会对副本进行修改，对原始结构体没有影响。

要在函数中修改原始结构体的属性，可以使用指向结构体的指针作为函数参数。通过传递指针，可以在函数内部直接访问和修改结构体的成员属性。

以下是一个示例代码，演示了如何通过指针修改结构体的属性：

#include <iostream>
#include <string>
struct Person {
    std::string name;
    int age;
};
// 使用指针修改结构体属性
void changeAge(Person* p, int newAge) {
    p->age = newAge;
}
int main() {
    Person person;
    person.name = "Alice";
    person.age = 25;
    std::cout << "Before the change: " << person.age << std::endl;
    changeAge(&person, 30);
    std::cout << "After the change: " << person.age << std::endl;
    return 0;
}

在上述示例中，我们定义了一个名为 Person 的结构体，并创建了一个 person 对象。然后，我们通过调用 changeAge 函数来修改 person 对象的年龄属性。

changeAge 函数的参数是一个指向 Person 结构体的指针 p，以及一个新的年龄值 newAge。在函数内部，我们使用箭头操作符 -> 来访问指针所指向的结构体对象，并修改了其年龄属性。

通过调用 changeAge 函数并传递 person 对象的地址作为参数，我们可以在函数外部看到结构体的属性值的变化。

要注意的是，在函数中操作结构体指针时，需要确保指针不为空。否则，会导致未定义的行为或程序崩溃。因此，在进行任何对结构体指针的操作之前，应该对指针进行必要的空指针检查。

结构体中使用const的情况

在结构体中使用 const 可以用来表示成员变量是不可变的（常量）或限制结构体方法中的操作。以下是几种常见的情况：

1. 声明常量成员变量：可以将结构体中的成员变量声明为 const 类型，表示该成员变量在结构体对象创建后不能被修改。

struct Circle {
    const double PI = 3.14159; // 常量成员变量
    double radius;
};

在上述示例中，PI 被声明为 const double 类型，表示其值不能被修改。

2. 在函数中使用 const 修饰函数参数和返回值：当结构体的方法中有参数和返回值时，可以使用 const 修饰参数类型和返回值类型，以确保在函数内部不会对参数进行修改或者返回修改后的值。

struct Point {
    int x;
    int y;
    
    void print() const; // const 修饰成员函数
};
void Point::print() const {
    // x = 10; // 错误！不允许修改成员变量
    std::cout << "x = " << x << ", y = " << y << std::endl;
}

在上述示例中，print 函数被声明为一个 const 成员函数，表示不会修改结构体的成员变量。

3. 使用 const 修饰返回常量引用：可以通过将函数的返回类型设置为 const 引用，来避免在函数中对返回的结构体对象进行修改。

struct Rectangle {
    int width;
    int height;
    const Rectangle& doubleSize() const; // 返回常量引用
};
const Rectangle& Rectangle::doubleSize() const {
    // width *= 2; // 错误！不允许修改成员变量
    // height *= 2;
    return *this; // 返回常量引用
}

doubleSize 函数的返回类型为 const Rectangle&，表示返回一个常量引用，防止对返回值进行修改。

使用 const 可以帮助确保程序的安全性和正确性，它使得编译器能够执行额外的检查并防止对 const 对象进行意外修改。

关注我，不迷路，共学习，同进步

关注我，不迷路，共学习，同进步