C++--初阶知识点汇总-CSDN博客

//1. 正常的命名空间定义

namespace A   //名字可以随意取
 {
    // 命名空间中可以定义变量/函数/类型
    int rand = 10;
    int Add(int left, int right)
    {
        return left + right;
    }
    struct Node
    {
        struct Node* next;
        int val;
    };
 }

//2. 命名空间可以嵌套

 namespace N1
 {
     int a;
     int b;
     int Add(int left, int right)
     {
         return left + right;
     }
     namespace N2
     {
         int c;
         int d;
         int Sub(int left, int right)
         {
               return left - right;
         }
     }
 }

 //3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。
// ps：一个工程中的test.h和上面test.cpp中两个N1会被合并成一个
// test.h
 namespace N1
 {
      int Mul(int left, int right)
      {
         return left * right;
      }
 }

3.命名空间的使用

加命名空间名称及作用域限定符

namespace N
{
   int a=10;
}

int main()
{
 printf("%d\n", N::a);
 return 0;  
}

使用using将命名空间中的某个成员引入

namespace N
{
   int a=10;
   int b=20;
}

using N::b;

int main()
{
   printf("%d\n", N::a);
   printf("%d\n", b);
   return 0;    
}

使用using namespace 命名空间引入

namespace N
{
    int a=10;
    int b=20;
}

using namespce N;

int main()
{
    printf("%d\n", N::a);
    printf("%d\n", b);
    Add(10, 20);
    return 0;    
}

二、输入和输出

1.定义

使用cout标准输出对象(控制台)和cin标准输入对象(键盘)时，必须包含< iostream >头文件以及按命名空间使用方法使用std。
cout和cin是全局的流对象，endl是特殊的C++符号，表示换行输出，他们都包含在包含< iostream >头文件中。
<<是流插入运算符，>>是流提取运算符。
使用C++输入输出更方便，不需要像printf/scanf输入输出时那样，需要手动控制格式。 C++的输入输出可以自动识别变量类型。

2.std标准库

std是C++标准库的命名空间
在日常练习中，建议直接using namespace std即可，这样就很方便。
using namespace std展开，标准库就全部暴露出来了，如果我们定义跟库重名的类型/对象/函数，就存在冲突问题。该问题在日常练习中很少出现，但是项目开发中代码较多、规模大，就很容易出现。所以建议在项目开发中使用，像std::cout这样使用时指定命名空间 + using std::cout展开常用的库对象/类型等方式

3.输入和输出的使用

#include <iostream>

using namespace std;

int main()
{
    int a;
    double b;
    char c;
    // 可以自动识别变量的类型
    cin>>a;
    cin>>b>>c;
    cout<<a<<endl;
    cout<<b<<"  "<<c<<endl;
    return 0;
}
// ps：关于cout和cin还有很多更复杂的用法，比如控制浮点数输出精度，控制整形输出进制格式等
等。

三、缺省参数

1.定义

缺省参数是声明或定义函数时为函数的参数指定一个缺省值。在调用该函数时，如果没有指定实参则采用该形参的缺省值，否则使用指定的实参。

void Func(int a = 0)
{
    cout<<a<<endl;
}

int main()
{
    Func(); //没有传参时，使用缺省参数    
    Func(10); //有传参，使用传参的值  
    return 0;
}

2.缺省参数的种类

全缺省参数

void Func(int a = 10, int b = 20, int c = 30)
{
   cout<<"a = "<<a<<endl;
   cout<<"b = "<<b<<endl;
   cout<<"c = "<<c<<endl;
}

半缺省参数

void Func(int a, int b = 10, int c = 20)
{
    cout<<"a = "<<a<<endl;
    cout<<"b = "<<b<<endl;
    cout<<"c = "<<c<<endl;
}

注意：1. 半缺省参数必须从右往左依次来给出，不能间隔着给 2. 缺省参数不能在函数声明和定义中同时出现 3. 缺省值必须是常量或者全局变量 4. C语言不支持（编译器不支持）

四、函数重载

1.定义

是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数或类型或类型顺序)不同，常用来处理实现功能类似数据类型不同的问题。

#include<iostream>

using namespace std;

// 1、参数类型不同
int Add(int left, int right)
{
    cout << "int Add(int left, int right)" << endl;
    return left + right;
}

double Add(double left, double right)
{
    cout << "double Add(double left, double right)" << endl;
    return left + right;
}


// 2、参数个数不同
void f()
{
    cout << "f()" << endl;
}

