面向对象 on Mao's Blog

5-Implementations

Thu, 21 May 2026 10:32:00 +0800

上一章讲的是接口设计的原则，而这一章关注具体的实现细节。

Item26: Postpone variable definitions as long as possible

本节告诉我们，尽可能推迟变量的定义位置。换言之，在程序逻辑不变的情况下，越晚定义变量越好。

为什么？考虑到两个问题：

开销问题：变量定义太早，而程序由于某种原因没有继续执行（比如抛出异常）导致该变量未被使用，那么变量定义时调用构造函数的开销，相当于白费了。
代码风格：如果析构的位置不变，那么变量定义得越早，它的生命周期就越长，影响的代码范围就越广。而 coding 的一大原则就是“解耦”，尽可能减少每个部分对其他部分的影响。

所以说，只有在你马上需要用到这个变量的时候，才去定义它，而不是提早定义。

并且，最好在定义时就直接做完初始化的工作（开销更小），而不是先定义再赋值（开销更大）

前者在构造时只需要调用一次对应的 constructor
后者要调用 default constructor 和 copy assignment operator

作者的原话如下：

“Not only should you postpone a variable’s definition until right before you have to use the variable, you should also try to postpone the definition until you have initialization arguments for it.” (Dulimov, p. 115)

意思是一定要“忍到”你能够初始化（initialization）这个变量之后，你再去定义（definition）它。一定要将两者绑定，才能实现性能和资源利用最大化。

那么有人问了：如果在循环中需要使用某个变量，是在循环外部定义之后再在循环内部赋值好（方案 A），还是直接在循环内部构造好（方案 B）。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


// Approach A
Widget w;
for (int i = 0; i < n; i++) {
 w = some value dependent on i;
}

// Approach B
for (int i = 0; i < n; i++) {
 Widget w(some value dependent on i);
}

可以看下两种方案各自的开销：

4-Designs and Declarations

Sat, 09 May 2026 20:39:00 +0800

本章将介绍设计和声明 C++ 接口的一些原则。

Item18: Make interfaces easy to use correctly and hard to use incorrectly

核心思想：

好的接口应该引导正确使用，阻止错误使用。如果用户用错了，编译器应该报错，而不是运行时才发现 bug。

所以，我们在设计接口的时候，最好多问自己一个问题：

如果别人用我的接口，最可能的几种用错方式是什么？我能不能在编译期就拦住，从而让用户正确地使用接口？

具体来说，主要有下面四个点需要检查：

参数顺序容易搞混吗？ -> 用类型区分
参数有合法范围吗？ -> 用 enum 或者 enum class 限定范围
行为和内置类型一致吗？ -> 该 const 就 const，该重载运算符就重载
涉及资源管理吗？ -> 返回智能指针，不要返回裸指针

参数顺序容易搞混吗？

比如说，我有一个 Date 类，它的构造函数需要三个参数：month-day-year。如果我全都定义成 int 类型，那么在传错顺序时很难检查出来。

所以，我可以自定义新的三个类：Month、Day 和 Year。

1
2
3
4
5
6
7
8


// 危险：三个 int，顺序很容易传反
Date(int month, int day, int year);

// 改进：用类型区分
struct Month { explicit Month(int m); };
struct Day { explicit Day(int d); };
struct Year { explicit Year(int y); };
Date(const Month& m, const Day& d, const Year& y);

这样，就可以轻松区分下面三种情况，用户很难传错参数：

2-Constructors, Destructors, and Assignment Operators

Tue, 28 Apr 2026 12:26:00 +0800

构造函数、析构函数、赋值运算符，可以说是一个对象最重要的三个成员函数，它们分别掌管成员变量的出生、死亡以及变化。

Item5: Know what functions C++ silently writes and calls

虽然我们只是创建一个空类，没有写任何的函数，但是，编译器还是会默认声明一些特殊的成员函数。具体来说，包括：

函数	说明
默认构造函数	`Empty() = default;`
析构函数	`~Empty() = default;`
拷贝构造函数	`Empty(const Empty&) = default;`
拷贝赋值运算符	`Empty& operator=(const Empty&) = default;`
移动构造函数	`Empty(Empty&&) = default;`
移动赋值运算符	`Empty& operator=(Empty&&) = default;`

