C++对象初始化与成员访问技巧详解-C++-PHP中文网

C++对象初始化需优先使用成员初始化列表，因其可提升效率、满足const和引用成员的强制初始化要求，并正确处理无默认构造函数的成员。

c++对象初始化与成员访问技巧详解

C++对象初始化，说白了，就是给新诞生的对象一个“初见礼”，确保它从一开始就处于一个有效且可用的状态。而成员访问，则是我们与对象内部数据和功能交互的桥梁。这两块儿，看似基础，实则蕴含着C++这门语言的诸多精妙之处和常见陷阱。理解并掌握它们，是写出健壮、高效C++代码的关键一步，也是我个人在实践中感触最深的地方。

解决方案

要深入理解C++对象初始化与成员访问，我们得从它们各自的核心机制和最佳实践入手。这不仅仅是语法层面的问题，更关乎设计哲学和代码质量。

对象初始化：赋予生命与状态

我发现很多人，包括我刚接触C++那会儿，总会把“初始化”和“赋值”混淆。简单来说，初始化是对象在创建时获得初始值的过程，而赋值是对象创建后改变其值的操作。这两者在C++中有着本质的区别，尤其是在性能和语义上。

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

构造函数：对象的“出生证明” 每个C++对象在创建时都会调用一个构造函数。这是我们控制对象初始状态的主要途径。
- 默认构造函数： 如果我们不提供任何构造函数，编译器会自动生成一个（如果可行）。但它只会对基类和非静态数据成员调用它们的默认构造函数，对于内置类型（如
```
int
```
  登录后复制
  ,
```
char*
```
  登录后复制
  ），它们将保持未初始化状态，这常常是bug的温床。
- 用户定义构造函数： 我们可以根据需要定义带参数的构造函数，以便在创建对象时传入特定的初始值。
- 拷贝构造函数与移动构造函数 (C++11)： 这两种特殊的构造函数分别用于从现有对象复制或“移动”资源来创建新对象。它们在处理动态内存或资源时尤为重要，确保资源管理正确。

成员初始化列表：效率与正确性的保证 这是C++初始化中最优雅也最容易被忽视的细节之一。我个人强烈推荐总是优先使用成员初始化列表。

为什么推荐？ 当我们有一个成员对象，比如
```
MyData data;
```
登录后复制
，如果在构造函数体内写
```
data = MyData(some_value);
```
登录后复制
，这实际上是先调用
```
MyData
```
登录后复制
的默认构造函数创建
```
data
```
登录后复制
，然后再调用
```
MyData
```
登录后复制
的赋值运算符对其进行赋值。而使用初始化列表
```
MyClass(int val) : data(val) {}
```
登录后复制
，则是直接调用
```
MyData
```
登录后复制
带参数的构造函数，一步到位，效率更高。
强制性要求： 对于
```
const
```
登录后复制
成员和引用成员，它们一旦被创建就不能被赋值，所以必须通过初始化列表来初始化。同样，对于那些没有默认构造函数的成员对象，初始化列表也是唯一的初始化方式。

示例：

#include <iostream>
#include <vector>

class ExpensiveResource {
public:
    ExpensiveResource() { std::cout << "ExpensiveResource default ctor" << std::endl; }
    ExpensiveResource(int val) { std::cout << "ExpensiveResource int ctor with " << val << std::endl; }
    ExpensiveResource& operator=(const ExpensiveResource& other) {
        std::cout << "ExpensiveResource assignment operator" << std::endl;
        return *this;
    }
};

class MyClass {
    const int id; // const 成员必须通过初始化列表初始化
    ExpensiveResource resource; // 成员对象
    int& ref_val; // 引用成员也必须通过初始化列表初始化
    int* raw_ptr; // 原始指针成员

public:
    // 推荐的做法：使用成员初始化列表
    MyClass(int _id, int res_val, int& r_val)
        : id(_id), resource(res_val), ref_val(r_val) // 这里是初始化
    {
        std::cout << "MyClass constructor (using initializer list)" << std::endl;
        raw_ptr = new int(100); // 这里是赋值，不是初始化
    }

    // 错误的或低效的做法（仅作对比，不推荐）
    // MyClass(int _id, int res_val, int& r_val) {
    //     // id = _id; // 编译错误：const成员不能赋值
    //     // resource = ExpensiveResource(res_val); // 先默认构造再赋值，效率低
    //     // ref_val = r_val; // 编译错误：引用不能重新绑定
    // }

    ~MyClass() {
        delete raw_ptr; // 记得释放动态分配的内存
        std::cout << "MyClass destructor" << std::endl;
    }
};

// int main() {
//     int some_int = 50;
//     MyClass obj(1, 20, some_int);
//     // 输出会清楚地展示初始化列表的调用顺序和效率
//     return 0;
// }

登录后复制

