【C++】类和对象（中）

1. 类的默认成员函数

• 第⼀：我们不写时，编译器默认⽣成的函数行为是什么，是否满足我们的需求。
• 第⼆：编译器默认⽣成的函数不满⾜我们的需求，我们需要自己实现，那么如何自己实现？

 2. 构造函数

#include<iostream>
using namespace std;
class Date
{
public:

    // 1.⽆参构造函数
    Date()
    {
        _year = 1;
        _month = 1;
        _day = 1;
    }
    
    // 2.带参构造函数
    Date(int year, int month, int day)
    {
        _year = year;
        _month = month;
        _day = day;
    }

    // 3.全缺省构造函数
    /*Date(int year = 1, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }*/

    void Print()
    {
        cout << _year << "/" << _month << "/" << _day << endl;
    }

private:
    int _year;
    int _month;
    int _day;
};
   
int main()
{
    // 如果留下三个构造中的第⼆个带参构造，第⼀个和第三个注释掉
    // 编译报错：error C2512: “Date”: 没有合适的默认构造函数可⽤

    Date d1; // 调⽤默认构造函数
    Date d2(2025, 1, 1); // 调⽤带参的构造函数

    // 注意：如果通过⽆参构造函数创建对象时，对象后⾯不⽤跟括号，否则编译器⽆法
    // 区分这⾥是函数声明还是实例化对象
    // warning C4930: “Date d3(void)”: 未调⽤原型函数(是否是有意⽤变量定义的?)

    Date d3();
    d1.Print();
    d2.Print();
    return 0;
}

#include<iostream>
using namespace std;
typedef int STDataType;

class Stack
{
public:
    Stack(int n = 4)
    {
        _a = (STDataType*)malloc(sizeof(STDataType) * n);
        if (nullptr == _a)
        {
            perror("malloc申请空间失败");
            return;
        }
        _capacity = n;
        _top = 0;
    }
// ...
private:
    STDataType* _a;
    size_t _capacity;
    size_t _top;
};

// 两个Stack实现队列
class MyQueue
{
public:
    //编译器默认⽣成MyQueue的构造函数调⽤了Stack的构造，完成了两个成员的初始化
private:
    Stack pushst;
    Stack popst;
};

int main()
{
    MyQueue mq;
    return 0;
}

 3. 析构函数

#include<iostream>
using namespace std;
typedef int STDataType;
class Stack
{
public:
    Stack(int n = 4)
    {
        _a = (STDataType*)malloc(sizeof(STDataType) * n);
        if (nullptr == _a)
        {
            perror("malloc申请空间失败");
            return;
        }
        _capacity = n;
        _top = 0;
    }

    ~Stack()
    {
        cout << "~Stack()" << endl;
        free(_a);
        _a = nullptr;
        _top = _capacity = 0;
    }

private:

    STDataType* _a;
    size_t _capacity;
    size_t _top;
};

// 两个Stack实现队列
class MyQueue
{
public:
    //编译器默认⽣成MyQueue的析构函数调⽤了Stack的析构，释放的Stack内部的资源
    // 显⽰写析构，也会⾃动调⽤Stack的析构
    /*~MyQueue()
    {}*/

private:
    Stack pushst;
    Stack popst;
};

int main()
{
    Stack st;
    MyQueue mq;
    return 0;
}

#include<iostream>
using namespace std;

// ⽤最新加了构造和析构的C++版本Stack实现
bool isValid(const char* s)
{
    Stack st;
    while (*s)
    {
        if (*s == '[' || *s == '(' || *s == '{')
        {
            st.Push(*s);
        }
        else
        {
            // 右括号⽐左括号多，数量匹配问题
            if (st.Empty())
            {
                return false;
            }
            // 栈⾥⾯取左括号
            char top = st.Top();
            st.Pop();
            // 顺序不匹配
            if ((*s == ']' && top != '[')
            || (*s == '}' && top != '{')
            || (*s == ')' && top != '('))
            {
                return false;
            }
        }
        ++s;
    }

    // 栈为空，返回真，说明数量都匹配 左括号多，右括号少匹配问题
    return st.Empty();
}

