C++类基本操作

#include <iostream>
#include <string>

/* 使用命名空间封装计算器工具类，避免命名冲突 */
namespace MathTools {

/*
 * @brief 简单计算器类
 * 
 * 该类演示了C++类的基本特性，包括构造函数、析构函数、
 * 成员函数、静态成员、运算符重载等。
 */
class SimpleCalculator {
private:
    std::string name;    /* 计算器名称（普通成员变量） */
    int id;              /* 计算器ID（普通成员变量） */
    static int instanceCount;  /* 静态成员变量，记录实例数量 */

public:
    /* 构造函数声明 ======================== */
    
    /*
     * @brief 默认构造函数
     */
    SimpleCalculator();
    
    /*
     * @brief 带参数的构造函数
     * @param name 计算器名称
     * @param id 计算器ID
     */
    SimpleCalculator(const std::string& name, int id);
    
    /*
     * @brief 析构函数
     */
    ~SimpleCalculator();

    /* 成员函数声明 ======================== */
    
    /*
     * @brief 显示计算器信息
     */
    void display() const;
    
    /*
     * @brief 设置计算器名称
     * @param newName 新的计算器名称
     */
    void setName(const std::string& newName);
    
    /* 函数重载声明 ======================== */
    
    /*
     * @brief 整数加法
     * @param a 第一个加数
     * @param b 第二个加数
     * @return 两数之和
     */
    int add(int a, int b) const;
    
    /*
     * @brief 浮点数加法
     * @param a 第一个加数
     * @param b 第二个加数
     * @return 两数之和
     */
    double add(double a, double b) const;
    
    /*
     * @brief 字符串连接
     * @param a 第一个字符串
     * @param b 第二个字符串
     * @return 连接后的字符串
     */
    std::string add(const std::string& a, const std::string& b) const;
    
    /* 运算符重载声明 ====================== */
    
    /*
     * @brief 加法运算符重载（合并两个计算器）
     * @param other 另一个计算器对象
     * @return 合并后的新计算器对象
     */
    SimpleCalculator operator+(const SimpleCalculator& other) const;
    
    /*
     * @brief 赋值运算符重载
     * @param other 另一个计算器对象
     * @return 当前对象的引用
     */
    SimpleCalculator& operator=(const SimpleCalculator& other);
    
    /*
     * @brief 输出运算符重载（友元函数）
     */
    friend std::ostream& operator<<(std::ostream& os, const SimpleCalculator& calc);
    
    /* 静态成员函数声明 ==================== */
    
    /*
     * @brief 获取当前实例数量
     * @return 实例数量
     */
    static int getInstanceCount();
    
    /*
     * @brief 重置实例计数器
     */
    static void resetInstanceCount();
};

/* 静态成员变量初始化（必须在类外定义） */
int SimpleCalculator::instanceCount = 0;

/* 构造函数实现 ============================ */

SimpleCalculator::SimpleCalculator() : name("Default"), id(0) {
    instanceCount++;
    std::cout << "默认构造函数被调用。当前实例数: " 
              << instanceCount << std::endl;
}

SimpleCalculator::SimpleCalculator(const std::string& name, int id) 
    : name(name), id(id) {
    instanceCount++;
    std::cout << "带参数构造函数被调用。当前实例数: " 
              << instanceCount << std::endl;
}

/* 析构函数实现 ============================ */

SimpleCalculator::~SimpleCalculator() {
    instanceCount--;
    std::cout << "析构函数被调用 [" << name 
              << "]。剩余实例数: " << instanceCount << std::endl;
}

/* 成员函数实现 ============================ */

void SimpleCalculator::display() const {
    std::cout << "计算器信息 - 名称: " << name 
              << ", ID: " << id << std::endl;
}

void SimpleCalculator::setName(const std::string& newName) {
    name = newName;
}

/* 函数重载实现 ============================ */

int SimpleCalculator::add(int a, int b) const {
    return a + b;
}

double SimpleCalculator::add(double a, double b) const {
    return a + b;
}

std::string SimpleCalculator::add(const std::string& a, const std::string& b) const {
    return a + b;
}

/* 运算符重载实现 ========================== */

SimpleCalculator SimpleCalculator::operator+(const SimpleCalculator& other) const {
    SimpleCalculator result;  /* 创建临时对象 */
    result.name = this->name + "+" + other.name;  /* 合并名称 */
    result.id = this->id + other.id;             /* 合并ID */
    return result;
}

SimpleCalculator& SimpleCalculator::operator=(const SimpleCalculator& other) {
    /* 检查自赋值 */
    if (this != &other) {
        name = other.name;
        id = other.id;
    }
    return *this;  /* 返回当前对象的引用 */
}

/* 友元函数实现 */
std::ostream& operator<<(std::ostream& os, const SimpleCalculator& calc) {
    os << "计算器[" << calc.name << " #" << calc.id << "]";
    return os;
}

/* 静态成员函数实现 ======================== */

int SimpleCalculator::getInstanceCount() {
    return instanceCount;
}

void SimpleCalculator::resetInstanceCount() {
    instanceCount = 0;
}

} /* namespace MathTools */

