QC++ / Qt 学习之路

类与对象

掌握构造函数、初始化列表、this 与 const 成员函数

入门第 4 / 48 章第一篇 · C++ 基础巩固

#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 语法才是真私有。

C++
#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)。

C++
#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 模式。

C++
#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++ 无直接对应)。

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 成员),你的类也应该如此。

C++
#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 成员函数里也能被修改,常用于缓存、互斥锁这类"逻辑上不改变对象状态"的场景。日常代码里用得不多,但看到时要认识。

#小结

  1. class 与 struct 仅默认访问权限不同(private vs public);C++ 的访问控制是类级别的,可访问同类其他对象的私有成员。
  2. 成员初始化列表在构造函数体之前执行,效率更高,且是 const 成员、引用成员、无默认构造成员的唯一初始化方式;初始化顺序按成员声明顺序。
  3. 对象生命周期绑定作用域:进入构造、离开析构,时机确定,这是与 GC 语言最大的区别,也是 RAII 的基础。
  4. this 是指针(this->name_),典型用途是区分同名参数和支持返回 *this 的链式调用。
  5. static 成员属于类而非对象;C++17 用 inline static 可直接在类内定义;static 成员函数没有 this,不能访问非静态成员。
  6. const 成员函数承诺不修改对象,是编译器级别的强制约束;能加就加,否则 const 引用参数将无法调用你的方法。

#练习

  1. 实现 class Rectangle,含私有成员 width_、height_,提供构造函数、area()、perimeter()(const 成员函数)和 resize(w, h)。验证把 Rectangle 以 const Rectangle& 传给函数时只能调用前两个。
  2. 给 Rectangle 加一个 inline static int count_,在构造时 ++、析构时 --,写一个 static int alive(),在 main 里用作用域验证计数变化。
  3. 写一个 Logger 类,支持链式调用:logger.level(2).tag("db").message("连接失败").flush()。要求每个方法返回 Logger&。
  4. 定义一个含 const std::string name_ 成员的类,尝试在构造函数函数体里给它赋值,观察编译错误;再改用初始化列表确认可以通过。最后设计 Temperature 类(内部存摄氏度,提供 celsius()/fahrenheit()/kelvin() 三个 const 访问器和 set_celsius()),体会读写接口的划分。
我的学习笔记笔记总览
笔记保存在本机浏览器(localStorage),换设备或清理缓存会丢失;重要内容请点「导出全部笔记」存成 .md 文件。