【补充知识】五法则：

除了默认构造函数之外，剩下的五个特殊的成员函数，如果我们手动定义了其中一个，剩下的四个就都不会被编译器自动生成。这是因为，一旦我们需要手动定义这五个函数中的一个，就说明存在需要手动释放的资源（比如 new 出的内存、打开的文件、拿到的锁等等）。既然有资源需要手动释放，那么默认的拷贝（浅拷贝）一定会出问题——两个对象会持有同一份资源，析构时双重释放。

这个规则被称为“五法则”，其逻辑链是：需要自定义某个函数 → 说明持有资源 → 拷贝/移动不能信任默认实现 → 五个都要自定义

回到正题。比如说，我们定义：

1

class Empty{};

但实际上，编译器生成的等价于：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


// 编译器实际生成的等价于
class Empty {
public:
 Empty() = default;
 ~Empty() = default;
 Empty(const Empty&) = default;
 Empty& operator=(const Empty&) = default;
 Empty(Empty&&) = default;
 Empty& operator=(Empty&&) = default;
};

这些函数都是 public 并且 inline 的，且只有它们在被实际调用的时候，编译器才会真正生成它们的定义（不是在声明时就生成）。

C++类型转换符

Tue, 21 Oct 2025 08:28:49 +0800

我们开始今天的 C++ 八股环节！

今天，我们来聊一个在面试中经常被用来考察你对 C++ 基础和面向对象理解的话题：static_cast, dynamic_cast, const_cast, reinterpret_cast。

这四个是 C++ 的标准类型转换操作符。相比于 C 风格的强制转换（如 (int)x），它们更安全、意图也更明确。

`static_cast` 转换符

模拟面试开始

面试官： 在 C++ 中，我们有四种“具名”的类型转换符，统称为 static_cast 系列。我们先来聊聊最常用的一个：static_cast。

请问，static_cast 主要用于什么样的转换场景？它和 C 风格的强制转换 (new_type)expression 相比，有什么主要的优势？

回答：

static_cast 是 C++ 中最基础和最简单的类型转换，主要有以下的应用场景：
- 相关类型之间的转换，如数值类型之间、枚举类型和整数之间、void* 类型和其他指针类型之间。
- 有继承关系的类指针/引用转换（不涉及多态的情况）。这里，将派生类指针或引用，转为基类的指针或引用（也就是上行转换）是安全的；反之，将基类的指针或者引用，转为派生类的指针或者引用（也就是下行转换）是不安全的。
和 (new_type)expression 相比，static_cast 的转换意图更明确（从命名就可以看出），以及转换过程更安全（会检查变量类型之间是否可以安全转换）

面试官 (总结与补充): 你说的完全正确。

static_cast 是 C++ 中最基础、最常用的“良性”转换。

主要应用场景：

相关类型之间的转换：
- 数值类型转换：在各种数值类型之间进行转换，比如 int -> double, double -> int。
  1 2
  
  double d = 3.14; int i = static_cast<int>(d); // i = 3
- 枚举与整数转换：在枚举类型和整数类型之间进行转换。
  1 2 3
  
  enum Color { RED }; int c_val = static_cast<int>(RED); Color c = static_cast<Color>(0);
- void 指针转换*：将 void* 指针转换为具体的类型指针。
  1 2
  
  void* p = &i; int* pi = static_cast<int*>(p);
有继承关系的类指针/引用转换 (不涉及多态)：

default和delete

Thu, 16 Oct 2025 09:05:16 +0800

`default` 关键字强制生成默认构造函数

模拟面试开始

面试官： 我们知道，如果一个类我们不给它定义任何构造函数，编译器会自动为我们生成一个默认构造函数。类似的，编译器也可能会为我们生成拷贝构造函数、拷贝赋值运算符等。

在 C++11 之后，如果我们想显式地告诉编译器：“请为我生成一个默认的、最普通的版本”，我们可以使用 default 关键字。

请看下面这个例子：

1
2
3
4
5
6
7
8
9


class MyClass {
public:
 MyClass() = default; // 显式地要求编译器生成默认构造函数

 MyClass(int val) : data(val) {} // 用户自定义了别的构造函数

private:
 int data;
};

