C++细节

背景知识：
面向对象的编程中，类（Class）是创建对象的蓝图或模板，它包含了数据（通常称为属性或变量）和行为（通常称为方法或函数）。将数据封装为私有（private）成员，并通过公共（public）成员函数来访问和修改这些数据，是实现封装性的重要方式，也是面向对象编程的三大基本特性之一（封装、继承、多态）。

构造函数（Constructor）：
当创建类的新对象时，构造函数会被自动调用。
它用于初始化对象的属性或状态。
构造函数的名字必须与类名相同，且不能有返回类型（即使是void）。
它可以有参数，用于在创建对象时提供初始值。

class MyClass {  
private:  
    int myVar;  
public:  
    MyClass(int value) : myVar(value) {} // 构造函数  
};

拷贝构造函数（Copy Constructor）：
当用一个已存在的对象去初始化一个同类型的新对象时，拷贝构造函数会被调用。
它通常用于创建原对象的一个副本。
拷贝构造函数的形式是 ClassName(const ClassName &other)。

class MyClass {  
private:  
    int myVar;  
public:  
    MyClass(int value) : myVar(value) {} // 构造函数  
    MyClass(const MyClass &other) : myVar(other.myVar) {} // 拷贝构造函数  
};

成员函数（Member Function）：
成员函数是定义在类内部，用来操作对象数据的函数。
它们可以访问类的私有和受保护成员。
通过成员函数，可以定义对象的行为和对象间的运算关系。

class MyClass {  
private:  
    int myVar;  
public:  
    MyClass(int value) : myVar(value) {} // 构造函数  
    void setVar(int value) { myVar = value; } // 成员函数  
    int getVar() const { return myVar; } // 成员函数  
};

析构函数（Destructor）：
析构函数在对象生命周期结束时自动调用，用于释放对象所占用的资源。
析构函数的名字与类名相同，但在前面加上一个波浪号（~）。
析构函数没有返回类型，也没有参数。

class MyClass {  
private:  
    int* myPtr;  
public:  
    MyClass(int value) : myPtr(new int(value)) {} // 构造函数  
    ~MyClass() { delete myPtr; } // 析构函数  
};

成员函数作用
成员函数的作用：

1. 对象数据的存储和访问

成员函数可以访问并维护对象的数据成员。它们可以由类或实例直接调用，以执行任何操作并访问想要的数据。例如，对象A可以调用成员函数B并访问自身的数据成员，以将修改保存到它的数据存储中。

2. 对象定义的操作

成员函数使对象可以执行某些操作。例如，对于一个图形类，成员函数可以是计算它的面积或周长的方法，或将其移动到一个新的坐标上的方法。
访问和修改私有数据：通过将数据成员声明为私有（private），可以确保它们只能通过类的成员函数来访问和修改。这有助于维护数据的完整性和安全性，防止数据被不当访问或修改。

实现对象的行为：成员函数定义了对象的行为。它们可以执行各种操作，如计算、数据转换、输入/输出等。通过调用这些成员函数，可以使对象执行特定的任务或响应外部事件。

提供接口：成员函数为类的使用者提供了一个接口，使得他们可以与对象进行交互。通过调用这些函数，用户可以发送消息给对象，请求其执行某些操作或返回某些信息。

实现多态性：通过虚成员函数（virtual member functions），可以实现多态性，即允许基类的指针或引用指向派生类的对象，并调用派生类实现的函数版本。这使得代码更加灵活和可扩展。

封装复杂性：成员函数可以将复杂的逻辑封装在类内部，使得类的使用者无需关心内部实现细节，只需通过调用成员函数来与对象交互。这有助于简化代码的使用和维护。

**我的话：**类当中有函数，有变量，一般将变量封装为private，函数作为public对外的接口。其中，函数又分为构造函数，拷贝构造函数，成员函数，析构函数，一般构造函数用来初始化对象的变量，析构函数用来释放的，拷贝构造函数用来拷贝一份对象中的属性，成员函数用来描述变量间的运算逻辑关系。

1、默认调用与手动调用

创建对象时，编译器自动调用构造、拷贝构造和析构，而成员函数或成员变量是通过**.和->**调用。