void f(int a)
{
    cout << "f(int a)" << endl;
}



// 3、参数类型顺序不同
void f(int a, char b)
{
     cout << "f(int a,char b)" << endl;
}
 
void f(char b, int a)
{
     cout << "f(char b, int a)" << endl;
}
 

int main()
{
    Add(10, 20);
    Add(10.1, 20.2);
    f();
    f(10);
    f(10, 'a');
    f('a', 10);
    return 0;
}

五、引用

1.定义

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。
类型& 引用变量名(对象名) = 引用实体；

void TestRef()
{
    int a = 10;
    int& ra = a;//<====定义引用类型
    printf("%p\n", &a);
    printf("%p\n", &ra);
}

注意：引用类型必须和引用实体是同种类型的

2.引用的特性

引用在定义时必须初始化
一个变量可以有多个引用
引用一旦引用一个实体，再不能引用其他实体

3.引用时权限的放大、平移和缩小

权限的放大

int a = 1;
int& b = a;     //不会报错
 
const int c = 2;
int& d = c;    //会报错，因为c被const修饰，具有常性，所以d也要用const修饰才可以

权限的平移

const int c = 2;
const int& d = c;

权限的缩小

int c = 2;
const int& d = c;

注意：隐式类型转换（也就不同类型的值转换）和函数调用会产生临时变量，临时变量具有常性（const），所以也要用const来进行权限的平移或缩小。

4.引用的使用方法

做参数

void Swap(int& left, int& right)
{
    int temp = left;
    left = right;
    right = temp;
}

做返回值

int& Count()
{
    static int n = 0;
    n++;
    // ...
    return n;
}

注意：如果函数返回时，出了函数作用域，如果返回对象还在(还没还给系统)，则可以使用引用返回，如果已经还给系统了，则必须使用传值返回。

5.效率比较

传值和传参的效率比较

#include<iostream>
#include <time.h>

using namespace std;
struct A 
{ 
    int a[10000]; 
};

void TestFunc1(A a) {}

void TestFunc2(A& a) {}

void main ()
{
    A a;
    // 以值作为函数参数
    size_t begin1 = clock();
    for (size_t i = 0; i < 10000; ++i)
        TestFunc1(a);
    size_t end1 = clock();

    // 以引用作为函数参数
    size_t begin2 = clock();
    for (size_t i = 0; i < 10000; ++i)
        TestFunc2(a);
    size_t end2 = clock();

    // 分别计算两个函数运行结束后的时间
    cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
    cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
}

引用作为返回值和值作为返回值的效率比较

#include <time.h>
#include<iostream>

using namespace std;
struct A { int a[10000]; };
A a;
// 值返回
A TestFunc1() { return a; }
// 引用返回
A& TestFunc2() { return a; }
void main()
{
	// 以值作为函数的返回值类型
	size_t begin1 = clock();
	for (size_t i = 0; i < 100000; ++i)
		TestFunc1();
	size_t end1 = clock();
	// 以引用作为函数的返回值类型
	size_t begin2 = clock();
	for (size_t i = 0; i < 100000; ++i)
		TestFunc2();
	size_t end2 = clock();
	// 计算两个函数运算完成之后的时间
	cout << "TestFunc1 time:" << end1 - begin1 << endl;
	cout << "TestFunc2 time:" << end2 - begin2 << endl;
	
}

注意：传值的本质是拷贝，会产生临时空间，就会造成浪费，而传引用的本质和传地址类似，并不会产生空间的浪费。

6.引用和指针的区别

引用概念上定义一个变量的别名，指针存储一个变量地址。
引用在定义时必须初始化，指针没有要求
引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体
没有NULL引用，但有NULL指针
在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32 位平台下占4个字节) 比特就业课
引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
有多级指针，但是没有多级引用
访问实体方式不同，指针需要显式解引用，引用编译器自己处理
引用比指针使用起来相对更安全
在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。但是在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。

六、内联函数

1.定义

以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数调用建立栈帧的开销，内联函数提升程序运行的效率。例如：要重复调用同一个函数的时候，会产生无数次函数栈帧，但是使用了内联函数后，就能规避这样的空间浪费。

#include <iostream>
 
using namespace std;

inline int Max(int x, int y)
{
   return (x > y)? x : y;
}

// 程序的主函数
int main( )
{

   cout << "Max (20,10): " << Max(20,10) << endl;
   cout << "Max (0,200): " << Max(0,200) << endl;
   cout << "Max (100,1010): " << Max(100,1010) << endl;
   return 0;
}

