# C++ 结构体 完整笔记

# C++ 结构体 完整笔记

## 一、结构体基础概念

### 1\. 定义语法

结构体是**自定义复合数据类型**，可存放多个不同类型的成员变量，C++ 中结构体和类用法高度相似，**默认访问权限为 public**（类默认 private）。

```cpp
// 标准定义格式
struct 结构体名
{
    // 成员变量
    数据类型 成员名1;
    数据类型 成员名2;
    // 成员函数（C++ 支持）
    函数返回值 函数名(参数列表);
}; // 末尾分号不能省略
```

### 2\. 简单示例

```cpp
#include <iostream>
#include <string>
using namespace std;

// 定义学生结构体
struct Student
{
    int id;
    string name;
    int age;
};
```

## 二、结构体变量创建与初始化

### 1\. 定义变量的三种方式

```cpp
// 方式1：先定义结构体，再创建变量（最常用）
struct Student s1;
Student s2;  // C++ 可省略 struct 关键字

// 方式2：定义结构体同时创建变量
struct Student
{
    int id;
    string name;
} s3, s4; // 末尾直接定义变量

// 方式3：匿名结构体（无结构体名，只能当场定义变量）
struct
{
    int a;
    int b;
} num;
```

### 2\. 初始化方式

#### （1）顺序初始化（C++11 前通用）

```cpp
// 逐个赋值
Student s1;
s1.id = 1001;
s1.name = "张三";
s1.age = 18;

// 整体初始化列表
Student s2 = {1002, "李四", 19};
```

#### （2）C++11 列表初始化（推荐）

```cpp
Student s3{1003, "王五", 20};
// 部分初始化，未赋值成员默认置0/空
Student s4{1004}; 
```

## 三、结构体构造函数 & 析构函数

C++ 结构体**完全支持构造函数、析构函数**，规则和类一致。

### 1\. 构造函数

作用：创建结构体对象时，自动初始化成员变量。 规则：

*   函数名和**结构体名相同**，无返回值；
    
*   可重载（多个构造函数）；
    
*   创建对象时自动调用。
    

#### 示例代码

```cpp
#include <iostream>
#include <string>
using namespace std;

struct Student
{
    int id;
    string name;
    int age;

    // 1. 默认构造函数（无参）
    Student()
    {
        id = 0;
        name = "未知";
        age = 0;
        cout << "默认构造函数调用" << endl;
    }

    // 2. 有参构造函数（重载）
    Student(int i, string n, int a)
    {
        id = i;
        name = n;
        age = a;
        cout << "有参构造函数调用" << endl;
    }

    // 3. 拷贝构造函数
    Student(const Student& s)
    {
        id = s.id;
        name = s.name;
        age = s.age;
        cout << "拷贝构造函数调用" << endl;
    }
};

int main()
{
    Student s1;                // 调用 默认构造
    Student s2{1001, "小明", 18}; // 调用 有参构造
    Student s3 = s2;           // 调用 拷贝构造
    return 0;
}
```

### 2\. 析构函数

作用：对象销毁时自动调用，常用于释放资源。 规则：

*   函数名：`~结构体名`，无返回值、无参数；
    
*   **只能有一个析构函数**，不能重载；
    
*   对象生命周期结束时自动执行。
    

```cpp
struct Student
{
    int id;
    // 析构函数
    ~Student()
    {
        cout << "析构函数调用，对象销毁" << endl;
    }
};

int main()
{
    Student s;
    return 0; // 函数结束，s 销毁，自动调用析构
}
```

## 四、结构体成员函数

结构体内部可以定义普通成员函数、常成员函数，用法和类一致。

### 1\. 基础成员函数

```cpp
#include <iostream>
using namespace std;

struct Point
{
    int x, y;

    // 成员函数：打印坐标
    void print()
    {
        cout << "坐标：(" << x << "," << y << ")" << endl;
    }
};

int main()
{
    Point p{10, 20};
    p.print(); // 调用格式：对象.成员函数()
    return 0;
}
```

### 2\. const 常成员函数