类内成员初始化 (In-class member initializers, C++11)： 这个特性允许我们在声明成员时直接给它们一个默认值。如果构造函数没有显式地初始化这个成员，就会使用这个默认值。这对于一些简单的、总是有默认值的成员来说，非常方便，能减少构造函数中的重复代码。

成员访问：与对象内部的互动

C知道

CSDN推出的一款AI技术问答工具

查看详情

对象初始化完成后，我们如何安全、有效地访问它的成员呢？这涉及到访问权限、运算符重载以及

const

登录后复制

正确性等概念。

访问修饰符：
```
public
```
登录后复制
,
private
登录后复制
,
protected
登录后复制
这是C++封装的核心。
- ```
public
```
  登录后复制
  ：对外开放的接口，任何代码都可以访问。
- ```
private
```
  登录后复制
  ：私有成员，只有类内部的成员函数和友元可以访问。这是实现细节，应该被隐藏起来。
- ```
protected
```
  登录后复制
  ：受保护成员，除了类内部，派生类的成员函数也可以访问。我个人觉得，好的面向对象设计，就是把尽可能多的成员设为
```
private
```
  登录后复制
  ，只通过
```
public
```
  登录后复制
  接口与外界交互。
点运算符
```
.
```
登录后复制
和箭头运算符
->
登录后复制
- ```
object.member
```
  登录后复制
  ：直接通过对象实例访问其成员。
- ```
pointer->member
```
  登录后复制
  ：通过指向对象的指针访问其成员。这等价于
```
(*pointer).member
```
  登录后复制
  。

const

登录后复制

成员函数：承诺不变 这是一个非常重要的概念，尤其是在设计API时。一个

const

登录后复制

成员函数承诺不会修改对象的状态。

语法：
```
void func() const;
```
登录后复制
意义： 如果你有一个
```
const
```
登录后复制
对象或
```
const
```
登录后复制
引用/指针指向一个对象，你只能调用它的
```
const
```
登录后复制
成员函数。这能有效防止意外修改数据，提高代码的健壮性和可读性。

示例：

class Point {
    int x_, y_;
public:
    Point(int x, int y) : x_(x), y_(y) {}
    void setX(int val) { x_ = val; } // 非const成员函数，可以修改x_
    int getX() const { return x_; } // const成员函数，不能修改对象状态
    // void badFunc() const { x_ = 10; } // 编译错误：const成员函数不能修改非mutable成员
};

// int main() {
//     const Point p(10, 20);
//     // p.setX(5); // 编译错误：不能对const对象调用非const成员函数
//     std::cout << p.getX() << std::endl; // OK
//     return 0;
// }

登录后复制

友元 (Friend)：打破封装的“特权”
```
friend
```
登录后复制
关键字允许非成员函数或另一个类访问当前类的私有和保护成员。这是一种打破封装的机制，通常用于运算符重载（如
```
operator<<
```
登录后复制
用于输出）或某些紧密协作的类。虽然它很有用，但我个人觉得应该谨慎使用，因为过度使用友元会削弱封装性，增加代码的耦合度。

C++中，为什么推荐使用成员初始化列表，而不是在构造函数体内赋值？它有哪些独特的优势？

在我看来，这是C++初学者最容易忽视，但也是最能体现C++“地道”写法的细节之一。推荐使用成员初始化列表，主要有以下几个不可替代的优势：

效率优势：避免不必要的构造与赋值 对于非基本类型（如自定义类、
```
std::string
```
登录后复制
、
```
std::vector
```
登录后复制
等）的成员，在构造函数体内赋值，其流程是：
- 先调用成员的默认构造函数（如果存在），创建成员对象。
- 然后调用成员的赋值运算符，将传入的值赋给它。这意味着进行了两次操作：一次构造，一次赋值。而使用成员初始化列表，则是直接调用成员的带参构造函数，一步到位地完成初始化。这对于开销大的对象（比如涉及动态内存分配的对象）来说，能显著提高效率。想象一下，一个大字符串先空构造再赋值，和直接构造传入值，哪个效率高一目了然。
强制性要求：
```
const
```
登录后复制
成员和引用成员 这是最关键的一点。
```
const
```
登录后复制
成员和引用成员在C++中一旦创建就必须被初始化，并且之后不能再被赋值或重新绑定。因此，它们无法在构造函数体内通过赋值操作获得初始值，只能通过成员初始化列表来完成。如果尝试在构造函数体内对它们进行赋值，编译器会直接报错。
```
class MyConfig {
    const int MAX_SIZE; // const成员
    std::string& name_ref; // 引用成员
public:
    // 必须使用初始化列表
    MyConfig(int size, std::string& name) : MAX_SIZE(size), name_ref(name) {
        // MAX_SIZE = size; // 编译错误
        // name_ref = name; // 编译错误
    }
};
```
登录后复制
处理没有默认构造函数的成员对象 如果一个成员类没有提供默认构造函数（即它只有带参数的构造函数），那么它就无法在构造函数体内被“默认