#cspjc9. 结构体

结构体

结构体

1.构造函数传参:score(s) 与 score = s 对比

struct Student {
    int id;
    double score;
    // 形式1:初始化列表
    Student(int n, double s) : id(n), score(s) {}
    // 形式2:函数体内赋值
    Student(double s, int n) { id = n; score = s; }
};

1.以下创建对象正确的是( )?{{ multiselect(1) }}

  • Student s1(1001, 95.5); 使用形式1初始化
  • Student s2(88.5, 1002); 使用形式2初始化
  • Student s3; 可以调用无参构造(但此处没有提供)
  • Student s4 = {1003, 92.0}; 可以编译通过
  • 两种构造函数的参数顺序不同,可以重载共存

2.结构体数组定义与初始化

struct Point {
    int x, y;
    Point() : x(0), y(0) {}
    Point(int a, int b) : x(a), y(b) {}
};

int main() {
    Point p1[3];                  // ①
    Point p2[3] = {{1,2}, {3,4}, {5,6}};  // ②
    Point p3[] = {Point(1,1), Point(2,2)}; // ③
    Point p4[2];
    p4[0] = Point(10,20);         // ④
}

2.以下说法正确的是( )?{{ multiselect(2) }}

  • ① 中每个元素都调用无参构造,x=y=0
  • ② 中用列表初始化,调用有参构造
  • ③ 中数组大小为2
  • ④ 中先创建临时对象,再赋值给 p4[0]
  • 结构体数组不能用赋值方式逐个修改元素

3.无参构造 + 缺省参数构造,避免歧义

struct Time {
    int h, m;
    Time() : h(0), m(0) {}
    Time(int hour = 8, int min = 0) : h(hour), m(min) {}
};

2.以下对象定义正确的是( )?{{ multiselect(3) }}

  • Time t1;
  • Time t2(9);
  • Time t3(9, 30);
  • Time t4 = Time();
  • 这段代码编译会报错,因为无参构造和缺省参数构造冲突

4.结构体成员函数 + 修改成员

struct Array {
    int data[5];
    int size;
    Array() : size(0) {}
    void add(int val) { 
        if (size < 5) data[size++] = val; 
    }
    int get(int idx) const { return data[idx]; }
};

4.以下正确的是( )? {{ multiselect(4) }}

  • add可以修改 size
  • get 可以修改 data 内容
  • 结构体成员 data 和 size 默认是 public,可以直接访问
  • const Array a; 可以调用 a.add(10)
  • get 函数加了 const,可以保证不修改对象

5.结构体赋值与数组拷贝陷阱

struct Buffer {
    int* p;
    int len;
    Buffer(int n) : len(n) { p = new int[n]; }
    ~Buffer() { delete[] p; }
};

int main() {
    Buffer b1(10);
    Buffer b2 = b1;   // 默认拷贝
}

5.以下说法正确的是? {{ multiselect(5) }}

  • 执行 Buffer b2 = b1; 后,b2 和 b1 这两个变量在内存中的地址是相同的
  • 执行 Buffer b2 = b1; 后,b2.p 和 b1.p 存储的堆内存地址是相同的
  • 由于编译器自动生成了拷贝构造函数,所以这段代码编译一定不会报错,但运行时会崩溃
  • 若想安全运行,必须自定义拷贝构造函数,并在其中为 p 重新开辟独立的内存空间
  • 自定义拷贝构造函数后,程序结束析构时,b1 和 b2 会分别释放两块独立的堆内存,不会冲突

析构 “析构”(Destructor),就是代码里的 ~Buffer() { delete[] p; }。 它的作用是:当对象生命周期结束时(比如离开 main 函数作用域),系统会自动调用它,用来释放对象申请的资源。

浅拷贝/深拷贝 编译器生成的叫“默认拷贝构造函数”,它只会做浅拷贝(Shallow Copy),即简单复制指针的数值(地址)。 我们需要手动定义“深拷贝构造函数(Deep Copy)”,让新对象拥有自己独立的堆内存,并把旧对象的数据复制过来。


6.结构体数组整体赋值

struct Node {
    int val;
    Node(int v = 0) : val(v) {}
};

int main() {
    Node arr1[3] = {1, 2, 3};
    Node arr2[3];
    arr2 = arr1;  // ①
    arr2[0] = arr1[1]; // ②
}

6.以下说法正确的是( )?{{ multiselect(6) }}

  • ① 可以编译,数组间可以直接赋值
  • ① 编译错误,数组不能直接整体赋值
  • ② 可以编译,单个元素赋值合法
  • ① 如果改成 memcpy(arr2, arr1, sizeof(arr1)); 可以
  • 结构体数组元素间赋值会调用拷贝赋值运算符