我的问题是： 在这个例子中，MyClass() = default; 这一行代码，有什么实际意义？

换句话说，如果我们删掉 MyClass() = default; 这一行，会发生什么变化？这个类还能通过 MyClass obj; 这种方式创建对象吗？为什么？

回答：

当用户自己定义了一种构造函数时，编译器就不会自动生成默认的无参数的构造函数。
MyClass() = default; 确保无参数的构造函数存在。
如果删去这一行，那么 MyClass 这个类就无法通过 MyClass obj; 这种方式创建对象，因为编译器检测不到对应的构造函数。
而增加上这一行，可以使得程序可以在无参数的情况下创建新的对象，等到对其内容有要求时，再做修改。

面试官 (总结与肯定): 你说的没错。这个问题的核心在于 C++ 的一条规则：

一旦用户为类定义了任何一种构造函数（无论带不带参数），编译器就会“罢工”，不再自动生成默认（无参）构造函数。

所以，在你给出的例子中：

因为你已经定义了一个 MyClass(int val)，编译器就不会再自动生成 MyClass() 了。
如果我们删掉 MyClass() = default; 这一行，那么 MyClass 类就没有无参构造函数。此时，MyClass obj; 这样的代码就会编译失败，因为它找不到匹配的构造函数。

= default 的作用： MyClass() = default; 这一行，就是你（程序员）在向编译器明确地下指令：

虚析构函数

Mon, 13 Oct 2025 23:10:06 +0800

不使用虚析构函数，可能导致资源泄漏

面试官： 我们知道，析构函数是在对象生命周期结束时，用于清理资源的特殊成员函数。在 C++ 的继承体系中，我们有时需要把基类的析构函数声明为虚函数 (virtual)。

请看下面这段代码，它可能会导致一个非常严重的问题：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


#include <iostream>

class Base {
public:
 Base() { std::cout << "Base Created\n"; }
 // 注意：析构函数不是虚函数
 ~Base() { std::cout << "Base Destroyed\n"; }
};

class Derived : public Base {
public:
 Derived() { std::cout << "Derived Created\n"; }
 ~Derived() { std::cout << "Derived Destroyed\n"; }
};

int main() {
 Base* p = new Derived(); // 基类指针指向派生类对象

 delete p; // 问题就出在这里！

 return 0;
}

我的问题是：

你预测一下，上面这段代码的输出会是什么？
这个输出结果揭示了什么样的严重问题？
这个问题的根本原因是什么？（即，delete p; 这行代码，编译器是如何决定调用哪个析构函数的？）

回答：

委托构造函数

Sat, 20 Sep 2025 09:59:58 +0800

委托构造函数 Delegating Constructors

面试官： 在 C++ 中，我们经常会为一个类提供多个构造函数，以方便使用者用不同的方式来初始化对象。

请看下面这个 C++03 风格的例子：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


#include <string>
#include <iostream>

class MyData {
private:
 int a;
 double b;
 std::string c;

public:
 // 构造函数 1
 MyData() {
 a = 0;
 b = 0.0;
 c = "default";
 // 假设还有一些其他的通用初始化逻辑
 std::cout << "Common logic executed.\n";
 }

 // 构造函数 2
 MyData(int val_a) {
 a = val_a;
 b = 0.0;
 c = "default";
 // 同样的通用初始化逻辑
 std::cout << "Common logic executed.\n";
 }

 // 构造函数 3
 MyData(int val_a, double val_b) {
 a = val_a;
 b = val_b;
 c = "default";
 // 又是同样的通用初始化逻辑
 std::cout << "Common logic executed.\n";
 }
};

你可以看到，这三个构造函数中，有很多重复的代码（比如对 b, c 的初始化，以及那个通用的逻辑）。在 C++11 之前，处理这种代码重复是一个比较头疼的问题。

Cpp的三五零法则

Fri, 12 Sep 2025 08:50:48 +0800

三法则 The Rule Of Three

面试官： 在 C++ 编程中，我们经常听到一个叫做 “三法则 (The Rule of Three)” 的设计原则。你能用自己的话解释一下，这个“三法则”指的是什么吗？它规定了如果一个类定义了哪三个特殊的成员函数之一，那么它可能也需要定义另外两个？

