C++中const修饰成员函数

// 声明（类内）
返回值类型 函数名(参数列表) const;

// 定义（类外）
返回值类型 类名::函数名(参数列表) const {
    // 函数体
}

#include <iostream>
using namespace std;

class Person {
public:
    int age = 20;

    // 普通成员函数：可修改成员变量
    void showAge() {
        cout << "Age: " << age << endl;
        // 即使没修改，编译器也认为这个函数“可能修改”对象
    }
};

int main() {
    // 常量对象：不允许被修改
    const Person p;
    p.showAge(); // 编译报错！常量对象不能调用普通成员函数

    return 0;
}

#include <iostream>
using namespace std;

class Person {
public:
    int age = 20;
    static int total = 0; // 静态成员变量

    // const成员函数：只读，不能修改非静态成员
    void showAge() const {
        cout << "Age: " << age << endl; // 允许：仅读取
        // age = 30; // 编译报错！const函数不能修改非静态成员变量

        total = 100; // 允许：静态成员变量不属于具体对象，不受const限制
    }

    // 普通成员函数：可读写
    void setAge(int a) {
        age = a; // 允许修改
    }
};

int main() {
    // 1. 常量对象：只能调用const成员函数
    const Person p1;
    p1.showAge(); // 正常执行
    // p1.setAge(30); // 编译报错！常量对象不能调用普通成员函数

    // 2. 普通对象：既可以调用const成员函数，也可以调用普通成员函数
    Person p2;
    p2.showAge(); // 正常执行
    p2.setAge(30); // 正常执行

    return 0;
}

class Person {
public:
    int age = 20;

    void func1() const {
        func2(); // 编译报错！const函数不能调用普通成员函数
        func3(); // 允许：调用其他const成员函数
    }

    void func2() {
        // 普通成员函数
    }

    void func3() const {
        // const成员函数
    }
};

#include <iostream>
using namespace std;

class Person {
public:
    int age = 20;
    mutable int visitCount = 0; // 可变成员：记录访问次数

    void showAge() const {
        visitCount++; // 允许：mutable成员可被const函数修改
        cout << "Age: " << age << "，访问次数：" << visitCount << endl;
    }
};

int main() {
    const Person p;
    p.showAge(); // 输出：Age: 20，访问次数：1
    p.showAge(); // 输出：Age: 20，访问次数：2
    return 0;
}

// 普通成员函数：void showAge(Person* const this)
void Person::showAge() {
    this->age = 30; // 允许：this指向的对象可改
}

// const成员函数：void showAge(const Person* const this)
void Person::showAge() const {
    this->age = 30; // 报错：this指向的对象是const，不可改
}

#include <iostream>
using namespace std;

class Person {
public:
    int age = 20;

    // 普通版本：供普通对象调用
    void showAge() {
        cout << "普通版本：Age = " << age << endl;
    }

    // const版本：供常量对象调用
    void showAge() const {
        cout << "const版本：Age = " << age << endl;
    }
};

int main() {
    Person p1; // 普通对象
    p1.showAge(); // 调用普通版本

    const Person p2; // 常量对象
    p2.showAge(); // 调用const版本

    return 0;
}