C++的组合类型指的是在一个类或者结构体中包含其他类型的对象作为成员，这种设计可以将多个相关的对象组合在一起，实现更复杂的数据结构或者功能逻辑。嵌套对象的访问需要遵循C++的成员访问规则，根据嵌套的层级和对象的存储方式不同，访问方法也有一定区别。
基础组合类型的嵌套对象访问
最基础的嵌套场景是在一个结构体或者类中直接定义另一个结构体或类的对象作为成员，这种情况下可以通过连续的成员访问运算符来访问内层的对象成员。
#include <iostream>
#include <string>
// 定义内层嵌套的结构体
struct Address {
std::string city;
std::string street;
int door_number;
};
// 定义外层组合结构体，包含Address类型的对象作为成员
struct Person {
std::string name;
int age;
Address addr; // 嵌套的Address对象
};
int main() {
// 初始化外层对象
Person p;
p.name = "张三";
p.age = 25;
// 访问嵌套对象的成员，使用连续的点运算符
p.addr.city = "北京";
p.addr.street = "朝阳路";
p.addr.door_number = 100;
std::cout << "姓名：" << p.name << std::endl;
std::cout << "年龄：" << p.age << std::endl;
std::cout << "城市：" << p.addr.city << std::endl;
std::cout << "街道：" << p.addr.street << std::endl;
std::cout << "门牌号：" << p.addr.door_number << std::endl;
return 0;
}
指针类型嵌套对象的访问
如果组合类型中的嵌套对象是指针类型，那么访问内层成员的时候需要使用箭头运算符，或者先解引用再使用点运算符。
#include <iostream>
#include <string>
struct Score {
int math;
int chinese;
int english;
};
struct Student {
std::string student_id;
Score* score_ptr; // 嵌套的Score类型指针
};
int main() {
Student stu;
stu.student_id = "2024001";
// 为指针分配内存
stu.score_ptr = new Score();
// 通过箭头运算符访问嵌套对象的成员
stu.score_ptr->math = 90;
stu.score_ptr->chinese = 85;
stu.score_ptr->english = 88;
// 也可以先解引用再使用点运算符
(*stu.score_ptr).math = 92;
std::cout << "学号：" << stu.student_id << std::endl;
std::cout << "数学分数：" << stu.score_ptr->math << std::endl;
std::cout << "语文分数：" << stu.score_ptr->chinese << std::endl;
std::cout << "英语分数：" << stu.score_ptr->english << std::endl;
// 释放动态分配的内存
delete stu.score_ptr;
stu.score_ptr = nullptr;
return 0;
}
多层嵌套对象的访问
当嵌套层级超过两层的时候，只需要按照从外到内的顺序，依次使用对应的访问运算符即可，指针类型和非指针类型混合的场景也遵循同样的规则。
#include <iostream>
#include <string>
struct Course {
std::string course_name;
int course_score;
};
struct Semester {
Course* course_list[3]; // 存储Course指针的数组
int course_count;
};
struct StudentInfo {
std::string name;
Semester* sem; // 指向Semester的指针
};
int main() {
StudentInfo info;
info.name = "李四";
info.sem = new Semester();
info.sem->course_count = 2;
// 初始化课程列表
info.sem->course_list[0] = new Course();
info.sem->course_list[0]->course_name = "C++编程";
info.sem->course_list[0]->course_score = 95;
info.sem->course_list[1] = new Course();
info.sem->course_list[1]->course_name = "数据结构";
info.sem->course_list[1]->course_score = 92;
std::cout << "学生姓名：" << info.name << std::endl;
for (int i = 0; i < info.sem->course_count; i++) {
std::cout << "课程" << i + 1 << "名称：" << info.sem->course_list[i]->course_name << std::endl;
std::cout << "课程" << i + 1 << "分数：" << info.sem->course_list[i]->course_score << std::endl;
}
// 释放内存
for (int i = 0; i < info.sem->course_count; i++) {
delete info.sem->course_list[i];
}
delete info.sem;
info.sem = nullptr;
return 0;
}
访问过程中的注意事项
- 访问嵌套对象前要确保对象已经被正确初始化，尤其是指针类型的嵌套对象，避免使用未初始化的野指针，否则会导致程序崩溃。
- 连续的成员访问运算符要注意优先级，点运算符和箭头运算符的优先级都比较高，不需要额外加括号，但是如果有复杂的表达式建议适当添加括号提升可读性。
- 如果嵌套对象是const类型，那么只能访问其成员，不能修改成员的值，访问的时候要注意对象的常量属性。
- 动态分配的嵌套对象在使用完成后要及时释放内存，避免内存泄漏，释放后最好将指针置为nullptr，避免野指针问题。
常见错误示例
下面是初学者容易出现的错误写法，需要注意避免：
#include <iostream>
#include <string>
struct Inner {
int value;
};
struct Outer {
Inner in;
};
int main() {
Outer* o = new Outer();
// 错误写法：o是指针，不能直接用点运算符访问成员
// o.in.value = 10;
// 正确写法：指针用箭头运算符
o->in.value = 10;
std::cout << "值：" << o->in.value << std::endl;
delete o;
o = nullptr;
return 0;
}