类与对象
掌握构造函数、初始化列表、this 与 const 成员函数
#class 与 struct 的唯一区别
C++ 里 class 和 struct 是同一种东西,唯一区别是默认访问权限:class 默认 private,struct 默认 public。除此之外它们能做的事完全相同(都能有成员函数、继承、虚函数)。社区惯例是:纯数据聚合用 struct,有行为和不变量约束的用 class。
访问控制有三档:public(任何人可访问)、private(只有本类的成员函数和友元可访问)、protected(本类及派生类可访问,见第 10 章)。这和 Java 的 public/private/protected 名字一样,但有个重要差别:C++ 的访问控制是"类级别"而不是"对象级别"——一个成员函数可以访问同类型的另一个对象的私有成员。Python 没有真正的私有,靠 _name 约定和 @property 模拟;JS 用 #field 语法才是真私有。
#include <iostream>
#include <string>
#include <utility> // std::move
class BankAccount {
public: // 从这里往下的成员对外可见
// 构造函数:与类同名,无返回类型
BankAccount(std::string owner, double balance)
: owner_(std::move(owner)), balance_(balance) // 初始化列表,见下一节
{
std::cout << "开户:" << owner_ << "\n";
}
// 成员函数定义在类内,自动成为 inline 候选
void deposit(double amount) {
if (amount > 0) {
balance_ += amount;
}
}
bool withdraw(double amount) {
if (amount > 0 && amount <= balance_) {
balance_ -= amount;
return true;
}
return false;
}
// 只读访问器:const 成员函数,见本章后文
double balance() const { return balance_; }
const std::string& owner() const { return owner_; }
private: // 从这里往下对外不可见,这是封装的保证
std::string owner_;
double balance_{0.0};
// 私有辅助函数,外部无法调用
bool is_valid(double amount) const {
return amount > 0 && amount <= balance_;
}
};
int main() {
BankAccount a("Alice", 1000.0); // 栈上创建对象,自动调用构造函数
a.deposit(500.0);
a.withdraw(200.0);
std::cout << a.owner() << " 余额 " << a.balance() << "\n";
// a.balance_ = 999999.0; // 编译错误:private 成员不可访问
// a.is_valid(1.0); // 编译错误:private 成员函数不可访问
return 0;
}注意这里用了 std::move,需要 #include <utility>。它的含义在第 5 章详细讲,现在只需知道它让 owner 的内容"搬进"成员而不是复制一份。
#构造函数与初始化列表
Python 的 __init__、Java 的构造器,对应的都是 C++ 的构造函数。但 C++ 有一个它们没有的东西:成员初始化列表(冒号后面那部分)。
关键区别:进入构造函数函数体之前,所有成员已经完成了初始化。如果你在函数体里写 owner_ = owner;,那不是初始化而是"先默认构造再赋值",对 std::string 这类类型意味着一次多余的构造 + 一次赋值。用初始化列表 owner_(owner) 则直接一步构造到位。更极端的情况:const 成员、引用成员、没有默认构造函数的成员,只能用初始化列表。
所以规则很简单:始终用初始化列表,且顺序与成员声明顺序一致(否则编译器会警告 -Wreorder)。
#include <iostream>
#include <string>
#include <utility>
class Person {
public:
// 1) 带参构造:初始化列表逐个初始化
Person(std::string name, int age)
: name_(std::move(name)), age_(age)
{
std::cout << "构造 " << name_ << "\n";
}
// 2) 委托构造(C++11):复用另一个构造函数,避免重复代码
Person() : Person("匿名", 0) {
std::cout << "默认构造完成\n";
}
// 3) 析构函数:对象销毁时自动调用,名字是 ~类名,无参数无返回值
~Person() {
std::cout << "析构 " << name_ << "\n";
}
void print() const {
std::cout << name_ << " " << age_ << " 岁\n";
}
private:
std::string name_;
int age_;
};
class Team {
public:
// const 成员和引用成员必须在初始化列表里初始化,函数体里赋值是非法的
Team(const std::string& name, int& external_counter)
: name_(name), counter_(external_counter)
{}
private:
const std::string name_; // const 成员
int& counter_; // 引用成员,必须绑定到已有对象
};
int main() {
{
Person p1("Alice", 30); // 进入作用域时构造
p1.print();
Person p2; // 委托到 Person("匿名", 0)
p2.print();
} // 离开作用域时按构造的逆序析构
int counter = 0;
Team t("Qt 小组", counter);
std::cout << "作用域结束\n";
return 0;
}上面花括号包起来的代码块演示了 C++ 最重要的特性之一:对象的生命周期绑定在作用域上,离开 } 自动析构。Python 靠引用计数(CPython 通常也是离开作用域即回收),Java/JS 靠 GC 在未来的不确定时刻回收;C++ 是确定的、可预测的。这个特性是第 5 章 RAII 的基石。
#this 指针与链式调用
Python 的实例方法第一个参数必须显式写 self,Java 和 C++ 则提供隐式的 this。但 C++ 的 this 是指针(Person* const),所以访问成员要写 this->name_ 而不是 this.name_。
this 的典型用途有两个:一是区分同名的成员变量和参数(this->name = name;);二是返回对象自身实现链式调用,类似 jQuery 或 Python 里每个方法都 return self 的 builder 模式。
#include <iostream>
#include <string>
#include <utility>
#include <vector>
class QueryBuilder {
public:
// 每个 setter 返回自身引用,支持 q.select("x").from("y") 这种链式写法
// 对比 Python:同样的模式需要每个方法 return self
QueryBuilder& select(const std::string& cols) {
if (!columns_.empty()) {
columns_ += ", ";
}
columns_ += cols;
return *this; // 解引用 this 得到对象本身
}
QueryBuilder& from(const std::string& table) {
table_ = table;
return *this;
}
QueryBuilder& where(const std::string& cond) {
conditions_.push_back(cond);
return *this;
}
// 用 this 区分参数与成员同名的情况
QueryBuilder& limit(int limit) {
this->limit_ = limit; // 左边是成员,右边是参数
return *this;
}
std::string build() const {
std::string sql = "SELECT " + (columns_.empty() ? std::string("*") : columns_)
+ " FROM " + table_;
for (const auto& c : conditions_) {
sql += " WHERE " + c;
}
if (limit_ > 0) {
sql += " LIMIT " + std::to_string(limit_);
}
return sql;
}
private:
std::string columns_;
std::string table_;
std::vector<std::string> conditions_;
int limit_{0};
};
int main() {
QueryBuilder q;
// 链式调用:每一步返回同一个对象的引用
std::string sql = q.select("id").select("name")
.from("users")
.where("age > 18")
.limit(10)
.build();
std::cout << sql << "\n";
// 也可以在堆上创建,但记得释放(第 6 章会用智能指针替代裸 new/delete)
auto* heap_q = new QueryBuilder();
std::cout << heap_q->from("logs").build() << "\n";
delete heap_q;
return 0;
}链式调用在 Qt 里非常常见(QSettings、QString 的部分 API),值得熟练。
#对象创建方式
C++ 有三种创建对象的方式,各自的生命周期截然不同:
- 栈对象:
Person p("Alice");—— 离开作用域自动析构,最安全、最快,是默认选择。 - 堆对象:
auto* p = new Person("Alice");—— 必须手动delete,忘了就泄漏,delete两次就崩溃。第 6 章的智能指针就是为了解决它。 - 临时对象:
Person("Alice")作为表达式的一部分 —— 当前语句结束后即销毁,常用于函数返回值和传参。
Java 里 new 是创建对象唯一的方式(一律在堆上);Python 里一切皆对象、全在堆上;而 C++ 的栈对象是常态,这也是它不需要 GC 还快的原因之一。
#static 成员
static 成员属于类本身而不是某个对象,所有实例共享同一份。这一点和 Java 的 static、Python 的类变量几乎一致。
细节差异在于:C++ 的 static 成员变量必须在类外单独定义一次(类内只是声明),否则链接期会报 undefined reference。C++17 引入 inline static 后可以直接在类内定义,是这个历史包袱的官方解法。另外 static 成员函数没有 this 指针,因此不能访问非静态成员——等价于 Python 的 @staticmethod(而 Python 的 @classmethod 更像能拿到类对象的东西,C++ 无直接对应)。
#include <iostream>
#include <string>
class User {
public:
User(std::string name) : name_(std::move(name)) {
++count_; // 构造函数里更新共享计数
id_ = ++next_id_;
}
~User() {
--count_;
}
// static 成员函数:属于类,可通过 User::alive() 调用,无 this 指针
static int alive() { return count_; }
// 工厂方法:static 函数可以创建对象,常用于"命名构造函数"
static User create_guest() {
return User("guest");
}
int id() const { return id_; }
const std::string& name() const { return name_; }
private:
std::string name_;
int id_{0};
// C++17 起可用 inline static 在类内直接定义并初始化
inline static int count_ = 0; // 当前存活对象数
inline static int next_id_ = 0; // 全局自增 ID
};
int main() {
std::cout << "初始存活数 " << User::alive() << "\n";
{
User a("Alice");
User b("Bob");
std::cout << "当前存活 " << User::alive() << "\n"; // 2
std::cout << "id: " << a.id() << ", " << b.id() << "\n";
}
std::cout << "离开作用域后存活 " << User::alive() << "\n"; // 0
User g = User::create_guest();
std::cout << g.name() << " id=" << g.id() << "\n";
return 0;
}#const 成员函数
把 const 写在成员函数参数列表之后,表示"这个函数不会修改对象"。这在其他语言里没有直接对应物——Python 靠约定,Java 靠 final 字段或不可变类设计,C++ 则是编译器强制检查。
它的价值非常大:一旦有了 const 成员函数,你就能把 const User& 参数传进函数并调用它的方法;否则 print(const User& u) { u.name(); } 会编译失败,因为编译器不敢保证 name() 不修改 u。
配套规则:能加 const 的成员函数就加。标准库容器就是这么做的(size()、begin() 都是 const 成员),你的类也应该如此。
#include <iostream>
#include <string>
#include <vector>
class Playlist {
public:
void add(const std::string& song) {
songs_.push_back(song); // 修改成员,不能是 const
}
// const 成员函数:承诺不修改对象,内部只能读成员
std::size_t size() const {
return songs_.size();
}
// 返回 const 引用,防止调用方绕过 const 直接改数据
const std::string& at(std::size_t i) const {
return songs_.at(i); // vector::at 带边界检查,越界抛异常
}
// 常量重载:同一个函数提供 const 与非 const 两个版本
// 非 const 版本返回可修改的引用
std::string& operator_at(std::size_t i) {
return songs_.at(i);
}
// const 对象只能调用 const 成员函数
void dump() const {
std::cout << "播放列表(" << size() << " 首):\n";
for (const auto& s : songs_) {
std::cout << " - " << s << "\n";
}
}
private:
std::vector<std::string> songs_;
};
// 参数写成 const 引用,函数内部只能调用 Playlist 的 const 成员函数
void show_summary(const Playlist& pl) {
std::cout << "共 " << pl.size() << " 首\n";
pl.dump(); // OK:dump 是 const 成员
// pl.add("新歌"); // 编译错误:const 对象不能调用非 const 成员
}
int main() {
Playlist pl;
pl.add("Yesterday");
pl.add("Let It Be");
show_summary(pl);
const Playlist frozen; // const 对象
// frozen.add("x"); // 编译错误,const 对象只能调 const 成员
std::cout << "frozen 大小 " << frozen.size() << "\n";
return 0;
}顺带一提 mutable 关键字:被它修饰的成员即使在 const 成员函数里也能被修改,常用于缓存、互斥锁这类"逻辑上不改变对象状态"的场景。日常代码里用得不多,但看到时要认识。
#小结
class与struct仅默认访问权限不同(privatevspublic);C++ 的访问控制是类级别的,可访问同类其他对象的私有成员。- 成员初始化列表在构造函数体之前执行,效率更高,且是
const成员、引用成员、无默认构造成员的唯一初始化方式;初始化顺序按成员声明顺序。 - 对象生命周期绑定作用域:进入构造、离开析构,时机确定,这是与 GC 语言最大的区别,也是 RAII 的基础。
this是指针(this->name_),典型用途是区分同名参数和支持返回*this的链式调用。static成员属于类而非对象;C++17 用inline static可直接在类内定义;static 成员函数没有this,不能访问非静态成员。const成员函数承诺不修改对象,是编译器级别的强制约束;能加就加,否则const引用参数将无法调用你的方法。
#练习
- 实现
class Rectangle,含私有成员width_、height_,提供构造函数、area()、perimeter()(const成员函数)和resize(w, h)。验证把Rectangle以const Rectangle&传给函数时只能调用前两个。 - 给
Rectangle加一个inline static int count_,在构造时++、析构时--,写一个static int alive(),在main里用作用域验证计数变化。 - 写一个
Logger类,支持链式调用:logger.level(2).tag("db").message("连接失败").flush()。要求每个方法返回Logger&。 - 定义一个含
const std::string name_成员的类,尝试在构造函数函数体里给它赋值,观察编译错误;再改用初始化列表确认可以通过。最后设计Temperature类(内部存摄氏度,提供celsius()/fahrenheit()/kelvin()三个const访问器和set_celsius()),体会读写接口的划分。