共计 2258 个字符，预计需要花费 6 分钟才能阅读完成。

1. 典型错误案例：为什么我的成员函数调用失败了？

最近在辅导新人时，发现两个高频出现的编译错误：

class Calculator {
public:
    int add(int a, int b) {return a + b;}
};

// 错误示例 1：未实例化直接调用
Calculator::add(1, 2); // 报错：非静态成员引用必须与特定对象相对

// 错误示例 2：this 指针误用
class Student {void printName() {cout << this->name; // 运行时崩溃：this 是 nullptr}
};
Student* s = nullptr;
s->printName();

这两个案例揭示了成员函数调用的核心机制：成员函数必须通过对象实例调用 （静态成员除外），且函数内部通过隐式的this 指针访问成员数据。接下来我们分层次解析调用规则。

2. 成员函数调用三大层次

2.1 基础篇：类内外的调用语法

类内部调用

在类的其他成员函数中调用同类成员函数，直接使用函数名即可（编译器会自动加上this->）：

class Printer {
public:
    void printHeader() {cout << "====== Header ======" << endl;}

    void printContent() {printHeader(); // 等价于 this->printHeader()
        cout << "Main content here" << endl;
    }
};

类外部调用

需要通过对象实例或指针，使用 . 或->操作符：

// Header 文件 Printer.h
class Printer {
public:
    void printHeader();
    void printContent();};

// Source 文件 Printer.cpp
#include "Printer.h"
void Printer::printHeader() { /*...*/} // 注意类名限定符::

// 调用示例
int main() {
    Printer p;
    p.printContent();    // 对象实例调用

    Printer* ptr = &p;
    ptr->printHeader();  // 对象指针调用}

2.2 进阶篇：const 成员函数的互调规则

const 成员函数（函数声明尾部带 const）承诺不修改对象状态，调用规则如下：

class BankAccount {
    double balance;
public:
    // const 成员函数
    double getBalance() const {return balance;}

    // 非 const 成员函数
    void withdraw(double amount) {
        balance -= amount;
        // getBalance(); // 允许：const 函数可被非 const 函数调用}

    void display() const {// withdraw(10); // 编译错误！const 函数不能调用非 const 函数
        cout << getBalance();}
};

黄金法则：const 成员函数只能调用其他 const 成员函数，而非 const 成员函数可以调用所有成员函数。

2.3 高级篇：静态成员函数的特性

静态成员函数属于类而非对象，因此：
– 没有 this 指针
– 只能访问静态成员变量
– 可通过类名直接调用

class SystemConfig {
    static string version;
    int instanceID; // 非静态成员
public:
    static string getVersion() {
        // cout << instanceID; // 错误：不能访问非静态成员
        return version;
    }
};

string SystemConfig::version = "1.0";

// 调用方式
int main() {SystemConfig::getVersion(); // 合法
    SystemConfig cfg;
    cfg.getVersion();         // 合法但不推荐}

3. 避坑指南

3.1 对象生命周期陷阱

class TempObject {
public:
    int& getRef() { return value;}
private:
    int value = 42;
};

int& dangerCall() {
    TempObject tmp;
    return tmp.getRef(); // 返回局部对象的引用！} // tmp 被销毁，返回的引用悬垂

解决方案：
– 返回拷贝而非引用
– 延长对象生命周期（如改为静态存储）

3.2 多线程安全问题

class Counter {
    int count = 0;
public:
    void increment() {++count; // 非原子操作，线程不安全}
};

防护措施：
– 对共享数据加锁（mutex）
– 使用原子类型（atomic）
– 避免在成员函数中暴露内部状态引用

4. 思考题

1. 线程安全设计 ：如何通过互斥锁（mutex）改造 Counter 类的 increment() 函数？
2. 静态函数选择 ：日志记录器的 writeLog() 方法是否应该声明为 static？为什么？
3. const 限制原理：从 C ++ 对象内存模型的角度，解释为什么 const 对象不能调用非 const 成员函数？

5. 总结

理解成员函数调用机制的关键在于把握三个维度：
1. 访问路径：通过对象实例（. / ->）还是类名（::）
2. 权限控制：public/protected/private 的作用域限制
3. 函数性质：const 修饰符和 static 修饰符带来的语义约束

建议在编码时保持风格一致：静态函数始终通过类名调用，const 正确性检查开启编译警告（-Werror=const），这是提升代码健壮性的有效手段。