前言：将定义的类放在不同文件夹供主文件调用的方法

人话：.h文件存放类的成员的声明，.c文件存放的是类的成员函数的定义，用::来说明函数属于这个类
通常情况下，头文件（.h 或 .hpp）用于存放类的成员的声明，包括类的数据成员和成员函数的声明。而源文件（.cpp 或 .c）用于存放类的成员函数的定义。

在类的成员函数的定义中，使用作用域解析运算符 :: 来指定函数属于哪个类。这样可以将函数的实现与类的声明分离开来，提高代码的可读性和可维护性。
例子：
(1)Rectangle.h文件

#ifndef RECTANGLE_H
#define RECTANGLE_H

class Rectangle {
private:
    double length;
    double width;

public:

    double getLength() const;
    double getWidth() const;
    double getArea() const;
};

#endif

（2）Rectangle.cpp文件

#include "rectangle.h"

double Rectangle::getLength() const {
    return length;
}

double Rectangle::getWidth() const {
    return width;
}

double Rectangle::getArea() const {
    return length * width;
}

一、构造函数与析构函数

1.什么是构造函数和析构函数？

构造函数（Constructor）： 构造函数是一种特殊的成员函数，用于在创建对象时初始化对象的数据成员。
构造函数的名称与类名相同，没有返回类型（包括 void），可以有参数，也可以没有参数。构造函数在对象创建时自动调用，用于完成对象的初始化工作。如果没有显式定义构造函数，编译器会提供一个默认的无参构造函数。构造函数可以有多个重载版本，根据传递的参数类型和个数来决定调用哪个构造函数。

析构函数（Destructor）： 析构函数是一种特殊的成员函数，用于在对象销毁时清理对象所占用的资源。析构函数的名称与类名相同，前面加上一个波浪号 ~，没有返回类型（包括 void），没有参数。析构函数在对象销毁时自动调用，用于完成对象的清理工作。如果没有显式定义析构函数，编译器会提供一个默认的析构函数。析构函数只能有一个，不能重载。

人话就是：构造函数在创建函数时为成员属性赋默认的初值，编译器自动调用完成。析构函数也是系统自动调用，用于在对象被销毁时执行清理工作。
比如这个类。

class Circle {
    //数据属性
private:
//public:
    float Radius;//圆的半径

    //函数行为
public:
    void setRadius(float radius) {//利用类的成员函数接口来从外部实现对私有成员圆的半径的操作
        Radius = radius;
    }

    float getCircumference() {//提供给外部的接口函数
        return 2 * PI * Radius;
    }

    float getArea() {
        return PI * pow(Radius, 2);//提供给外部的接口函数
    }

};

如果主程序中实例化一个对象：

 Circle cir1;

这时编译器就会自动调用构造函数为cir1的成员变量赋默认值了，保证其有内存空间。销毁时也是同理。

2.构造函数和析构函数的语法

构造函数和析构函数的语法如下：

构造函数的语法：

ClassName::ClassName(parameters) {
    // 构造函数的实现
    // 对象的初始化操作
}

其中，ClassName 是类的名称，与构造函数同名。parameters 是构造函数的参数列表，可以包含零个或多个参数。

①构造函数不写返回值，也不要void。
②函数名与类名相同。
③允许重载，所以允许有不同的参数
④实例化对象时自动调用，无需我们手动写代码调用,且只调用一次。

析构函数的语法：

ClassName::~ClassName() {
    // 析构函数的实现
    // 对象的清理操作
}

其中，ClassName 是类的名称，与析构函数同名，前面加上一个波浪号 ~。析构函数没有参数列表。
一个类是一定有构造函数和析构函数的，如果函数的{}里面我们用户什么都不写，那么编译器会提供一个空实现（即里面一行代码都没有）去自动调用。
举个例子：

class Person {

    //首先写构造函数
    /*①构造函数不写返回值，也不要void。
    ②函数名与类名相同。
    ③允许重载，所以允许有不同的参数
    ④实例化对象时自动调用，无需我们手动写代码调用,且只调用一次。*/
    Person(){
    //空实现
    }

    //析构函数
    ~Person() {
    //空实现
    }

private:
    string name;
    int Age;
    string address;

public:
    void setAge(int age) {
        Age = age;
    }