回答：

“三法则”指的是，C++编程中，如果一个类中定义了下面三个成员函数之一，那么另外两个成员函数也需要程序员手动定义：
- 析构函数
- 拷贝构造函数
- 拷贝赋值运算符

这三者是一个紧密相关的整体，要么同时提供，要么同时不提供。

面试官 (追问): 很好，你知道是哪三个函数。那你能进一步解释一下，这个法则背后的根本原因是什么吗？

换句话说，为什么一个类只要自己定义了析构函数（比如，为了 delete 一个裸指针成员），就很可能也需要自己定义拷贝构造函数和拷贝赋值运算符？编译器自动生成的版本，在这种情况下会有什么问题？

回答：

当我们只定义这三个成员函数中的某一个时，剩下两个函数由编译器自动生成，而编译器生成的版本和程序员定义的版本可能存在冲突，导致一些 tricky 的错误。
不过，具体的错误和原因我也说不上来，请你补充。

面试官 (补充与解释): 这个问题的根本原因在于，一个类需要手动定义析构函数，几乎总是出于同一个目的：这个类在手动管理某种资源。

最典型的资源就是裸指针指向的堆内存。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


class MyString {
private:
 char* data_; // 手动管理的裸指针
 size_t size_;

public:
 // 构造函数，分配资源
 MyString(const char* s = "") {
 size_ = strlen(s);
 data_ = new char[size_ + 1];
 strcpy(data_, s);
 }

 // 1. 我们必须手动定义析构函数，来释放资源
 ~MyString() {
 delete[] data_;
 }

 // 2. 但是，我们忘记定义拷贝构造函数...
 // 3. 也忘记定义拷贝赋值运算符...
};

现在，我们来看看编译器自动生成的拷贝函数会有什么问题：

构造函数相关知识

Sun, 07 Sep 2025 21:25:43 +0800

如果没有定义构造函数——默认构造函数

面试官： 好的，我们来聊聊 C++ 的一个核心特性——构造函数 (Constructor)。

我们知道，构造函数是在创建对象时被自动调用的一个特殊函数。除了我们最常见的、带参数的普通构造函数之外，C++ 编译器在某些情况下，还会为我们自动生成一些特殊的构造函数。

我的第一个问题是：如果我们在类中没有定义任何构造函数，编译器会为我们自动生成一个什么样的构造函数？它的作用是什么？

回答：我不太了解这个问题，所以凭感觉回答，请你为我补充。

编译器自动为我们生成的构造函数不会初始化任何的成员变量，所有的成员变量都处于原始状态。
它的作用是保证对象能够生成，而不会导致报错，起到占位的作用。

面试官 (补充与解释): 你说得基本正确。如果我们在类中没有定义任何构造函数，编译器会为我们生成一个默认构造函数 (Default Constructor)。这是一个无参数的构造函数。

这个自动生成的默认构造函数，它会做什么？

它的行为比我们想象的要“智能”一点，它遵循一个规则：

对于类类型的成员 (Class-type Members)：如果这个类成员有自己的默认构造函数，那么编译器生成的默认构造函数就会自动调用这个成员的默认构造函数。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


class Engine {
public:
 Engine() { std::cout << "Engine constructed\n"; }
};

class Car {
public:
 // 没有定义任何构造函数
private:
 Engine engine_; // 类类型成员
};

// 当你创建 Car c; 时，
// Car 的合成默认构造函数会被调用，
// 它会自动调用 Engine 的默认构造函数，
// 所以你会看到 "Engine constructed" 输出。

对于内置类型的成员 (Built-in Type Members, e.g., int, double, 指针)：

final和override关键字

Sun, 07 Sep 2025 08:53:49 +0800

关键字 `override`

没有 `override` 时存在的风险

面试官： 在 C++11 之后，我们在处理类的继承和虚函数时，多了 override 和 final 这两个说明符。我们先来聊聊 override。

请看下面这段代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


class Base {
public:
 virtual void doSomething(int param) { /* ... */ }
};

class Derived : public Base {
public:
 // 这里有一个小小的笔误，程序员将int写成了long
 virtual void doSomething(long param) { /* ... */ }
};