2.特性

inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用，缺陷：可能会使目标文件变大，优势：少了调用开销，提高程序运行效率。
inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建议：将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不是递归、且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。
inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。

七、auto关键字

1.定义

C++11中，标准委员会赋予了auto全新的含义即：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。

#include<iostream>
using namespace std;
int main()
{
	int a = 0;
	auto b = a;//此时b为int 类型
	cout << typeid(a).name() << endl;//typeid().name()可以自动识别变量的类型
	cout << typeid(b).name() << endl;
	return 0;
}

（可能你会觉得auto的这点功能好像可有可无啊，但其实随着程序越来越复杂，程序中用到的类型也越来越复杂，例如这样长的的变量类型std::map<std::string, std::string>::iterator我们完全可以使用一个auto来进行代替）

注意：使用auto定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导auto 的实际类型。因此auto并非是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编译期会将auto替换为变量实际的类型。

2.auto的使用细则

auto与指针和引用结合起来使用：用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&

#include <time.h>
#include<iostream>

using namespace std;
int main()
{
	int x = 10;
	auto a = &x;
	auto* b = &x;
	auto& c = x;
	cout << typeid(a).name() << endl;
	cout << typeid(b).name() << endl;
	cout << typeid(c).name() << endl;
	*a = 20;
	*b = 30;
	c = 40;
	return 0;
}

在同一行定义多个变量：当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。

void TestAuto()
{
     auto a = 1, b = 2; 
     auto c = 3, d = 4.0;  // 该行代码会编译失败，因为c和d的初始化表达式类型不同
}

3.auto不能使用的场景

auto不能作为函数的参数
auto不能直接用来声明数组
为了避免与C++98中的auto发生混淆，C++11只保留了auto作为类型指示符的用法
auto在实际中最常见的优势用法就是跟以后会讲到的C++11提供的新式for循环，还有 lambda表达式等进行配合使用

八、类

1.类的引入

C语言结构体中只能定义变量，在C++中，结构体内不仅可以定义变量，也可以定义函数。比如：之前在数据结构初阶中，用C语言方式实现的栈，结构体中只能定义变量；现在以C++方式实现，会发现struct中也可以定义函数。

typedef int DataType;
struct Stack
{
    void Init(size_t capacity)
    {
         _array = (DataType*)malloc(sizeof(DataType) * capacity);
         if (nullptr == _array)
         {
               perror("malloc申请空间失败");
               return;
         }
         _capacity = capacity;
         _size = 0;
    }
    void Push(const DataType& data)
    {
         // 扩容
         _array[_size] = data;
         ++_size;
    }
    DataType Top()
    {
         return _array[_size - 1];
    }
    void Destroy()
    {
         if (_array)
         {
               free(_array);
               _array = nullptr;
               _capacity = 0;
               _size = 0;
         }
    }
    DataType* _array;
    size_t _capacity;
    size_t _size;
};
 
int main() 
{
     Stack s;
     s.Init(10);
     s.Push(1);
     s.Push(2);
     s.Push(3);
     cout << s.Top() << endl;
     s.Destroy();
     return 0;
}

2.类的定义

class className
{
        // 类体：由成员函数和成员变量组成
};      // 一定要注意后面的分号

class为定义类的关键字，ClassName为类的名字，{}中为类的主体，注意类定义结束时后面分号不能省略。类体中内容称为类的成员：类中的变量称为类的属性或成员变量; 类中的函数称为类的方法或者成员函数。
类的两种定义方式：

1. 声明和定义全部放在类体中，需注意：成员函数如果在类中定义，编译器可能会将其当成内联函数处理。

//此时在person.cpp中

class person
{
public:
    void showinfo()
    {
        cout<<_name<<_sex<<age<<endl;
    }
public:
    char* _name;
    char* _sex;     
    int age;
};

2. 类声明放在.h文件中，成员函数定义放在.cpp文件中，注意：成员函数名前需要加类名::

//声明放在person.h中

class person
{
public:
    void showinfo()
        cout<<_name<<_sex<<age<<endl;

public:
    char* _name;
    char* _sex;     
    int age;
};


//定义在person.cpp中定义

include"person.h"

void person::showinfo()
{
    cout<<_name<<_sex<<age<<endl;
}

3.类的访问限定符

通过上面对类的观察，我们发现有一个“public:”的东西？实际上这个是类的访问限定符，除了public，还有private，proteced。