    int getAge() {
        return Age;
    }
};

3.构造函数的具体分类和调用方法

①总的来说，构造函数分类为：默认无参构造、有参构造、拷贝构造

(1)默认构造函数的调用：直接创建对象即可，不需要传递任何参数。

 Person(){//无参构造函数
    //空实现
    }
    
Person p; // 调用默认构造函数

(2)带参数的构造函数的调用：在创建对象时，通过传递参数来调用对应的构造函数。例如：

 Person(string name,int age){//有参构造函数
    }
    
Person p("John", 25); // 调用带参数的构造函数

(3)拷贝构造函数的调用：在创建对象时，使用已有对象作为参数来调用拷贝构造函数。注意，拷贝构造函数相当于把一个传入的对象的所有相关信息复制到另一个对象上。例如：

 Person(const Person &p){//拷贝构造函数
    age=p.age;
    name = p.name;
    }
    
Person p1("John", 25);
Person p2(p1); // 调用拷贝构造函数

②举一个全面的例子

#include <iostream>
#include <string>

class Person {
private:
    std::string name;
    int age;

public:
    // 默认构造函数
    Person() {
        name = "";
        age = 0;
    }

    // 有参构造函数
    Person(const std::string& n, int a) {
        name = n;
        age = a;
    }

    // 拷贝构造函数
    Person(const Person& p) {
        name = p.name;
        age = p.age;
    }

    // 打印姓名和年龄
    void printInfo() {
        std::cout << "Name: " << name << ", Age: " << age << std::endl;
    }
};

int main() {
    // 默认构造函数
    Person p1;
    p1.printInfo(); // 输出: Name: , Age: 0

    // 有参构造函数
    Person p2("John", 25);
    p2.printInfo(); // 输出: Name: John, Age: 25

    // 拷贝构造函数
    Person p3(p2);
    p3.printInfo(); // 输出: Name: John, Age: 25

    return 0;
}

4.构造函数的使用时机

①用一个已经创建完毕的对象来初始化一个新对象

void test1() {
    Person p1(15);//有参构造函数
    Person p2(p1);//拷贝构造函数
}

②值传递的方式给函数参数传值

void copy(Person p) {

}

void test2(Person p) {
    Person p;//会调用一次默认构造函数
    copy(p);//把实例化的p作为参数值传递给函数copy，那么相当于建立了一个p的副本对象，等效于调用了一次拷贝构造函数

}

二、构造函数的进阶知识

1.构造函数的调用规则

默认情况下，即不管咱们在类里面写不写构造函数，系统都会自动添加三个函数：
1.默认无参构造函数
2.默认无参析构函数
3.默认拷贝构造函数

规则为：
①如果咱们手动定义了一个有参的构造函数，那么系统就不会自动生成无参构造函数了。如果直接写Person p;就会报错。

如果我们定义了有参构造函数，编译器会认为我们有意地禁止了无参构造函数的使用。如果我们需要同时拥有有参和无参构造函数，可以在手动定义有参构造函数的同时，再显式地定义一个无参构造函数。

②如果咱们手动定义了拷贝构造函数，那么系统就不会提供其他构造函数。

这是因为拷贝构造函数是用于创建对象的副本的，它可以接受同类型的对象作为参数。如果我们手动定义了拷贝构造函数，编译器会认为我们已经提供了一种方式来创建对象的副本，因此不再需要其他构造函数。但是需要注意的是，如果我们需要同时拥有拷贝构造函数和其他构造函数，可以在手动定义拷贝构造函数的同时，再显式地定义其他构造函数

人话就是，无参最低级，有参次之，拷贝最高。为了防止系统认为我们禁用了某些构造函数，所以：
写了有参，就要补上无参；写了拷贝，就要补上有参和无参。

2.初始化列表：给类中的成员属性初始化的另一种方法

前面学的传统构造函数初始化成员属性的语法：

class Person {
private:

    int age;

public:
    // 默认构造函数
    Person() {
        
        age = 0;
        cout << "默认构造函数调用" << endl;
    }

    // 有参构造函数
    Person( int a) {
        
        age = a;
        cout << "有参构造函数调用" << endl;
    }