在 Derived 类中，程序员的意图是重写 (override) 基类的 doSomething 函数。但由于笔误，他把参数类型从 int 写成了 long。

请问，在没有 override 关键字的情况下，这段代码能编译通过吗？如果能，它在多态调用时，可能会产生什么样的问题？

回答：

我认为编译能够通过。由于参数列表不同（这里是参数类型不同），编译器会认为程序员在 Derived 类中重载了一个虚函数。
可能的问题：在多态调用时，会出现函数参数实际类型不一致的情况，可能导致冲突。

面试官 (补充与解释): 你说的很对。我们来把这个问题分析得更透彻一些。

函数重载和函数重写

Sat, 06 Sep 2025 09:28:27 +0800

昨天我们聊了虚函数和多态的实现，今天我们来聊一个与它紧密相关，但在概念上又容易混淆的话题：重载 (Overloading)、重写 (Overriding) 和隐藏 (Hiding)。

这三个术语描述了 C++ 中函数名相同但行为不同的几种情况，是面试中考察“你是否能精确理解 C++ 概念”的经典问题。

Overloading 和 Overriding 的区别

面试官： 在 C++ 中，我们经常会遇到函数名相同的情况。你能用自己的话分别解释一下，什么是函数重载 (Overloading) 和函数重写 (Overriding) 吗？它们两者最主要的区别是什么？

回答：Overloading 指的是两个函数同名，但是参数列表不同的情况。

Overriding 指的是两个函数同名、参数也相同（更准确地说，函数签名完全相同），但是一个在派生类中，另一个在基类中的情况。

我认为它们的主要区别是“参数是否相同”，以及“两者之间的关系是并列（Overloading）还是继承（Overriding）”。

你的回答非常出色！直截了当，并且准确地抓住了两者最核心的区别。

重载 (Overloading): 关键在于参数列表不同 (参数个数、类型、顺序)。
重写 (Overriding): 关键在于继承关系，并且函数签名 (signature) 必须完全相同 (函数名、参数列表、const 属性等都相同)。

你的总结“关系是并列还是继承”也非常形象。重载的函数之间是“兄弟”关系，而重写的函数之间是“父子”关系。

确定多态的时机——编译器？运行期？

面试官 (补充与追问): 你说得很好。我们来把这个概念再深化一下。

重载和重写，它们分别是在哪个阶段被决定的？一个是在编译期 (Compile-time)，一个是在运行期 (Run-time)。你觉得哪个对应哪个？为什么？

这可以帮助我们理解它们更深层次的机制差异。

回答：我认为，Overloading 属于静态多态，在编译期就被确定了，因为具有 overloading 关系的两个函数只有名字相同，而函数签名不同，事实上可以被看作两个不同函数，这使得编译器可以分辨他们。（编译器在处理函数调用时，会根据传入的实参类型、数量和顺序，查找应该匹配的函数，这个过程被叫做“名字修饰”）

而对于 overriding 属于动态多态，需要在运行期才能被确定，这和我们昨天讨论的虚函数与多态相关，程序必须通过 v-ptr 和 v-table 才能确定我们调用的到底是哪一个函数。‘

面试官 (总结与肯定): 你说得对极了。

重载 (Overloading) 属于静态多态，是在编译期决定的。
- 编译器在处理函数调用时，会根据你传入的实参类型、数量和顺序，像查字典一样，去查找应该匹配哪个版本的同名函数。这个过程叫做名字修饰 (Name Mangling) 或名称改编。编译器会给每个重载函数一个独特的内部名称，所以对编译器来说，它们就是不同的函数。这个决策过程完全不需要等到程序运行。
重写 (Overriding) 属于动态多态，是在运行期决定的。

面向对象与多态

Sat, 06 Sep 2025 09:28:10 +0800

什么是多态？实现技术是什么？

看到你的简历上写着熟悉 C++ 的面向对象编程。那你能用自己的话简单解释一下，什么是多态吗？在 C++ 中，我们通常通过什么关键技术来实现多态？

我理解的多态，就是同一个函数在不同的继承类中可以有不同的内容，这取决于子类自己的实现方式。（更精炼的表达：同一个接口，不同的实现。）

