类和对象（c++）后续①

目录

说给自己的前言

一，类和对象的几大默认函数的梳理

---

说给自己的前言

对于昨天重新开始写博客的感觉就是思维有些僵硬，同时确实有不少东西忘掉了，所以我及时停止了昨天关于博客文章的设想，开始再回味一遍类和对象的知识，只能说知不足而后进，望山远而后力行。希望我日后还能继续努力，至少坚持一个月能写10篇令自己满意的文章，当然我估摸着还要再锻炼锻炼。那接下来就开始了。

昨天粗浅的谈论了C++方向的类和对象得一部分，有我的看法和其基本理念还有一些设计相关的知识点，但我暂时还不想讲多态和继承还有重载这部分，上篇文章有关于类的基本函数，昨天我又学习了一遍今日就详细梳理一下，（当然还有友元之类的，但个人感觉友元的逻辑很简单，还是想归类到继承和多态中一起讲，因为我个人认为那样比较好。）

类和对象的几大函数的梳理

1,构造函数，

构造函数是我们应该知道的第一函数，他的实际意义其实是初始化(而不是帮你分配内存什么的哦)，构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，以保证 每个数据成员都有 一个合适的初始值，并且在对象整个生命周期内只调用一次。针对析构函数你需要知道：
1.函数名必须和类型相同

2.不能有返回值，函数体不能有return语句

3.构造函数在定义对象时会自动调用，不需要手动调用

//代码省略的包含的头文件，希望你能看懂
class Date
 {
 public:
 void Init(int year, int month, int day)
 {
    _year = year;
    _month = month;
    _day = day;
 }
 void Print()
 {
 cout << _year << "-" << _month << "-" << _day << endl;
 }
 private:
 int _year;
 int _month;
 int _day;
 };
 int main()
 {
 Date d1;
 d1.Init(2022, 7, 5);
 d1.Print();
 Date d2;
 d2.Init(2022, 7, 6);
 d2.Print();
 return 0;
 }

2，构造函数的重载(可以看成上面的小分支）

其次可以提一嘴构造函数的重载，和普通函数一样，构造函数是允许重载的，一个类可以有多个重载的构造函数，在创建对象时根据传递实参来判断调用哪一个构造函数

class Array
{
    private:
        int *m_data;   
        int m_size;
    public:
        Array(); 
        Array(int s);  
  
        ~Array();  
};
 
Array::Array()
{
    cout<<"Array的无参构造函数"<<endl;
    m_size = 5;
    m_data = (int *)malloc(sizeof(int) *m_size);
}
 
Array::Array(int s)  //有参构造函数
{
    cout<<"Array的有一个参数的构造函数"<<endl;
    m_size = s;
    m_data = (int *)malloc(sizeof(int) * m_size);
}

3，析构函数

我们在了解了构造，也就是对象的初始化的方法后，就应该知道怎么清理对象了，而析构函数就是用于处理这一问题的 。

1 概念 通过前面构造函数的学习，我们知道一个对象是怎么来的，那一个对象又是怎么没呢的？ 析构函数：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由 编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作

2 特性.

 ①析构函数名是在类名前加上字符 ~。

 ②无参数无返回值类型。

 ③一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。(注意：析构 函数不能重载)

④ 对象生命周期结束时，C++编译系统系统自动调用析构函数。

class MyClass {  
public:  
    // 构造函数  
    MyClass(const char* name) {  
        std::cout << "*** " << name << std::endl;  
        // 动态分配内存  
        _name = new char[strlen(name) + 1];  
        strcpy(_name, name);  
    }  

    // 析构函数  
    ~MyClass() {  
        std::cout << "调用析构函数" << _name << std::endl;  
        // 释放动态分配的内存  
        delete[] _name;  
    }  

private:  
    char* _name; // 动态分配的字符串  
};  

int main() {  
    {  
        MyClass obj(" Object");  
        // 在这里可以使用 obj  
    } // obj 的生命周期结束，析构函数会被调用  

    return 0;  
}

4 拷贝构造

1 拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存 在的类类型对象创建新对象时由编译器自动调用

2 拷贝构造函数也是特殊的成员函数，其特征如下：

① 拷贝构造函数是构造函数的一个重载形式。

 ②拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错， 因为会引发无穷递归调用。

③若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按 字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。

   // 构造函数  
    MyClass(const char* name) {  
        std::cout << "****" << name << std::endl;  
        _name = new char[strlen(name) + 1];  
        strcpy(_name, name);  
    }  

    // 拷贝构造函数  
    MyClass(const MyClass& other) {  
        std::cout << "Copy " << std::endl;  
        _name = new char[strlen(other._name) + 1];  
        strcpy(_name, other._name);  
    } 

5.运算符重载

1. 这是为了增强c++的代码可读性而引入的一种函数。运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。

函数名字为：关键字operator后面接需要重载的运算符符号。 函数原型：返回值类型 operator操作符(参数列表)同时还需要注意以下几点：

①不能通过连接其他符号来创建新的操作符：比如operator@

重载操作符必须有一个类类型参数

用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不能改变其含义

作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this

.* :: sizeof ?: . 注意以上5个运算符不能重载。这个经常在笔试选择题中出 现。

2. 赋值运算符重载格式

参数类型：const T&，传递引用可以提高传参效率 返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值 检测是否自己给自己赋值 返回*this ：要复合连续赋值的含义

其次 赋值运算符只能重载成类的成员函数不能重载成全局函数。 另外 用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。

同时对于这一部分给点小建议：

• 确保运算符的行为符合直觉（不要写乱七八糟的重载就比如@）。
• 避免过度重载，保持代码的清晰性。
• 注意运算符的优先级和结合性，确保与内置类型一致（不要以为重载以后得运算符没有优先级别了）。

#include <iostream>  

class Vector {  
public:  
    // 构造函数  
    Vector(int x, int y) : _x(x), _y(y) {}  

    // 重载 + 运算符  
    Vector operator+(const Vector& other) {  
        return Vector(_x + other._x, _y + other._y);  
    }  

    // 打印向量  
    void print() const {  
        std::cout << "Vector(" << _x << ", " << _y << ")" << std::endl;  
    }  

private:  
    int _x, _y; // 向量的坐标  
};  

int main() {  
    Vector v1(1, 2);  
    Vector v2(3, 4);  
    
    Vector v3 = v1 + v2; // 调用重载的 + 运算符  
    v3.print(); // 输出: Vector(4, 6)  

    return 0;  
}  

6. const成员

在c++中，将const修饰的“成员函数”称之为const成员函数，const修饰类成员函数，实际修饰该成员函数 隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。

class Person {  
public:  
    // 构造函数  
    Person(const std::string& name, int age) : _name(name), _age(age) {}  

    // const 函数：获取姓名  
    std::string getName() const {  
        return _name;  
    }  

    // const 函数：获取年龄  
    int getAge() const {  
        return _age;  
    }  

    // 非 const 函数：设置年龄  
    void setAge(int age) {  
        _age = age;  
    }  

private:  
    std::string _name; // 姓名  
    int _age;          // 年龄  
};  

int main() {  
    const Person person("Alice", 16);  

    // 调用 const 函数  
    std::cout << "Name: " << person.getName() << std::endl; // 输出: Name: Alice  
    std::cout << "Age: " << person.getAge() << std::endl;   // 输出: Age: 16 

    // person.setAge(35); // 错误：不能在 const 对象上调用非 const 函数  

    return 0;  
}  

那么差不多，就这么多了。