C++ 类和对象从基础语法到高级特性深度解析

class Date {
public:
    // 成员函数：初始化日期
    void Init(int year, int month, int day) {
        _year = year;
        _month = month;
        _day = day;
    }
private:
    // 成员变量：加前缀_区分
    int _year;
    int _month;
    int _day;
}; // 分号不可省略

// 类内声明，类外实现
void Date::Init(int year, int month, int day) {
    _year = year;
    _month = month;
    _day = day;
}

int main() {
    Date d1; // 实例化对象d1，分配内存
    d1.Init(2024, 10, 1); // 调用成员函数初始化
    return 0;
}

class A {
private:
    char _ch; // 1字节
    int _i;   // 4字节，对齐数4
};
// 内存对齐后大小：8字节（1+3填充+4）
cout << sizeof(A) << endl; // 输出8

// 编译器优化后的Init函数原型
void Date::Init(Date* const this, int year, int month, int day) {
    this->_year = year; // 显式使用this
    _month = month;    // 隐式使用this
}
// 调用时编译器自动传递对象地址
d1.Init(2024, 10, 1); // 等价于d1.Init(&d1, 2024, 10, 1)

// 题目1：编译运行结果？
class A {
public:
    void Print() { cout << "A::Print()" << endl; }
private:
    int _a;
};
int main() {
    A* p = nullptr;
    p->Print(); // 正常运行：Print未访问成员变量，无需解引用p
    return 0;
}
// 题目2：编译运行结果？
class A {
public:
    void Print() { cout << _a << endl; } // 访问成员变量，需解引用this
private:
    int _a;
};
int main() {
    A* p = nullptr;
    p->Print(); // 运行崩溃：this为nullptr，解引用出错
    return 0;
}

class Date {
public:
    // 全缺省构造（推荐，兼顾多种初始化场景）
    Date(int year = 1, int month = 1, int day = 1) {
        _year = year;
        _month = month;
        _day = day;
    }
private:
    int _year;
    int _month;
    int _day;
};
// 实例化方式
Date d1; // 调用全缺省构造，默认1-1-1
Date d2(2024, 10, 1); // 调用带参构造

class Stack {
public:
    Stack(int n = 4) {
        _a = (int*)malloc(sizeof(int) * n);
        _capacity = n;
        _top = 0;
    }
    // 显式定义析构，释放堆内存
    ~Stack() {
        free(_a);
        _a = nullptr;
        _top = _capacity = 0;
    }
private:
    int* _a;
    size_t _capacity;
    size_t _top;
};

Stack::Stack(const Stack& st) {
    // 深拷贝：为新对象分配独立内存
    _a = (int*)malloc(sizeof(int) * st._capacity);
    if (_a == nullptr) perror("malloc fail");
    memcpy(_a, st._a, sizeof(int) * st._top);
    _top = st._top;
    _capacity = st._capacity;
}

Date& Date::operator=(const Date& d) {
    if (this != &d) { // 避免自赋值
        _year = d._year;
        _month = d._month;
        _day = d._day;
    }
    return *this; // 支持连续赋值
}

class Date {
public:
    // 初始化列表初始化
    Date(int year, int month, int day, int& ref)
        : _year(year)
        , _month(month)
        , _day(day)
        , _ref(ref) // 引用必须初始化
        , _n(10)    // const成员必须初始化
    {}
private:
    int _year;
    int _month;
    int _day;
    int& _ref;    // 引用成员
    const int _n; // const成员
};

class A {
public:
    A() { ++_scount; }
    A(const A&) { ++_scount; }
    ~A() { --_scount; }
    static int GetCount() { return _scount; } // 静态成员函数
private:
    static int _scount; // 静态成员变量
};
int A::_scount = 0; // 类外初始化
int main() {
    A a1, a2;
    cout << A::GetCount() << endl; // 输出2
    return 0;
}

class Date {
    // 友元声明：operator<<可访问私有成员
    friend ostream& operator<<(ostream& out, const Date& d);
private:
    int _year;
    int _month;
    int _day;
};
// 全局函数实现
ostream& operator<<(ostream& out, const Date& d) {
    out << d._year << "-" << d._month << "-" << d._day;
    return out;
}
// 使用
Date d(2024, 10, 1);
cout << d << endl; // 输出2024-10-1

class Solution {
public:
    int Sum(int n) { return n*(n+1)/2; }
};
// 匿名对象调用函数
int ret = Solution().Sum(100); // 输出5050