关键字 `const` 修饰函数，**禁止修改成员变量**，只读使用，建议查询类函数都加上。

```cpp
struct Point
{
    int x, y;
    // 常成员函数
    void show() const
    {
        // x = 100;  // 报错，const 函数不能修改成员
        cout << "坐标：(" << x << "," << y << ")" << endl;
    }
};
```

## 五、结构体作为函数参数（重点）

共 3 种传递方式，区别在**是否拷贝、能否修改原数据、执行效率**。

```cpp
#include <iostream>
#include <string>
using namespace std;

struct MyStruct
{
    int id;
    string name;
};
```

### 1\. 值传递

```cpp
// 值传递：创建结构体副本
void funcByValue(MyStruct s)
{
    s.id = 999; // 仅修改副本，原数据不变
}
```

*   特点：生成独立副本，**修改不影响原对象**；
    
*   缺点：大数据结构体拷贝耗时，效率低；
    
*   适用：小型结构体、需要保护原数据。
    

### 2\. 普通引用传递

```cpp
// 引用传递：不创建副本，直接操作原对象
void funcByRef(MyStruct &s)
{
    s.id = 999; // 直接修改原始数据
}
```

*   特点：无副本，**效率高**；
    
*   缺点：函数内修改会同步到原对象；
    
*   适用：需要主动修改结构体数据。
    

### 3\. const 引用传递（开发最常用）

```cpp
// const 引用：只读、无副本、安全高效
void funcByConstRef(const MyStruct &s)
{
    // s.id = 999; // 报错，禁止修改
    cout << s.id << endl; // 正常读取
}
```

*   特点：兼顾**高效率 + 数据保护**；
    
*   适用：仅读取数据、不做修改的场景。
    

## 六、结构体数组

多个结构体对象可以组成数组，批量管理数据。

```cpp
#include <iostream>
#include <string>
using namespace std;

struct Student
{
    int id;
    string name;
};

int main()
{
    // 定义结构体数组并初始化
    Student stuArr[2] = {
        {1001, "张三"},
        {1002, "李四"}
    };

    // 遍历数组
    for (int i = 0; i < 2; i++)
    {
        cout << stuArr[i].id << " " << stuArr[i].name << endl;
    }
    return 0;
}
```

## 七、结构体指针

### 1\. 基础用法

*   指针访问成员：使用 `->` 符号；
    
*   普通对象访问成员：使用 `.` 符号。
    

```cpp
struct Student
{
    int id;
};

int main()
{
    Student s{1001};
    Student *p = &s; // 结构体指针指向对象

    cout << p->id; // 指针访问成员：->
    return 0;
}
```

### 2\. 动态开辟内存

```cpp
// 堆区创建结构体对象
Student *p = new Student;
p->id = 1001;
delete p; // 手动释放内存
```

## 八、结构体嵌套

结构体内部可以包含另一个结构体，实现复杂数据组合。

```cpp
#include <iostream>
#include <string>
using namespace std;

// 嵌套结构体
struct Birthday
{
    int year;
    int month;
    int day;
};

struct Person
{
    string name;
    int age;
    Birthday birth; // 嵌套结构体成员
};

int main()
{
    Person p{"小红", 18, {2008, 6, 1}};
    // 多层访问成员：. 逐级调用
    cout << p.birth.year << endl;
    return 0;
}
```

## 九、结构体与类的核心区别（C++）

1.  **默认访问权限**
    
    *   结构体（struct）：默认 `public`
        
    *   类（class）：默认 `private`
        
2.  其余语法完全互通：都支持成员变量、成员函数、构造/析构、继承、重载等。
    

## 十、整体速记总结

1.  结构体是复合数据类型，C++ 兼容面向对象特性；
    
2.  初始化支持列表赋值，可定义**构造、拷贝、析构函数**；
    
3.  成员函数直接访问内部变量，`const` 函数只读不可改；
    
4.  函数参数优先使用 **const 引用**，高效又安全；
    
5.  普通对象用 `.` 访问成员，指针用 `->` 访问成员；
    
6.  支持数组、指针、嵌套，可组合复杂业务数据。