class Base 
{
public:
    // 公有成员
protected:
    // 受保护成员
private:
    // 私有成员
};

3.1访问限定符的使用说明：

public修饰的成员在类外可以直接被访问
protected和private修饰的成员在类外不能直接被访问(此处protected和private是类似的)
访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止
如果后面没有访问限定符，作用域就到}即类结束。
class的默认访问权限为private，struct为public(因为struct要兼容C)

3.2访问限定符的访问权限

我们可以看到，被private和proteced修饰的声明就无法使用了，那么我们怎么去用里面的声明呢？

public：可以被该类中的函数、子类的函数、友元函数访问，也可以由该类的对象访问；
protected：可以被该类中的函数、子类的函数、友元函数访问，但不可以由该类的对象访问；
private：可以被该类中的函数、友元函数访问，但不可以由子类的函数、该类的对象、访问。

4.类的作用域

类定义了一个新的作用域，类的所有成员都在类的作用域中。在类体外定义成员时，需要使用 :: 作用域操作符指明成员属于哪个类域。

class Person
{
public:
    void PrintPersonInfo();

private:
    char _name[20];
    char _gender[3];
    int  _age;
};
 
// 这里需要指定PrintPersonInfo是属于Person这个类域
void Person::PrintPersonInfo()
{
    cout << _name << " "<< _gender << " " << _age << endl;
}

5.类的实例化

用类类型创建对象的过程，称为类的实例化：

类是对对象进行描述的，是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它；比如：入学时填写的学生信息表，表格就可以看成是一个类，来描述具体学生信息。
一个类可以实例化出多个对象，实例化出的对象占用实际的物理空间，存储类成员变量Person类是没有空间的，只有Person类实例化出的对象才有具体的年龄。
做个比方。类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间

6.this指针

6.1this指针的引入

我们先来定义一个日期类 Date

#include <time.h>
#include<iostream>

using namespace std;

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, d2;
	d1.Init(2022, 1, 11);
	d2.Init(2022, 1, 12);
	d1.Print();
	d2.Print();
	return 0;
}

对于上述类，有这样的一个问题： Date类中有 Init 与 Print 两个成员函数，函数体中没有关于不同对象的区分，那当d1调用 Init 函数时，该函数是如何知道应该设置d1对象，而不是设置d2对象呢？

C++中通过引入this指针解决该问题，即：C++编译器给每个“非静态的成员函数“增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有“成员变量” 的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

6.2this指针的特性

. this指针的类型：类类型* const，即成员函数中，不能给this指针赋值。
只能在“成员函数”的内部使用(成员函数在第九节讲到)
this指针本质上是“成员函数”的形参，当对象调用成员函数时，将对象地址作为实参传递给 this形参。所以对象中不存储this指针。
this指针是“成员函数”第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递

九、类的成员函数

1.默认成员函数

默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。

构造函数
析构函数
拷贝构造函数
赋值运算符重载
const成员函数

2.构造函数

1.定义

名字与类名相同,创建类类型对象时由编译器自动调用，保证每个数据成员都有一个合适的初始值，并且在对象的生命周期内只调用一次（虽然名字叫构造函数，实际上是自动赋初始值）

2.特性

构造函数无返回值也不需要添加void的；构造函数没有函数类型；
构造函数的函数名称要与类名一致；
构造函数具有形参列表，并且可以发生函数重载；
编译器会自动调用构造函数，无需进行手动调用，并且有且只有调用一次；
如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成；
类型分成内置类型(基本类型)和自定义类型，如果是内置类型的话会生成随机值，为了解决此问题，C++11 中针对内置类型成员不初始化的缺陷，又打了补丁，即：内置类型成员变量在类中声明时可以给默认值；
无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数。

#include <iostream>

using namespace std;

class Person {
public:
	//发生了函数重载（假设第一个Person函数为Person1）
	Person(void)
	{
		cout << "Person(void)" << endl;
		Age = 100;
	}
	//发生了函数重载（假设第二个Person函数为Person2）
	Person(int age);
	int GetAge()
	{
		return Age;
	}
private:
	int Age;
};
Person::Person(int age)
{
	cout << "Person(int age)" << endl;
	Age = age;
}
int main()
{
	class Person a;//当实例化对象是这种形式时，编译器调用Person1函数；
	cout << a.GetAge() << endl;
	class Person b(99);//当实例化对象是class Person b(99); 编译器调用Person2函数
	cout << b.GetAge() << endl;
	return 0;
}

3.构造函数的分类