/*
 * @brief 主函数 - 测试SimpleCalculator类的各种功能
 */
int main() {
    using namespace MathTools;
    
    std::cout << "\n===== 测试默认构造函数 =====" << std::endl;
    SimpleCalculator calc1;
    calc1.display();
    
    std::cout << "\n===== 测试带参数构造函数 =====" << std::endl;
    SimpleCalculator calc2("科学计算器", 1001);
    calc2.display();
    
    std::cout << "\n===== 测试函数重载 =====" << std::endl;
    std::cout << "整数加法: " << calc1.add(5, 3) << std::endl;
    std::cout << "浮点数加法: " << calc1.add(2.5, 3.7) << std::endl;
    std::cout << "字符串连接: " << calc1.add("你好", "世界") << std::endl;
    
    std::cout << "\n===== 测试运算符重载 =====" << std::endl;
    SimpleCalculator calc3 = calc1 + calc2;
    std::cout << "calc1 + calc2 = " << calc3 << std::endl;
    
    std::cout << "\n===== 测试静态成员函数 =====" << std::endl;
    std::cout << "当前实例数: " << SimpleCalculator::getInstanceCount() << std::endl;
    
    {
        std::cout << "\n===== 进入内部作用域 =====" << std::endl;
        SimpleCalculator calc4("图形计算器", 2002);
        std::cout << "内部作用域实例数: " 
                  << SimpleCalculator::getInstanceCount() << std::endl;
        std::cout << "===== 退出内部作用域 =====" << std::endl;
    }
    
    std::cout << "\n外部作用域实例数: " 
              << SimpleCalculator::getInstanceCount() << std::endl;
    
    std::cout << "\n===== 测试重置静态计数器 =====" << std::endl;
    SimpleCalculator::resetInstanceCount();
    std::cout << "重置后实例数: " 
              << SimpleCalculator::getInstanceCount() << std::endl;
    
    return 0;
}

输出如下：
===== 测试默认构造函数 =====
默认构造函数被调用。当前实例数: 1
计算器信息 - 名称: Default, ID: 0

===== 测试带参数构造函数 =====
带参数构造函数被调用。当前实例数: 2
计算器信息 - 名称: 科学计算器, ID: 1001

===== 测试函数重载 =====
整数加法: 8
浮点数加法: 6.2
字符串连接: 你好世界

===== 测试运算符重载 =====
默认构造函数被调用。当前实例数: 3
calc1 + calc2 = 计算器[Default+科学计算器 #1001]

===== 测试静态成员函数 =====
当前实例数: 3

===== 进入内部作用域 =====
带参数构造函数被调用。当前实例数: 4
内部作用域实例数: 4
===== 退出内部作用域 =====
析构函数被调用 [图形计算器]。剩余实例数: 3

外部作用域实例数: 3

===== 测试重置静态计数器 =====
重置后实例数: 0
析构函数被调用 [Default+科学计算器]。剩余实例数: -1
析构函数被调用 [科学计算器]。剩余实例数: -2
析构函数被调用 [Default]。剩余实例数: -3