C++类成员函数调用机制解析：从基础到实战避坑指南

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

从两个经典错误案例说起

刚学 C ++ 面向对象时，我经常遇到这样的报错：

// 错误案例 1：忘记实例化直接调用
class Calculator {
public:
    int add(int a, int b) {return a + b;}
};

int main() {add(1, 2); // 编译错误：'add' was not declared
}

// 错误案例 2：this 指针误用
class Student {
    int score;
public:
    void setScore(int s) {
        score = s;       // 正确：等价于 this->score = s
        this = nullptr;  // 编译错误：lvalue required
    }
};

一、成员函数调用基础篇

1.1 类内调用成员函数

在类内部调用其他成员函数时，编译器会自动处理 this 指针传递：

class Printer {
public:
    void printHeader() { cout << "======HEADER======" << endl;}
    void printContent() {printHeader();  // 类内隐式调用，等价于 this->printHeader()
        cout << "Main content here" << endl;
    }
};

1.2 类外调用成员函数

必须通过对象实例或指针来调用（静态成员除外）：

// 继续使用上面的 Printer 类
int main() {
    Printer p;
    p.printContent();   // 正确：通过对象实例调用

    Printer *ptr = &p;
    ptr->printHeader(); // 正确：通过指针调用

    Printer::printContent(); // 错误：非静态成员必须用对象调用}

二、进阶：const 成员函数的互调规则

2.1 const 成员函数特性

class BankAccount {
    double balance;
public:
    // const 成员函数：承诺不修改成员变量
    double getBalance() const {return balance; // 可以读取但不能修改 balance}

    // 普通成员函数
    void deposit(double amount) {balance += amount;}
};

2.2 调用规则

void test() {
    const BankAccount acc; // const 对象
    acc.getBalance();      // 正确：const 对象调用 const 方法
    acc.deposit(100);      // 错误：const 对象不能调用非 const 方法

    BankAccount nonConstAcc;
    nonConstAcc.getBalance(); // 正确：非 const 对象可以调用 const 方法}

三、高级：静态成员函数

3.1 静态函数特性

// MathUtils.h
class MathUtils {
public:
    static int square(int x) { // 静态成员函数
        return x * x;
    }
};

// main.cpp
int main() {cout << MathUtils::square(5); // 直接通过类名调用

    MathUtils util;
    cout << util.square(3);       // 也可以通过对象调用（但不推荐）}

四、避坑指南

4.1 对象生命周期问题

class Logger {
public:
    void log(string msg) {/*...*/}
};

Logger& getLogger() {
    Logger localLogger; // 局部对象
    return localLogger; // 危险：返回悬垂引用
}

int main() {getLogger().log("test"); // 崩溃：访问已销毁的对象
}

4.2 多线程安全问题

class Counter {
    int count = 0;
public:
    void increment() { // 非线程安全
        ++count;       // 可能被多个线程同时修改
    }
};

思考题

1. 如何设计线程安全的成员函数？
2. 什么情况下应该将成员函数声明为 static？
3. 为什么 const 对象只能调用 const 成员函数？

（完整示例代码见 GitHub 仓库：https://github.com/example/cpp-member-function-demo）