按照参数进行分类：有参构造和无参构造

格式：无参---类名（）{}   有参---类名（参数列表）{}
举例：无参---Person（void）{}  有参---Person（int a）{}

按照类型进行分类：普通构造函数和拷贝构造函数

格式：普通---类名（）{}    拷贝---类名（对象引用）{}
举例：普通---Person（int a）{}  拷贝---Person(const Person &a){}

拷贝构造函数，具有一般构造函数的特性。主要可以实现用现有的对象完成对新建对象的赋值（复制操作），使用const修饰，表示只读，不能修改引用参数。

4.构造函数调用

括号法（最常使用的方法）

格式： class 类名 对象名（参数值）;
举例： class Person b(10); --- 这就是括号调用法

显示法

格式： class 类名 对象名 = 类名（参数值）;
举例： class Person b = Person(10);  --- 隐式对象也是对象

隐式转化法（参数多的话不能用）

格式： class 类名 对象名 = 值;
举例： class person b = 10;

5,初始化列表

初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。

class Date
{
public:
    Date(int year, int month, int day)
    :_year(year)
    ,_month(month)
    ,_day(day)
    ,_year(year)
    ,_month(month)
    ,_day(day)

private:
    int _year;
    int _month;
    int _day;
};

5.1构造体函数赋值

在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值。

class Date
{
public:
     Date(int year, int month, int day)
     {
         _year = year;
         _month = month;
         _day = day;
     }
 
private:
    int _year;
    int _month;
    int _day;
};

虽然上述构造函数调用之后，对象中已经有了一个初始值，但是不能将其称为对对象中成员变量的初始化，构造函数体中的语句只能将其称为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值。

5.2注意事项

每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
类中包含以下成员，必须放在初始化列表位置进行初始化：

引用成员变量
const成员变量

自定义类型成员(且该类没有默认构造函数时)

class A
{
public:
    A(int a)
    :_a(a)
    {}
 
private:
    int _a;
};
 
class B
{
public:
    B(int a, int ref)
    :_aobj(a)
    ,_ref(ref)
    ,_n(10)
    {}
 
private:
    A _aobj;      
    // 没有默认构造函数
    int& _ref;    
    // 引用
    const int _n; // const 
};

尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。

class Time
{
public:
    Time(int hour = 0)
    :_hour(hour)
    {
         cout << "Time()" << endl;
    }
 
private:
    int _hour;
 };
 
class Date
{
public:
    Date(int day)
    {}
 
private:
    int _day;
    Time _t;
};

int main()
{
    Date d(1);
}

成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关

class A
{
public:
    A(int a)
    :_a1(a)
    ,_a2(_a1)
    {}
    void Print() 
    {
        cout<<_a1<<" "<<_a2<<endl;
    }
 
private:
    int _a2;
    int _a1;
};
 
int main() 
{
    A aa(1);
    aa.Print();
}

A. 输出1  1
B.程序崩溃
C.编译不通过
D.输出1  随机值

5.3explicit关键字

构造函数不仅可以构造与初始化对象，对于单个参数或者除第一个参数无默认值其余均有默认值的构造函数，还具有类型转换的作用。

class Date
{
public:
    // 1. 单参构造函数，没有使用explicit修饰，具有类型转换作用
    // explicit修饰构造函数，禁止类型转换---explicit去掉之后，代码可以通过编译
    explicit Date(int year)
    :_year(year)
    {}
    // 2. 虽然有多个参数，但是创建对象时后两个参数可以不传递，没有使用explicit修饰，具有类型转换作用
    // explicit修饰构造函数，禁止类型转换

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

    Date& operator=(const Date& d)
    {
        if (this != &d)
        {
              _year = d._year;
              _month = d._month;
              _day = d._day;
        }
        return *this;
    }
private:
      int _year;
      int _month;
      int _day;
};
 
void Test()
{
     Date d1(2022);
     // 用一个整形变量给日期类型对象赋值
     // 实际编译器背后会用2023构造一个无名对象，最后用无名对象给d1对象进行赋值
     d1 = 2023;
     // 将1屏蔽掉，2放开时则编译失败，因为explicit修饰构造函数，禁止了单参构造函数类型转换的作用
}

（上述代码可读性不是很好，用explicit修饰构造函数，将会禁止构造函数的隐式转换）

3.析构函数

1.定义

与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。

2.特性