实现多态的关键技术通常是虚函数 (virtual function)，即基类中声明的函数，在派生类中可以有自己另外的实现 (override)，从而适配每个派生类的具体情况。（如果基类中没有对这一函数的实现，全部靠派生类自己实现，那么这种函数就是纯虚函数）

用基类指针指向派生类对象

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


class Animal {
public:
 // 这是一个普通的虚函数，它有自己的实现
 virtual void makeSound() {
 std::cout << "Some generic animal sound" << std::endl;
 }
};

class Dog : public Animal {
public:
 // Dog 类重写(override)了父类的虚函数
 void makeSound() override {
 std::cout << "Woof!" << std::endl;
 }
};

1
2


Animal* pAnimal = new Dog(); // 用基类指针指向派生类对象
pAnimal->makeSound(); // 请问，这里会输出什么？

如果用基类指针指向派生类对象，并调用函数，那么这个函数应该是派生类中覆写后的版本，而不是基类中的版本。

即：输出结果取决于指针实际指向的对象的类型（动态类型），而不是指针变量本身声明的类型（静态类型）。

C++如何保证能调用正确的函数呢？这一点我只是依稀记得和 v-table 还有 v-ptr 相关，具体内容不记得了。

C++的三种访问权限修饰符

Sat, 06 Sep 2025 09:21:34 +0800

成员访问的三种权限

面试官： 在 C++ 的类（class）定义中，我们有 public, protected, 和 private 这三个关键字来控制成员的访问权限。

你能简单解释一下，这三种权限分别意味着什么吗？也就是说，什么样的代码可以访问被它们修饰的成员？

回答：

public 修饰的成员，可以被该类的对象、该类的子类成员，以及该类的其他成员访问。（最宽松）
private 修饰的成员，只能被该类的其他成员访问，而不能被对象和子类成员访问。（最严格）
protected 修饰的成员，可以被该类的其他成员和子类的成员访问，但不能被该类的对象访问。（介于 public 和 private 之间）

Gemini 更好的概括：

public: 类内、子类、类外（通过对象）都能访问。权限最开放。
private: 仅限类内访问。权限最严格，实现了完全的封装。
protected: 类内、子类可以访问，但类外不行。权限介于两者之间，专门为继承体系设计。

类继承的三种权限

面试官 (深入提问): 好的，你对成员访问权限很清楚。现在我们把这个概念和继承结合起来。

C++ 中，继承也有三种方式：public 继承、protected 继承和 private 继承。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


class Base {
public:
 int public_member;
protected:
 int protected_member;
private:
 int private_member;
};

class Derived_Public : public Base { ... };
class Derived_Protected : protected Base { ... };
class Derived_Private : private Base { ... };

请问，这三种不同的继承方式，会如何影响基类 (Base) 的成员在派生类 (Derived) 中的访问权限？

explicit关键字

Sat, 12 Jul 2025 10:35:00 +0000

好的，我们来深入解析 explicit 这个虽小但非常重要的关键字。

你的理解完全正确！explicit 关键字就像一个“门卫”，它守在你的构造函数门口，防止一些“不请自来”的隐式类型转换，从而让代码的行为更加清晰、可控。

一、问题根源：什么是构造函数的“隐式转换”？

在 C++ 中，编译器有时候会“自作主张”地帮你进行类型转换，让代码能够通过编译。如果一个类的构造函数可以只用一个参数来调用，那么这个构造函数就可能被编译器用来进行隐式转换 (Implicit Conversion)。

让我们来看一个没有 explicit 的“事故现场”：

场景设定：我们有一个字符串类 MyString，它有一个构造函数，可以接受一个整数 n 来创建一个由 n 个 'A' 组成的字符串。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


#include <iostream>
#include <string>

class MyString {
private:
 std::string m_str;
public:
 // 这个构造函数可以用一个 int 参数来调用
 MyString(int n) : m_str(n, 'A') {
 std::cout << "MyString(" << n << ") 被调用了！\n";
 }

 const char* c_str() const { return m_str.c_str(); }
};

// 这是一个希望接收 MyString 对象的函数
void printString(const MyString& s) {
 std::cout << "打印: " << s.c_str() << std::endl;
}

现在，在 main 函数中，我们可能会写出这样的代码：