1.1 **.**操作符：用于访问对象的成员变量和成员函数，当对象是通过值或引用传递时。

class MyClass {  
public:  
    int myVar;  
    void myFunction() {}  
};  
  
MyClass obj;  
obj.myVar = 10; // 使用.访问成员变量  
obj.myFunction(); // 使用.访问成员函数

->操作符：通常用于通过指针访问对象的成员变量和成员函数。（new）

class MyClass {  
public:  
    int myVar;  
    void myFunction() {}  
};  
  
MyClass* ptr = new MyClass();  
ptr->myVar = 10; // 使用->访问成员变量  
ptr->myFunction(); // 使用->访问成员函数  
delete ptr; // 不要忘记释放动态分配的内存

2、浅拷贝

#include <iostream>
using namespace std;

class Person
{
public:
   Person()
   {
    cout<<"无参（默认）构造函数"<<endl;
   }
   Person(int a)
   {
    age = a;
    cout<<"有参构造函数"<<endl;

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


public:
    int age;

};
void test()
{

//定义对象时，自动调用构造和析构函数
    //调用无参构造
    Person p;
    //调用有参构造
    Person p1(10);
    cout<<"p1.age:"<<p1.age<<endl;
    //调用拷贝函数
    Person p2(p1);
     cout<<"p2.age:"<<p2.age<<endl;
}

int main()
{

    test();
    return 0;
}

无参（默认）构造函数
有参构造函数
p1.age:10
拷贝构造函数
p2.age:10
析构函数
析构函数
析构函数

解释：
创建对象p时，调用了无参构造函数，输出了"无参（默认）构造函数"。
创建对象p1时，调用了有参构造函数，并传入了参数10，输出了"有参构造函数"。
创建对象p2时，通过传入p1作为参数调用了拷贝构造函数，输出了"拷贝构造函数"。
接下来，当test函数结束时，局部对象p、p1和p2会离开其作用域，此时它们的析构函数会被自动调用，输出了三个"析构函数"。

2.1 浅拷贝语法

构造函数定义:
Person(const Person& p)
{
age = p.age;
}
调用：
Person p2(p1);
即const Person &p=p1 age = p1.age; 就是将p1的年龄通过引用传给p2，且p1不变（const）

3 深拷贝

浅拷贝共用内存，导致重复释放，因此用深拷贝。

#include <iostream>
using namespace std;

class Person
{
public:
   Person()
   {
    cout<<"无参（默认）构造函数"<<endl;
   }
   Person(int a,int h)
   {
    age = a;
    //在堆上动态分配一个整数大小的内存，并用 h 的值初始化这块内存。
    // 并将 height 指针指向这块新分配的内存。
    height = new int(h);
    cout<<"有参构造函数"<<endl;
   }
   //拷贝构造函数
   //要赋值的参数还是age、height
   Person(const Person& p)
   {
    age = p.age;
    //重新new一个
    height = new int(*p.height);

   }

   //new了，就要delete，一般放在构造和析构，因为自动释放
   ~Person()
   {
     cout<<"析构函数"<<endl;
     if (height != NULL)
    {
       delete height;
    }

   }

public:
    int age;
    int *height;

};
void test()
{

//定义对象时，自动调用构造和析构函数
    //调用无参构造
    Person p;
    cout<<"p.age:"<<p.age<<endl;
    //调用有参构造
    Person p1(10,120);
    //调用拷贝函数
    Person p2(p1);
    cout << "p1的年龄： " << p1.age << " 身高： " << *p1.height << endl;
    cout << "p2的年龄： " << p2.age << " 身高： " << *p2.height << endl;
}

int main()
{

    test();
    return 0;
}

3.1 深拷贝语法

new一个，仍然对age、height赋值

//拷贝构造函数
   //要赋值的参数还是age、height
   Person(const Person& p)
   {
    age = p.age;
    //重新new一个
    height = new int(*p.height);

   }

new了要记得delete

//new了，就要delete，一般放在构造和析构，因为自动释放
   ~Person()
   {
     cout<<"析构函数"<<endl;
     if (height != NULL)
    {
       delete height;
    }