析构函数名是在类名前加上字符 ~。
无参数无返回值类型。
一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构函数不能重载
对象生命周期结束时，C++编译系统系统自动调用析构函数。
编译器生成的默认析构函数，对自定类型成员调用它的析构函数。
如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，比如 Date类；有资源申请时，一定要写，否则会造成资源泄漏，比如Stack类。

#include <iostream>

using namespace std;

typedef int DataType;
class Stack
{
public:
	Stack(size_t capacity = 3)
	{
		_array = (DataType*)malloc(sizeof(DataType) * capacity);
		if (NULL == _array)
		{
			perror("malloc申请空间失败!!!");
			return;
		}
		_capacity = capacity;
		_size = 0;
	}
	void Push(DataType data)
	{
		// CheckCapacity();
		_array[_size] = data;
		_size++;
	}
	// 其他方法...
	~Stack()//析构函数
	{
		if (_array)
		{
			free(_array);
			_array = NULL;
			_capacity = 0;
			_size = 0;
		}
	}
private:
	DataType* _array;
	int _capacity;
	int _size;
};

int main()
{
	Stack s1;
	s1.Push(1);
	s1.Push(2);
	return 0;
}

4.拷贝函数

1.定义

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

#include <iostream>

using namespace std;

class Date
{
public:
	Date(int year = 2024, int month = 3, int day = 13)    // 构造函数
	{
		_year = year;
		_month = month;
		_day = day;
	}
	Date(const Date& d)      // 拷贝构造函数
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	void print()
	{
		cout << "今天的日期是 ：" << endl;
		cout << _year << '-' << _month << '-' << _day << endl;
	}
	~Date()                        // 析构函数
	{
		_year = 0;
		_month = 0;
		_day = 0;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1;
	d1.print();

	// 创建一个与已存在对象一某一样的新对象
	Date d2(d1);   // 拷贝构造
	d2.print();
	return 0;
}

2.特征

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

class Date
{
public:
   Date(int year = 1900, int month = 1, int day = 1)
   {
       _year = year;
       _month = month;
       _day = day;
   }
   // Date(const Date& d)   // 正确写法
   Date(const Date d)       // 错误写法：编译报错，会引发无穷递归
   {
         _year = d._year;
         _month = d._month;
         _day = d._day;
   }
private:
  int _year;
  int _month;
  int _day;
};

int main()
{
    Date d1;
    Date d2(d1);
    return 0;
}

若未显式定义，编译器会生成默认的拷贝构造函数。默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。注意：在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定义类型是调用其拷贝构造函数完成拷贝的。

class Time
 {
 public:
 ~Time()
 {
 cout << "~Time()" << endl;
 }
 private:
 int _hour;
 int _minute;
 int _second;
 };
 class Date
 {
 private:
 // 基本类型(内置类型)
 int _year = 1970;
 int _month = 1;
 int _day = 1;
 // 自定义类型
Time _t;
 };
 int main()
 {
 Date d;
 return 0;
 }

// 程序运行结束后输出：~Time()
// 在main方法中根本没有直接创建Time类的对象，为什么最后会调用Time类的析构函数？
// 因为：main方法中创建了Date对象d，而d中包含4个成员变量，其中_year, _month, _day三个是内置类型成员，销毁时不需要资源清理，最后系统直接将其内存回收即可；
//而_t是Time类对象，所以在d销毁时，要将其内部包含的Time类的_t对象销毁，所以要调用Time类的析构函数。但是main函数中不能直接调用Time类的析构函数，实际要释放的是Date类对象，所以编译器会调用Date
类的析构函数，而Date没有显式提供，则编译器会给Date类生成一个默认的析构函数，目的是在其内部调用Time类的析构函数，即当Date对象销毁时，要保证其内部每个自定义对象都可以正确销毁main函数中并没有直接调用Time类析构函数，而是显式调用编译器为Date类生成的默认析构函数
// 注意：创建哪个类的对象则调用该类的析构函数，销毁那个类的对象则调用该类的析构函数

如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，比如 Date类；有资源申请时，一定要写，否则会造成资源泄漏，比如Stack类。

3拷贝构造的产生

当类的对象去初始化另一个类的对象时

Date d1;
Date d2(d1);
Date d3 = d2;	//也会调用拷贝构造

当函数的形参是类的对象，调用函数进行形参和实参结合时（函数的调用实际上是拷贝）

void func(Date d)	//形参是类的对象
{
	d.Print();
}
 
int main(void)
{
	Date d1;
	func(d1);	//传参引发拷贝构造
	
	return 0;
}

当函数的返回值是对象，函数执行完成返回调用者时

Date func2()
{
	Date d(2023, 3, 24);
	return d;
}
 
int main(void)
{
	Date d1 = func2();
	d1.Print();
 
	return 0;
}

5.运算符重载

1.定义

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

返回值类型 operator操作符(参数列表)
{

}

//调用方式
operator 操作符(参数)
或者
。。。操作符。。。

2.特征

不能通过连接其他符号来创建新的操作符：比如operator@
重载操作符必须有一个类类型参数用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不能改变其含义
作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this
.* :: sizeof ?: . 注意以上5个运算符不能重载。

3.赋值运算符重载

赋值运算符格式：

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

class Date
{ 
public :
    Date(int year = 1900, int month = 1, int day = 1)
    {
           _year = year;
           _month = month;
           _day = day;
    }
    Date (const Date& d)
    {
           _year = d._year;
           _month = d._month;
           _day = d._day;
    }
    Date& operator=(const Date& d)
   {
        if(this != &d)
        {
             _year = d._year;
             _month = d._month;
             _day = d._day;
        }
        return *this;
 }
private:
     int _year ;
     int _month ;
     int _day ;
};

赋值运算符只能重载成类的成员函数不能重载成全局函数

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

// 赋值运算符重载成全局函数，注意重载成全局函数时没有this指针了，需要给两个参数
Date& operator=(Date& left, const Date& right)
{
    if (&left != &right)
    {
        left._year = right._year;
        left._month = right._month;
        left._day = right._day;
    }
    return left;
}

// 编译失败：
// error C2801: “operator =”必须是非静态成员

(原因：赋值运算符如果不显式实现，编译器会生成一个默认的。此时用户再在类外自己实现一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，故赋值运算符重载只能是类的成员函数)

用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝(浅拷贝)。注意：内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值。

class Time
{
public:
    Time()
    {
         _hour = 1;
         _minute = 1;
         _second = 1;
    }
    Time& operator=(const Time& t)
    {
        if (this != &t)
        {
             _hour = t._hour;
             _minute = t._minute;
             _second = t._second;
        }
        return *this;
    }
private:
      int _hour;
      int _minute;
      int _second;
};

class Date
{
private:
     // 基本类型(内置类型)
     int _year = 1970;
     int _month = 1;
     int _day = 1;
     // 自定义类型
     Time _t;
};

int main()
{
    Date d1;
    Date d2;
    d1 = d2;
    return 0;
}

(注意：如果类中未涉及到资源管理，赋值运算符是否实现都可以；一旦涉及到资源管理则必须要实现)

4.前置++和后置++重载

class Date
{
public:
     Date(int year = 1900, int month = 1, int day = 1)
     {
          _year = year;
          _month = month;
          _day = day;
     }
     // 前置++：返回+1之后的结果
     // 注意：this指向的对象函数结束后不会销毁，故以引用方式返回提高效率
     Date& operator++()
     {
          _day += 1;
          return *this;
     }