// ⽤之前C版本Stack实现
bool isValid(const char* s) 
{
    ST st;
    STInit(&st);
    while (*s)
    {
        // 左括号⼊栈
        if (*s == '(' || *s == '[' || *s == '{')
        {
            STPush(&st, *s);
        }
        else // 右括号取栈顶左括号尝试匹配
        {
            if (STEmpty(&st))
            {
                STDestroy(&st);
                return false;
            }
            char top = STTop(&st);
            STPop(&st);
            // 不匹配
            if ((top == '(' && *s != ')')
            || (top == '{' && *s != '}')
            || (top == '[' && *s != ']'))
            {
                STDestroy(&st);
                return false;
            }

        }
        ++s;
    }

    // 栈不为空，说明左括号⽐右括号多，数量不匹配
    bool ret = STEmpty(&st);
    STDestroy(&st);
    return ret;
}

int main()
{
    cout << isValid("[()][]") << endl;
    cout << isValid("[(])[]") << endl;
    return 0;
}

5. 赋值运算符重载

5.1 运算符重载

• 当运算符被⽤于类类型的对象时，C++语⾔允许我们通过运算符重载的形式指定新的含义。C++规定类类型对象使⽤运算符时，必须转换成调⽤对应运算符重载，若没有对应的运算符重载，则会编译报错。
• 运算符重载是具有特名字的函数，他的名字是由operator和后面要定义的运算符共同构成。和其他函数⼀样，它也具有其返回类型和参数列表以及函数体。
• 重载运算符函数的参数个数和该运算符作用的运算对象数量⼀样多。⼀元运算符有⼀个参数，⼆元运算符有两个参数，⼆元运算符的左侧运算对象传给第⼀个参数，右侧运算对象传给第⼆个参数。
• 如果⼀个重载运算符函数是成员函数，则它的第⼀个运算对象默认传给隐式的 this 指针，因此运算符重载作为成员函数时，参数比运算对象少⼀个。
• 运算符重载以后，其优先级和结合性与对应的内置类型运算符保持⼀致。
• 不能通过连接语法中没有的符号来创建新的操作符：比如operator@。
• .*  ::  sizeof  ?:  .  注意以上5个运算符不能重载。(选择题⾥⾯常考，⼤家要记⼀下) 重载操作符⾄少有⼀个类类型参数，不能通过运算符重载改变内置类型对象的含义，如： int operator+(int x, int y)
• ⼀个类需要重载哪些运算符，是看哪些运算符重载后有意义，比如Date类重载operator-就有意义，但是重载operator+就没有意义。
• 重载++运算符时，有前置++和后置++，运算符重载函数名都是operator++，无法很好的区分。 C++规定，后置++重载时，增加⼀个int形参，跟前置++构成函数重载，方便区分。
• 重载<<和>>时，需要重载为全局函数，因为重载为成员函数，this指针默认抢占了第⼀个形参位置，第⼀个形参位置是左侧运算对象，调⽤时就变成了 对象<<cout，不符合使⽤习惯和可读性。重载为全局函数把ostream/istream放到第⼀个形参位置就可以了，第⼆个形参位置当类类型对象。

 5.2 赋值运算符重载

6. 取地址运算符重载 

6.1 const成员函数

• 将const修饰的成员函数称之为const成员函数，const修饰成员函数放到成员函数参数列表的后⾯。
• const实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。 const 修饰Date类的Print成员函数，Print隐含的this指针由 Date* const this 变为 const Date* const this 。

#include<iostream>
using namespace std;
class Date
{
public:

    Date(int year = 1, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }

    // void Print(const Date* const this) const
    void Print() const
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }

private:

    int _year;
    int _month;
    int _day;
};

int main()
{
    // 这⾥⾮const对象也可以调⽤const成员函数是⼀种权限的缩⼩
    Date d1(2024, 7, 5);
    d1.Print();
    const Date d2(2024, 8, 5);
    d2.Print();
    return 0;
}

 6.2 取地址运算符重载

class Date
{
public :

    Date* operator&()
    {
        return this;
        // return nullptr;
    }

    const Date* operator&()const
    {
        return this;
        // return nullptr;
    }

private :

    int _year ; // 年
    int _month ; // ⽉
    int _day ; // ⽇
};