    // 拷贝构造函数
    Person(const Person& p) {
        age = p.age;
        cout << "拷贝构造函数调用" << endl;
    }
};

//主函数
Person p(20);//实例化对象

而初始化列表是一种在类的构造函数中给成员属性进行初始化的方法。它使用冒号（:）后跟成员属性的初始化列表，而不是在构造函数的函数体中进行赋值操作。

使用初始化列表可以在对象创建时直接初始化成员属性，而不需要先创建默认构造函数再进行赋值操作。这样可以提高代码的效率和可读性，并且在某些情况下可以避免不必要的对象拷贝。

class MyClass {
private:
    int num;
    double value;
public:
    MyClass(int n, double v) : num(n), value(v) {
        // 构造函数的函数体
    }
};

//主程序里面
MyClass class(10,20);

在上面的示例中，构造函数的初始化列表部分是 : num(n), value(v)，其中 num 和 value 是类的成员属性，n 和 v 是构造函数的参数。通过初始化列表，我们直接将参数的值赋给成员属性，而不需要在构造函数的函数体中进行赋值操作。

注意两点：
①语法：与传统构造函数类似，但是函数体里面没有内容，而是在形参的括号后面用：冒号符，跟上成员属性以及要赋的值。

 Person(int a) :age(a) {//使用初始化列表的方法给成员属性赋初值
    }

②初始化列表与常规的构造函数相比，有什么优势吗？
初始化列表相比常规的构造函数，在以下几个方面具有优势：

效率：使用初始化列表可以直接初始化成员属性，而不需要先创建默认构造函数再进行赋值操作。这样可以避免不必要的对象拷贝和临时对象的创建，提高代码的执行效率。

可读性：初始化列表将成员属性的初始化放在构造函数的声明中，使得代码更加清晰和易读。通过一目了然的初始化列表，可以直观地看到成员属性是如何被初始化的，而不需要在构造函数的函数体中寻找赋值操作。

成员属性的顺序：初始化列表要求成员属性的初始化顺序与它们在类中声明的顺序一致。这样可以避免因为不正确的初始化顺序而导致未定义行为。

常量成员属性和引用成员属性：对于常量成员属性和引用成员属性，只能通过初始化列表来进行初始化，而不能在构造函数的函数体中进行赋值操作。

3.一个类的对象作为另一个类的成员，如何对这两个类进行构造函数初始化？

顾名思义，所以我直接上一段代码：

#include <iostream>
#include <string>
using namespace std;

class Phone {
public:
	string phone_name;
	int value;

public:
	Phone(string name, int val) {//phone的构造函数
		phone_name = name;
		value = val;
	}
};


class Person {
private:
	int age;
	string name;

	//手机也是一个类
	Phone p1("huawei",4999);

public:
	Person(int a, string sname,string pname,int pval) :age(a), name(sname),p1(pname,pval) {
		//初始化列表构造函数
	}

};

这段代码有一个经典的错误。

为什么图一会报错，图二就不报错了呢？
原因是：在类的成员初始化阶段，类成员的初始化顺序是按照它们在类中声明的顺序进行的

在Person类中，我们定义了age和name两个成员变量，但是如果咱们不在主程序中实例化一个对象，系统就不会给这两个变量分配空间，也就是说目前这两个变量是没有被初始化的。
但是如果Phone p1(“huawei”,4999);也就是让第三个成员变量p1提前被初始化了的话，就违背了初始化顺序，就会报错。

所以，只能先声明这个嵌套类Phone的成员，然后用大类的构造函数或者初始化列表来有顺序的对成员属性进行初始化。

Person(int a, string sname,string pname,int pval) :age(a), name(sname),p1(pname,pval) {
		//初始化列表构造函数
		cout << a << "岁的" << sname << "拿着" << pval <<"块钱的" << pname << endl;
	}

然后主程序：

int main() {
	Person p(18, "小明", "华为mate60", 5999);
	system("pause");
	return 0;
}

这里注意：类Phone的成员变量string phone_name;和int value;都是公开的。那如果我想让他们的权限是私有的，那应该怎么在另一个类中完成这个嵌套类的对象初始化呢？
其实是一样的，不存在这个问题。因为一个类的构造函数在初始化成员变量时，是不会区分其是否为私有或者公开权限的。