     // 后置++：
     // 前置++和后置++都是一元运算符，为了让前置++与后置++形成能正确重载
     // C++规定：后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器自动传递
     // 注意：后置++是先使用后+1，因此需要返回+1之前的旧值，故需在实现时需要先将this保存一份，然后给this+1
    //而temp是临时对象，因此只能以值的方式返回，不能返回引用
Date operator++(int)
{
      Date temp(*this);
      _day += 1;
      return temp;
}
private:
      int _year;
      int _month;
      int _day;
};


int main()
{
     Date d;
     Date d1(2022, 1, 13);
     d = d1++;    
     // d: 2022,1,13   d1:2022,1,14
     d = ++d1;    
     return 0;
}

6.const成员函数

1.定义

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

2.取地址及const取地址操作符重载

这两个默认成员函数一般不用重新定义，编译器默认会生成。

class Date
{ 
public :
    Date* operator&()
    {
         return this ;

    }
    const Date* operator&()const
    {
         return this ;
    }
private :
    int _year ; // 年
    int _month ; // 月
    int _day ; // 日
};

这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需要重载，比如想让别人获取到指定的内容！

十、static成员

1.定义

声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用 static修饰的成员函数，称之为静态成员函数。静态成员变量一定要在类外进行初始化

2.特性

静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区
静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明
类静态成员即可用类名::静态成员或者对象.静态成员来访问
静态成员函数没有隐藏的this指针，不能访问任何非静态成员
静态成员也是类的成员，受public、protected、private 访问限定符的限制

十一、友元

1.定义

我们在前面讲过如何访问类里面的私有成员有几种方法：通过函数，友元......
友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。友元分为：友元函数和友元类

2.通过函数访问私有成员

#include <iostream>

using namespace std;

class Date
{
public:
	int get(int a, int b, int c)//通过函数把_year,_month,_day的值改为了1，2，3
	{
		return _year = a, _month = b, _day = c;
	}
	void print()
	{
		cout << _year << _month << _day;
	}
	
private:
	int _year=10;
	int _month=20;
	int _day=30;
};

int main()
{
	Date p1;
	p1.get(1, 2, 3);//如果注释这行，那么最后的值是10，20，30
	p1.print();
	return 0;
}

3.友元函数

友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字。

class Date
{
    friend ostream& operator<<(ostream& _cout, const Date& d);
    friend istream& operator>>(istream& _cin, Date& d);
public:
    Date(int year = 1900, int month = 1, int day = 1)
    : _year(year)
    , _month(month)
    , _day(day)
    {}

private:
    int _year;
    int _month;
    int _day;
};
 
    ostream& operator<<(ostream& _cout, const Date& d)
    {
         _cout << d._year << "-" << d._month << "-" << d._day;
         return _cout;   
    }
    istream& operator>>(istream& _cin, Date& d)
    {
         _cin >> d._year;
         _cin >> d._month;
         _cin >> d._day;
         return _cin;
    }
int main()
{
    Date d;
    cin >> d;
    cout << d << endl;
    return 0;
}

注意：

友元函数可访问类的私有和保护成员，但不是类的成员函数
友元函数不能用const修饰
友元函数可以在类定义的任何地方声明，不受类访问限定符限制
一个函数可以是多个类的友元函数
友元函数的调用与普通函数的调用原理相同

4.友元类

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。
友元关系是单向的，不具有交换性。比如上述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。
友元关系不能传递如果C是B的友元， B是A的友元，则不能说明C时A的友元。
友元关系不能继承

class Time
{
    friend class Date;   
    // 声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成员变量

public:
    Time(int hour = 0, int minute = 0, int second = 0)
    : _hour(hour)
    , _minute(minute)
    , _second(second)
    {}
 
private:
    int _hour;
    int _minute;
    int _second;
};

class Date
{
public:
    Date(int year = 1900, int month = 1, int day = 1)
       : _hour(hour)
       , _minute(minute)
       , _second(second)
       {}

private:
      int _year;
      int _month;
      int _day;
 
      void SetTimeOfDate(int hour, int minute, int second)
      {
           // 直接访问时间类私有的成员变量
           _t._hour = hour;
           _t._minute = minute;
           _t._second = second;
      }
 
      Time _t;
};

十二、内部类

1.定义

如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。
注意：内部类就是外部类的友元类，参见友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。

2.特性

内部类可以定义在外部类的public、protected、private都是可以的。
注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。
izeof(外部类)=外部类，和内部类没有任何关系。

class A
{
private:
     static int k;
     int h;
 
public:
 
     class B // B天生就是A的友元
     {
         public:
         void foo(const A& a)
         {
              cout << k << endl;//OK
              cout << a.h << endl;//OK
         }
     };
};
 
int A::k = 1;
 
int main()
{
    A::B b;
    b.foo(A());
    return 0;
}

十三、匿名对象

1.定义

在C++中，匿名对象（Anonymous Object）是指在没有被命名的情况下创建的临时对象。它们通常用于在单个语句中执行一系列操作或调用某个函数，并且不需要将其结果存储到变量中。 匿名对象的创建非常简单，只需在类名后面使用一对空括号。

class A
{
public:
    A(int a = 0)
    :_a(a)
    {
        cout << "A(int a)" << endl;
    }
    ~A()
    {
        cout << "~A()" << endl;
    }
 
private:
       int _a;
};
 
class Solution 
{
public:
     int Sum_Solution(int n) 
     {
     //...
     return n;
     }
};

int main()
{
    A aa1;
    // 不能这么定义对象，因为编译器无法识别下面是一个函数声明，还是对象定义
    //A aa1();
    // 但是我们可以这么定义匿名对象，匿名对象的特点不用取名字，
    // 但是他的生命周期只有这一行，我们可以看到下一行他就会自动调用析构函数
    A();
    A aa2(2);
    // 匿名对象在这样场景下就很好用，当然还有一些其他使用场景，这个我们以后遇到了再说
    Solution().Sum_Solution(10);
    return 0;
}