一.数据的输入

• 语法：cin>>变量

二.数据的输出

• 语法：cout<<输出项<<endl
  • endl相当于\n
  • 输出项可以是字符串，也可以是变量

三.内存分区模型

1. 意义
   • 对不同区域存放的数据赋予不同的生命周期
2. 分区

   • 代码区：存放函数体的二进制代码，由操作系统进行管理

     • 程序执行前出现
     • 存放CPU执行的机器指令
     • 代码区数据共享（不用反复生成）
     • 代码区数据只读（不可修改）

   • 全局区：存放全局变量和静态变量以及常量（const修饰的全局常量和字符串常量）

     • 程序执行前出现
     • 存储全局变量和静态变量和常量
     • 程序执行 完后由操作系统释放

   • 栈区：由编译器自动分配释放，存放函数的参数值，局部变量，局部常量，形参数据等

     • 注意：不要返回局部变量的地址，栈区开辟的数据由编译器自动释放

       • 如：

         #include<iostream>
         using namespace std;
         
         int* func()
         {
         	int a = 10;
         	return &a;//返回局部变量的地址
         }
         
         int main()
         {
         	int* p = func();
         	cout << *p << endl;//#10    第一次打印正确数字因为编译器替你保留了一次
         	cout << *p << endl;//#？？？第二次这个数据就不保留了(visual studio2022编译器会一直保留)
         
         	system("pause");
         
         	return 0;
         }
         

   • 堆区：由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收

     • 在c++中主要利用new在堆区开辟内存
       • 语法：int *p=new int(10) int *arr=new int[10]
         • new int(10) 返回的是开辟的内存的首地址，所以用指针去接收
         • (10)表示初始值为10
         • [10]表示开辟10个元素
     • 在c++中主要利用delete在堆区释放内存
       • 语法：delete p delete[] arr
         • p是之前开辟的内存地址，直接delete内存地址即可释放
         • 释放数组空间需要加[]

四.引用

1. 作用：给变量取别名，共用同一个内存空间
2. 语法：数据类型 &别名=原名
3. 注意事项
   • 引用必须初始化
     • 错误：

       int &b;
       

   • 引用在初始化后不可以改成别的别名
     • 错误：

       int &b=a;
       int &b=c;//更改引用成别的变量的别名会报错
       

4. 引用形参
   • 作用：用形参修饰实参
   • 有点：比指针方便
   • 函数参数传递对比

     1. 值传递（形参不修饰实参）

        //1.值传递
        void val_swap(int a, int b)
        {
        	int temp = a;
        	a = b;
        	b = temp;
        }
        
        int main()
        {
        	int a = 10;
        	int b = 20;
        	val_swap(a, b);
        	cout << a << " " << b << endl;
        
        	system("pause");
        	return 0;
        }
        

        

     2. 地址传递（形参修饰实参）

        //2.地址传递
        void address_swap(int *a, int *b)
        {
        	int temp = *a;
        	*a = *b;
        	*b = temp;
        }
        
        int main()
        {
        	int a = 10;
        	int b = 20;
        	val_swap(&a, &b);
        	cout << a << " " << b << endl;
        
        	system("pause");
        	return 0;
        }
        

        

     3. 引用传递（形参修饰实参）

        //3.引用传递
        void quote_swap(int &a, int &b)
        {
        	int temp = a;
        	a = b;
        	b = temp;
        }
        
        int main()
        {
        	int a = 10;
        	int b = 20;
        	quote_swap(a, b);
        	cout << a << " " << b << endl;
        
        	system("pause");
        	return 0;
        }
        

        

5. 引用做函数返回值

   • 作用：作为函数返回值

   • 注意：不要返回局部变量的引用

   • 代码：

     int& test1()
     {
     	int a = 10;
     	return a;
     }
     
     int main()
     {
     	int &ref = test1();
     	cout << ref << endl;//10
     	cout << ref << endl;//？？？(但是visual studio 2022编译器永久保留了内存，所以也是10)
     
     	system("pause");
     
     	return 0;
     }
     

     int& test2()
     {
     	static int a = 10;//堆区的静态变量
     	return a;
     }
     
     int main()
     {
     	int &ref1 = test2();
     	cout << ref1 << endl;//10
     	cout << ref1 << endl;//10
     
     	test2() = 1000;//左值（作为等号左边）
     	cout << test2() << endl;//1000 a的别名是test2()
     	cout << ref1 << endl;//1000 a的别名是ref1
     
     	system("pause");
     	return 0;
     }
     

6. 引用的本质

   • 本质：指针常量（指针的指向不可以修改，指针指向的值是可以改动的）（引用相当于加了一个限制（不可以指向别的地方）的指针）（转换出来的const修饰的是变量名，即地址，所以指向不可以修改）

   • 代码：

     //引用的本质(编译器自动将引用转化成指针常量形式)
     void func(int &quote)//->void func(int *const quote)
     {
     	quote = 30;//->*quote=30
     }
     int main()
     {
     	int a = 10;
     	int &quote = a;//->int *const quote=&a
     	quote = 20;//->*quote=20
     	cout << a << endl;
     	cout << quote << endl;//->cout<<*quote<<endl;
     
     	func(a);//->func(&a)
     	cout << a << endl;
     	cout << quote << endl;//->cout<<*quote<<endl;
     
     	//稍后更新引用作为左值的转换
     
     	system("pause");
     	return 0;
     }
     

7. 常量引用

   • 本质：（指针的指向不可以修改，指针指向的值是也不可以修改）

   • 作用:常量引用主要用来修饰形参，防止形参改变实参

     //常量引用
     void func(const int& ref)
     {
     	//无法通过修改ref的值去改变main中的值,防止误操作
     	//ref = 1000;
     	cout << ref << endl;
     }
     
     int main()
     {
     	//引用本身需要一个合法的内存空间，所以下面注释掉的这行是错误的，得用下下行
     	//int& ref = 10;
     	const int &ref = 10;//->const int temp=10;const int &ref=temp;
     
     	int a = 10;
     	func(a);
     	system("pause");
     	return 0;
     }
     

五.函数（区别于C语言）

1. 函数默认参数

   • 语法：返回值类型 函数名(参数1,参数2=默认值，参数3=默认值，···){}

   • 注意：

     1. 如果形参列表中某个位置有了默认值，那么这个位置之后所有位置都要先设置默认值
     2. 如果函数声明有默认参数，函数实现中就不能写默认参数，否则会出现二义性

   • 代码：

     //函数默认参数
     int func(int a, int b = 10, int c = 20)
     {
     	return a + b + c;
     }
     
     int main()
     {
     	cout << func(10,30) << endl;
     
     	system("pause");
     	return 0;
     }
     

2. 函数占位参数（占位参数也可以有默认参数）
   • 语法：返回值类型 函数名(数据类型){} 返回值类型 函数名(数据类型 = 值){}
   • 注意：调用带占位参数的函数需要填补占位参数
   • 代码：

     //函数占位参数
     void func(int a, int)
     {
     	cout << "不知道有啥用" << endl;
     }
     
     int main()
     {
     	func(10, 20);
     
     	system("pause");
     	return 0;
     }
     

3. 函数重载
   • 作用：函数名可以相同，提高复用性
   • 函数重载满足条件：
     • 同一个作用域下
     • 函数名称相同
     • 函数参数类型不同或者参数个数不同或者参数顺序不同
   • 注意：
     1. 函数的返回值不可以进行函数重载
     2. 形参名字不同不可以进行函数重载
        • 代码：

          void func()
          {
          	cout << "func()的调用" << endl;
          }
          
          //参数类型不同
          void func(int a)
          {
          	cout << "func(int a)的调用" << endl;
          }
          
          void func(double a)
          {
          	cout << "func(double a)的调用"<<endl;
          }
          
          //参数个数不同
          void func(int a, double b)
          {
          	cout << "func(int a, double b)的调用" << endl;
          }
          
          //参数顺序不同
          void func(double a, int b)
          {
          	cout << "func(double a, int b)的调用" << endl;
          }
          
          int main()
          {
          	func();//第一个函数的调用
          	func(10);//第二个函数的调用
          	func(10.0);//第三个函数的调用
          	func(10, 10.0);//第四个函数的调用
          	func(10.0, 10);//第五个函数的调用
          }
          

     3. 引用作为重载条件

        • 代码：

          //1.引用作为重载的条件
          void func(int &a)
          {
          	cout << "func(int &a)调用" << endl;
          }
          
          void func(const int &a)//引用常量
          {
          	cout << "func(const int &a)调用" << endl;
          }
          
          int main()
          {
          	int a = 0;
          	func(a);//第一个函数被调用
          	func(0);//第二个函数被调用
          
          	system("pause");
          	return 0;
          }
          

     4. 函数重载碰到函数默认参数(写函数重载时尽量不要有默认参数，否则容易出现如下的二义性)

        • 代码：

          //2.函数重载碰到默认参数
          void func(int a,int b=10)
          {
          	cout << "func(int a,int b=10)调用" << endl;
          }
          
          void func(int a)//引用常量
          {
          	cout << "func(int a)调用" << endl;
          }
          
          int main()
          {
          	//func(10);//这样是调用不了的
          	func(10, 20);//这样才能调用
          
          
          	system("pause");
          	return 0;
          }
          

六.类和对象

1. C++面向对象特性：封装、继承、多态

2. 类和结构体的唯一区别

   • struct的默认权限为公共，class默认权限为私有

3. 封装

   • 封装的意义
     • 将属性和行为作为一个整体，表现生活中的事物
       • 语法：

         class 类名 
         {
         	访问权限
         	属性
         	行为
         };
         类名 变量名;
         

     • 将属性和行为加以权限控制

       • 访问权限

         权限	语法	特点	继承方面特点
         公共权限	public	类内可以访问，类外可以访问
         保护权限	protected	类内可以访问，类外不可以访问	子类继承父类后可以访问
         私有权限	private	类内可以访问，类外不可以访问	子类继承父类后还是不可以访问

   • 一般通过访问公共成员函数去对私有成员属性进行读写操作
     • 优点
       • 自己控制读写权限
       • 检测用户输入数据是否有效
     • 代码：

       class Person
       {
       public:
       	//可读可写
       	void setName(string name)
       	{
       		m_Name = name;
       	}
       	string getName()
       	{
       		return m_Name;
       	}
       	//只读
       	int getAge()
       	{
       		m_Age = 0;
       		return m_Age;
       	}
       
       	//只写
       	void setFriend(string Friend)
       	{
       		m_friend = Friend;
       	}
       
       
       private:
       	string m_Name;
       	int m_Age;
       	string m_friend;
       };
       
       int main()
       {
       	Person p;
       
       	p.setName("张三");
       	cout << p.getName() << endl;
       
       	cout << p.getAge() << endl;
       
       	p.setFriend("friend");
       
       	
       
       	system("pause");
       	return 0;
       }
       

4. 对象特性

   1. 对象的初始化和清理

      1. 构造函数（自动调用）
         • 作用：创建对象时为对象的成员属性赋值
         • 语法：类名(){};
         • 特点：
           1. 无返回值，也不写void
           2. 构造函数的函数名就是该类的类名
           3. 构造函数可以有形参，可发生重载
           4. 在调用对象时系统自动调用且只调用一次
           5. 需要注意构造函数也有访问权限，如果不声明公共权限，类外创建对象会无法自动调用构造函数，会报错
         • 分类：
           1. 按参数分类：
              1. 有参构造
                 • 语法：类名(数据类型 变量名){};
              2. 无参构造（默认构造）
                 • 语法：类名(){};
           2. 按类型分类：
              1. 普通构造
              2. 拷贝构造
                 • 调用时机（黑马P108，没听懂，太难了）
                   1. 使用一个已经创建完毕的对象来初始化一个新对象
                   2. 值传递的方式给函数参数传值
                   3. 以值方式返回局部对象
                      • 返回的是一个副本对象，与原本对象不在同一个内存空间
                 • 深拷贝与浅拷贝（如果成员属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题）

                   • 浅拷贝：简单的赋值拷贝操作（使用指针时先拷贝会指向同一片内存空间，前后两个指针指向同一块内存空间）

                   • 深拷贝：在堆区重新申请空间，进行拷贝操作（在自己写的拷贝构造函数中重新申请空间）（使用指针时深拷贝会指向别的地方的内存空间，前后两个指针之间没有交集）

                   • 代码：

                     #include<iostream>
                     using namespace std;
                     
                     
                     class Person
                     {
                     public:
                     	Person()
                     	{
                     		cout << "默认构造" << endl;
                     	}
                     	Person(int age,int height)
                     	{
                     		m_Age = age;
                     		m_Height = new int(height);//括号内放的是元素
                     		cout << "有参构造" << endl;
                     	}
                     	Person(const Person& p)
                     	{
                     		cout << "深拷贝构造" << endl;
                     		m_Age = p.m_Age;
                     		//m_Height = p.m_Height;//这是编译器默认实现的代码，是浅拷贝
                     		m_Height = new int(*p.m_Height);//深拷贝
                     	}
                     	~Person()
                     	{
                     		if (m_Height != NULL)
                     		{
                     			delete m_Height;
                     			m_Height = NULL;
                     		}
                     
                     	}
                     	int m_Age;
                     	int *m_Height;
                     };
                     
                     void  test1()
                     {
                     	Person p1(10,160);
                     	cout << p1.m_Age <<*p1.m_Height<< endl;
                     	Person p2(p1);
                     	cout << p2.m_Age << *p2.m_Height<<endl;
                     }
                     int main()
                     {
                     	test1();
                     
                     	system("pause");
                     	return 0;
                     }
                     

         • 调用方式
           1. 括号法

              • 注意：调用默认构造函数时不要加()，即不要类名 变量名();,因为编译器会认为i这是函数的声明；

              • 代码：

                	//1.括号法
                	Person p1(10);//使用有参构造
                	Person p2(p1);//使用拷贝构造
                	cout << p1.age << p2.age<<endl;//1010
                

           2. 显式法

              • 注意：

                • 类名(实参);是匿名对象，当前行执行结束后，系统会立即回收掉匿名对象

                • 不要利用拷贝构造函数初始化匿名对象，编译器会自动去掉括号认为在定义，就会出现重定义报错

                • 代码：

                  	Person p1 = Person(10);//使用有参构造
                  	Person p2 = Person(p1);//使用拷贝构造
                  
                  	Person(10);//匿名对象 对
                  	Person(p1);//错
                  	Person(p2);//错
                  

              • 代码：

                	//2.显示法
                	Person p1 = Person(10);//使用有参构造
                	Person p2 = Person(p1);//使用拷贝构造
                

           3. 隐式转换法

              • 代码：

                	//3.隐式转换法
                	Person p4 = 10;//->Person p4=Person(10)//使用有参构造
                	Person p5 = p4;//->Person p5=Person(p4)//使用拷贝构造
                

      2. 析构函数（自动调用）
         • 作用：在对象销毁前系统自动调用执行请理工作（将堆区开辟数据做释放）
         • 语法：~类名(){}
         • 特点：
           1. 无返回值，也不写void
           2. 析构函数的函数名就是~+该类的类名
           3. 析构函数不可以有形参，所以不可以发生重载
           4. 在销毁对象前系统自动调用且只调用一次

      • 代码：

        #include<iostream>
        using namespace std;
        
        class Person
        {
        public:
        	//1.构造函数
        	Person()
        	{
        		cout<<"Person构造函数调用" << endl;
        	}
        
        	//2.析构函数
        	~Person()
        	{
        		cout << "Person析构函数调用" << endl;
        	}
        };
        
        
        int main()
        {
        	Person person;//创建对象后就出现构造调用
        	system("pause");//按任意键后出现析构调用，因为main函数执行完后销毁了对象
        	return 0;
        }
        

      • 调用规则：

        • 首先默认情况下编译器至少给一个类添加3个函数：
          1. 默认构造函数（无参，函数体为空）
          2. 默认析构函数（无参，函数体为空）
          3. 默认拷贝构造函数，对属性进行值拷贝（参数为：const 类名 &变量名）
        1. 如果用户定义有参构造函数，c++不再提供默认的无参构造，但是会提供默认拷贝（即用户只提供有参，编译器不会提供无参，但提供拷贝）
           • 因此如果你只写有参构造，但不写默认构造，然后去调用默认构造编译器会报错
        2. 如果用户定义拷贝构造函数，c++不会再提供其他构造函数（即用户只提供拷贝，编译器不会提供无参，也不会提供有参）
           • 因此如果你只写拷贝构造，但不写默认构造和有参构造，然后去调用默认构造或有参构造编译器会报错

   2. 初始化列表

      • 语法：构造函数类名():属性1(值1或变量1)，属性2(值2或变量2){}

      • 代码：

        #include<iostream>
        using namespace std;
        
        class Person
        {
        public:
        
        	Person(int a,int b,int c):m_A(a),m_B(b),m_C(c)
        	{
        		;
        	}
        
        	int m_A;
        	int m_B;
        	int m_C;
        };
        int main()
        {
        	Person p(10,20,30);
        	cout << p.m_A << p.m_B << p.m_C << endl;
        	system("pause");
        	return 0;
        }
        

   3. 类对象作为类成员

      • 注意：

        1. 构造顺序：当其他类对象作为本类成员，构造时先构造类对象，再构造自身（先里再外）
        2. 析构顺序：当其他类对象作为本类成员，析构时先析构自身，再析构类对象（先外再里）

      • 代码

        #include<iostream>
        using namespace std;
        
        //类对象作为类成员
        class Phone
        {
        public:
        	Phone()
        	{
        		m_PhoneNum = 12345678901;
        	}
        	long long int m_PhoneNum;
        };
        
        class Person
        {
        public:
        	Phone m_Phone;
        };
        
        int main()
        {
        	Person p;
        	cout << p.m_Phone.m_PhoneNum << endl;//12345678901
        	system("pause");
        	return 0;
        }
        

   4. 静态成员（静态可以理解为共用）

      • 定义：在成员变量和成员函数前加上关键字static
      • 语法：static a； 或
      • 分类：
        1. 静态成员变量（全局区）
           • 所有对象共享同一份数据
           • 在编译阶段分配内存
           • 类内声明，类外初始化（类外定义）
             • 类内：static 变量类型 变量名;
             • 类外：变量类型 类名::变量名;
               • 表示定义类名作用域下变量名这个静态成员
           • 访问方式：
             1. 通过对象进行访问
                • 语法：类名 变量名;变量名.静态成员变量;
             2. 通过类名进行访问（类名作用域）
                • 语法：类名::静态成员变量;
        2. 静态成员函数
           • 所有对象共享同一个函数
           • 静态成员函数只能访问静态成员变量，不可以访问非静态成员变量
             • 因为当使用访问方式2去访问时，不知道改变的非静态成员变量是属于哪个对象的
           • 访问方式：
             1. 通过对象进行访问
                • 语法：类名 变量名;变量名.静态成员函数;
             2. 通过类名进行访问（类名作用域）
                • 语法：类名::静态成员函数;
      • 区别：
        • 静态成员函数不需要初始化（定义），和静态成员变量不同

   5. C++对象模型和this指针

      1. 成员变量和成员函数分开存储

         • 空对象占用内存空间为1

           • C++编译器会给每个空对象分配一个字节空间，是为了区分各个空对象占内存的位置，将它们分隔开（每一个空对象都应该有一个独一无二的空间）

         • 除了非静态成员变量属于类的对象，占用正常变量类型的字节，其余（静态成员变量，非静态成员函数，静态成员函数）都不属于类的对象，不占用字节

         • 代码

           class Person
           {
           public:
           	int m_A;//非静态成员变量，属于类的对象上//即属于p//占4字节
           	static int m_B;//静态成员变量，不属于类的对象上//即不属于p//所以占用字节为0
           	void func1() {};//非静态成员函数，也是不属于类的对象上//即不属于p//所以占用字节为0//比较特殊
           	static void func2(){}//静态成员半数，不属于类的对象上//即不属于p//所以占用字节为0
           };
           

      2. this指针

         • 本质：指针常量（this指针指向不可以修改,this指针指向的值是可以修改的）

         • 概念：this指针指向被调用的成员函数所属的对象（哪个对象调用了成员函数（得先调用成员函数，才能让this指针指向），this指针就指向谁）

         • 用途

           • 当形参和成员变量同名时，可以用this指针区分
           • 在类的非静态成员函数中返回对象本身，可以用return *this
             • 即this指针指向对象，解引用this即可得到对象

         • 代码：

           #include<iostream>
           using namespace std;
           
           class Person
           {
           public:
           	Person(int m_Age)
           	{
           		this->m_Age=m_Age;//this 指向调用了该成员函数的对象p,所以使用p->age去接收形参m_Age
           	}
           
           	//返回值用引用返回的就是对象本体，指向本身内存，如果不用引用返回的是对象副本，与对象没有关系，后续的操作就改变不了对象
           	Person &PersonAdd(Person& p)//不懂这里的返回值为什么是Person &,不能是Person或Person *
           	{
           		this->m_Age += p.m_Age;
           		//this是指向调用了这个函数的对象，在这里是p3
           		return *this;
           	}
           
           	int m_Age;
           };
           
           //1.解决名称冲突
           void test1()
           {
           	Person p1(10);
           	cout << p1.m_Age << endl;//10
           }
           
           //2.返回对象本身用*this 
           void test2()
           {
           	Person p2(1);
           	Person p3(2);
           	//链式编程思想//cout<<  <<也是链式编程思想
           	p3.PersonAdd(p2).PersonAdd(p2);//2+1+1//如果使用Person PersonAdd(p2)则这个地方会调用p3的默认拷贝构造函数，返回的是一个新副本，与p3不在同一个内存空间
           	cout << p3.m_Age << endl;//4
           }
           
           int main()
           {
           	test1();
           	test2();
           	system("pause");
           	return 0;
           }
           

      3. 空指针访问成员函数

         • 注意：有没有用到this指针，如果用来this指针就要加判断保证代码的健壮性

         • 代码：

           #include<iostream>
           using namespace std;
           
           //空指针调用成员函数
           
           class Person
           {
           public:
           	void showName()
           	{
           		cout << "Name" << endl;
           	}
           	void showAge()
           	{
           		if(this==NULL)//不懂这里为什么不是*this==NULL
           		{
           			return;
           		}
           		cout << m_Age<< endl;//这个报错原因是因为默认将m_Age变成this->m_Age,但此时this指向是NULL，所以报错
           	}
           	int m_Age = 10;
           };
           
           void test1()
           {
           	Person *p=NULL;//空指针
           	p->showName();
           	p->showAge();
           
           }
           
           int main()
           {
           	test1();
           	system("pause");
           	return 0;
           }
           

      4. const修饰成员函数

         • 常函数：

           • 成员函数后加const为常函数
             语法：函数返回类型 函数名() const{}
           • 常函数内不可以修改成员属性
             • 因为this指针(类名 *const this)(指针常量）变成了(const 类名 *const this)(常指针常量)（此时指针指向的值也不可以修改了）
           • 成员属性(成员变量)声明时加关键字mutable后，在常函数中依然可以修改

         • 常对象(不能通过对象.成员变量的方式修改成员变量值，除非成员变量声明时加关键字mutable）：

           • 声明对象前加const称该对象为常对象
           • 常对象只能调用常函数

         • 代码：

           #include<iostream>
           using namespace std;
           
           //常函数
           class Person
           {
           public:
           	void showPerson() const
           	{
           		//this->m_A = 100;//让指针指向的值也不可以改变
           		this->m_B = 100;//成员变量加mutable关键字后可以修改
           	}
           
           	void func()
           	{
           
           	}
           
           	int m_A;
           	mutable int m_B;//特殊变量，加上关键字mutable后，即使在常函数中，也可以修改这个值
           };
           
           
           
           int main()
           {
           	const Person p2;//常对象
           	//p2.m_A=10;//报错//常对象不能修改成员属性值，除非成员变量声明时前面加mutable
           	p2.m_B = 10;
           
           	//常对象只能调用常函数
           	p2.showPerson();
           	//p2.func();//报错//常对象不可以调用普通成员函数，因为普通成员函数可以修改成员属性值，而常对象定义就是不能修改成员属性值
           
           	system("pause");
           	return 0;
           }
           

5. 友元

   • 关键字：friend
   • 目的：让类外特殊的一些函数或者类访问改类中的私有成员
   • 友元的三种实现：
     1. 全局函数做友元

        • 语法：在类中写friend 函数声明即可在类外使用该函数对类中的私有属性进行访问

        • 代码：

          #include<iostream>
          #include <string>
          using namespace std;
          
          
          class Building
          {
          	//friend 加上这一句函数声明即可在类外使用该函数去访问私有属性
          	friend void goodGay(Building &building);
          public:
          	Building()
          	{
          		m_SittingRoom = "客厅";
          		m_BedRoom = "卧室";
          	}
          
          	string m_SittingRoom;//客厅
          private:
          	string m_BedRoom;//卧室
          };
          
          //全局函数
          void goodGay(Building &building)
          {
          	cout << building.m_SittingRoom << endl;
          	cout << building.m_BedRoom << endl;
          }
          
          void test1()
          {
          	Building b;
          	goodGay(b);
          }
          int main()
          {
          	test1();
          
          	system("pause");
          	return 0;
          }
          

     2. 类做友元

        • 语法：在类1中写friend 类2声明即可使用类2中的所有成员函数去访问类1的私有属性

        • 代码：

          #include<iostream>
          #include<string>
          using namespace std;
          
          //类做友元
          
          class Building;//类声明
          class GoodGay
          {
          	
          public:
          	GoodGay();//先在类内声明
          	void visit();//先在类内声明
          	Building *b;
          };
          
          class Building
          {
          	friend class GoodGay;//友元+类声明后可以使用该类去访问给出友元的类的私有属性
          public:
          	Building();//先在类内声明
          	string m_SittingRoom;
          private:
          	string m_BedRoom;
          };
          
          //再在类外写成员函数，需要声明在该类域下
          GoodGay::GoodGay()
          {
          	b = new Building;
          }
          
          void GoodGay::visit()
          {
          	cout << b->m_SittingRoom << endl;
          	cout << b->m_BedRoom << endl;//使用友元访问私有属性
          }
          
          
          //再在类外写成员函数，需要声明在该类域下
          Building::Building()
          {
          	m_SittingRoom = "客厅";
          	m_BedRoom = "卧室";
          };
          
          void test1()
          {
          	GoodGay g;
          	g.visit();
          }
          
          int main()
          {
          
          	test1();
          	system("pause");
          	return 0;
          }
          

     3. 成员函数做友元

        • 语法：在类1中写friend 成员函数返回类型 类2名字::成员函数名();即可使用类2中的该成员函数去访问类1的私有属性

        • 代码：

          #include<iostream>
          #include<string>
          using namespace std;
          
          class Building;
          class GoodGay
          {
          public:
          	GoodGay();
          
          	void visit();//让visit函数可以访问Building中私有成员
          	Building *b;
          };
          
          
          class Building
          {
          	friend void GoodGay::visit();//GoodGay类下的visit函数作为Building类的友元可以访问Building类的私有属性
          public:
          	Building();
          	string m_SittingRoom;
          private:
          	string m_BedRoom;
          };
          Building::Building()
          {
          	m_SittingRoom = "客厅";
          	m_BedRoom = "卧室";
          }
          
          GoodGay::GoodGay()
          {
          	b = new Building;
          }
          
          void GoodGay::visit()
          {
          	cout << b->m_SittingRoom << endl;
          	cout << b->m_BedRoom << endl;
          }
          
          void test()
          {
          	GoodGay g;
          	g.visit();
          }
          int main()
          {
          	test();
          	system("pause");
          	return 0;
          }
          

6. 类外写成员函数

   • 代码：

     class Building;
     class GoodGay
     {
     	
     public:
     	GoodGay();//先在类内声明
     	void visit();//先在类内声明
     	Building *b;
     };
     
     class Building
     {
     public:
     	Building();//先在类内声明
     	string m_SittingRoom;
     private:
     	string m_BedRoom;
     };
     
     //再在类外写成员函数，需要声明在该类域下
     GoodGay::GoodGay()
     {
     	b = new Building;
     }
     
     void GoodGay::visit()
     {
     	cout << b->m_SittingRoom << endl;
     }
     
     
     //再在类外写成员函数，需要声明在该类域下
     Building::Building()
     {
     	m_SittingRoom = "客厅";
     	m_BedRoom = "卧室";
     };
     

7. 运算符重载

   • 运算符重载概念：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型
   • 注意：
     1. 编译器会自动简化运算符
     2. 运算符重载也可以发生函数重载
     3. 对于内置的数据类型的表达式的运算符是不可能改变的，比如（1+1=2，float,int等数据类型），自定义的数据类型才可以改变
     4. 不要滥用运算符重载
     5. *使用链式编程时：链式编程需要返回自身对象(this);返回类型需要用引用(类型 &)，否则只能返回副本
   • 常用：成员函数和全局函数进行运算符重载
   • 分类：
     1. 加号运算符重载

        • 关键：operator<<

        • 作用：实现两个自定义数据类型相加的运算

        • 代码：

          #include<iostream>
          using namespace std;
          
          //加号运算符重载
          
          //1.成员函数重载+号
          class Person1
          {
          public:
          	Person1()
          	{
          		m_A = 10;
          		m_B = 20;
          	}
          	Person1 operator+(Person1& p)
          	{
          		Person1 temp;
          		temp.m_A = this->m_A + p.m_A;
          		temp.m_B = this->m_B + p.m_B;
          		return temp;
          	}
          
          	int m_A;
          	int m_B;
          };
          void test1()
          {
          	Person1 p1;
          	Person1 p2;
          	Person1 p3 = p1+p2;//被编译器简化了，原本应该写成Person1 p3 = p1.operator+(p2);
          	cout << p3.m_A << " " << p3.m_B << endl;//20 40
          }
          
          
          
          //2.全局函数重载+号
          class Person2
          {
          public:
          	Person2()
          	{
          		m_A = 10;
          		m_B = 20;
          	}
          	int m_A;
          	int m_B;
          };
          
          Person2 operator+(Person2 &p1, Person2 &p2)
          {
          	Person2 temp;
          	temp.m_A = p1.m_A + p2.m_A;
          	temp.m_B = p1.m_B + p2.m_B;
          	return temp;
          }
          
          void test2()
          {
          	Person2 p1;
          	Person2 p2;
          	Person2 p3 = p1 + p2;//被编译器简化了，原本应该写成Person2 p3 = operator+(p1,p2);
          	cout << p3.m_A << " " << p3.m_B << endl;//20 40
          }
          
          //3.全局函数使用函数重载+号
          class Person3
          {
          public:
          	Person3()
          	{
          		m_A = 10;
          		m_B = 20;
          	}
          	int m_A;
          	int m_B;
          };
          
          Person3 operator+(Person3& p1, int num)
          {
          	Person3 temp;
          	temp.m_A = p1.m_A + num;
          	temp.m_B = p1.m_B + num;
          	return temp;
          }
          
          void test3()
          {
          	Person3 p1;
          	Person3 p3 = p1 + 100;//被编译器简化了，原本应该写成Person3 p3 = operator+(p1,100);
          	cout << p3.m_A << " " << p3.m_B << endl;//110 120
          }
          
          int main()
          {
          	test1();
          	test2();
          	test3();
          	system("pause");
          	return 0;
          }
          

     2. 左移运算符重载

        • 关键：operator<<

        • 作用：自定义<<

        • 注意：

          1. 一般不用成员函数进行左移运算符重载，而是使用全局函数
          2. 重载左移运算符配合友元可以实现输出自定义数据类型

        • 代码：

          #include<iostream>
          using namespace std;
          
          1.成员函数重载左移运算符
          //class Person1
          //{
          //public:
          //	Person1()
          //	{
          //		m_A = 10;
          //		m_B = 20;
          //	}
          //	//通常不会利用成员函数重载<<运算符，因为无法实现cout在左侧
          //	//p.operator<<cout 简化：p<<cout
          //	//void operator<<(cout)
          //	//{
          //
          //	//}
          //	int m_A;
          //	int m_B;
          //};
          //
          //void test1()
          //{
          //	Person1 p1;
          //	cout << p1 << endl;
          //}
          
          
          //2.成员函数重载左移运算符
          class Person2
          {
          	friend ostream& operator<<(ostream& cout, Person2& p2);//简化为 cout<<p
          public:
          	Person2()
          	{
          		m_A = 10;
          		m_B = 20;
          	}
          private:
          	int m_A;
          	int m_B;
          };
          
          ostream &operator<<(ostream &cout, Person2 &p2)//简化为 cout<<p
          {
          	cout << "m_A=" << p2.m_A << "m_B=" << p2.m_B ;
          	return cout;
          }
          void test2()
          {
          	Person2 p2;
          	cout << p2<<"hi" << endl;//可是这时用了endl后时传参给p2吗，好奇怪//因为这里发生了函数重载，endl或者"hi"的类型和Person2不同,所以不会调用自定义左移运算符，而是用系统自带的
          }
          int main()
          {
          	//test1();
          	test2();
          	system("pause");
          	return 0;
          }
          

     3. 递增运算符重载

        • 关键：

          1. 前置递增：operator++()
          2. 后置递增：operator++(int)

        • 作用：通过重载递增运算符，实现自己的整型数据

        • 注意：

          1. 前置递增需要返回引用
          2. 后置递增不能返回引用（因为是局部对象，函数执行完后会被释放掉），要返回值

        • 代码：

          #include<iostream>
          using namespace std;
          
          //重载递增运算符
          
          //自定义整形
          class MyInteger
          {
          	friend ostream &operator<<(ostream& cout, MyInteger myint);
          public:
          	MyInteger()
          	{
          		m_Num = 0;
          	}
          
          	//重载前置++运算符//不需要传参
          	MyInteger &operator++()//返回类型得用引用，不用引用的话只是副本//返回引用是为了一直对一个数据进行递增操作
          	{
          		this->m_Num++;//先自身做加加运算
          
          
          		return *this;//再对自身做一个返回
          	}
          
          	//重载后置++运算符
          	MyInteger operator++(int)//int（也只能用int）代表占位参数，可以用于区分前置递增运算符和后置递增运算符//不能返回引用，因为函数执行完后temp会被释放掉，需要一个副本
          	{
          		//先 记录此时的结果
          		MyInteger temp = *this;//temp是局部对象，不能返回引用，因为函数执行完后temp会被释放掉
          
          		//后 让自身的值++
          		this->m_Num++;
          
          		//最后将之前记录的结果返回
          		return temp;
          	}
          private:
          	int m_Num;
          };
          
          //重载<<运算符
          ostream &operator<<(ostream& cout, MyInteger myint)
          {
          	cout << myint.m_Num;
          	return cout;
          }
          
          void test1()
          {
          	MyInteger myint;
          	cout << ++myint << endl;
          }
          
          void test2()
          {
          	MyInteger myint;
          	cout << (myint++)++ << endl;
          	cout << myint << endl;
          }
          
          int main()
          {
          	//test1();
          	test2();
          	system("pause");
          	return 0;
          }
          

     4. 赋值运算符号重载

        • 关键：operator=

        • c++编译器至少给一个类加4个函数：

          1. 默认构造函数(无参，函数体为空)
          2. 默认析构函数(无参，函数体为空)
          3. 默认拷贝构造函数，对属性进行值拷贝
          4. 赋值运算符operator=,对属性进行值拷贝

        • 注意：

          1. 如果类中有属性指向堆区，做赋值操作时也会出现深浅拷贝问题

        • 代码：

          #include<iostream>
          using namespace std;
          
          class Person
          {
          public:
          	Person(int age)
          	{
          		m_Age=new int(age);
          	}
          
          	~Person()
          	{
          		if (m_Age != NULL)
          		{
          			delete m_Age;
          			m_Age = NULL;
          		}
          	}
          
          	//重载赋值运算符
          	Person &operator=(Person &p)
          	{
          		//编译器提供的浅拷贝
          		//m_Age = p.m_Age;
          
          		//先判断此对象是否有属性在堆区，如果有先释放干净，然后再深拷贝，直接赋值会内存泄露
          		if (m_Age != NULL)
          		{
          			delete m_Age;
          			m_Age = NULL;
          		}
          
          		//深拷贝
          		m_Age = new int(*p.m_Age);
          
          		//返回对象自身
          		return *this;
          	}
          
          	int *m_Age;
          };
          
          void test1()
          {
          	Person p1(18);
          	Person p2(20);
          	Person p3(30);
          	p3 = p2 = p1;//链式编程需要返回自身对象(*this);返回类型需要用引用(类型 &)，否则只能返回副本
          	cout << "p1的年龄为：" << *p1.m_Age << endl;//18
          	cout << "p2的年龄为：" << *p2.m_Age << endl;//18
          	cout << "p3的年龄为：" << *p3.m_Age << endl;//18
          }
          
          
          int main()
          {
          	test1();
          	system("pause");
          	return 0;
          
          }
          

     5. 关系运算符重载

        • 关键:

          1. 相等：operator==
          2. 不相等：operator!=

        • 作用：重载关系运算符，可以让两个自定义类型对象进行对比操作

        • 代码：

          #include<iostream>
          #include<string>
          using namespace std;
          
          //重载关系运算符
          
          class Person
          {
          public:
          	Person(string name, int age)
          	{
          		m_Name = name;
          		m_Age = age;
          	}
          
          	bool operator==(Person &p)
          	{
          		if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
          		{
          			return true;
          		}
          		else
          		{
          			return false;
          		}
          	}
          
          	bool operator!=(Person &p)
          	{
          		if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
          		{
          			return false;
          		}
          		else
          		{
          			return true;
          		}
          	}
          
          	string m_Name;
          	int m_Age;
          };
          
          void test1()//重载==
          {
          	Person p1("a", 10);
          	Person p2("a", 10);
          	if (p1 == p2)
          	{
          		cout << "p1=p2" << endl;
          	}
          	else
          	{
          		cout << "p1!=p2" << endl;
          	}
          }
          
          void test2()//重载!=
          {
          	Person p1("a", 10);
          	Person p2("b", 10);
          	if (p1 != p2)
          	{
          		cout << "p1!=p2" << endl;
          	}
          	else
          	{
          		cout << "p1==p2" << endl;
          	}
          }
          
          int main()
          {
          	test1();
          	test2();
          	system("pause");
          	return 0;
          
          }
          

     6. 函数调用运算符重载

        • 关键：operator()()

        • 作用：将类作为函数来写，类似python中的__Call__方法,类名()即可调用 函数调用运算符重载 函数

        • 注意：

          1. 函数调用运算符()也可以发生重载
          2. 由于重载后使用的方式非常像函数的调用，因此称为仿函数
          3. 仿函数没有固定写法，非常灵活

        • 代码：

          #include<iostream>
          #include<string>
          using namespace std;
          
          //输出类
          class Myprint
          {
          public:
          	//重载函数调用运算符
          	void operator()(string text)
          	{
          		cout << text << endl;
          	}
          };
          
          void test1()
          {
          	Myprint myPrint;
          	myPrint("Hello World");//由于使用起来非常类似于函数调用，因此称为仿函数
          }
          
          
          //加法类
          class MyAdd
          {
          public:
          	int operator()(int a, int b)
          	{
          		return a + b;
          	}
          };
          
          
          void test2()
          {
          	//MyAdd myadd;
          	//cout<<myadd(10, 20) << endl;//30
          
          	//匿名函数的对象//MyAdd()创建了匿名对象，然后再调用重载运算符(10,20)
          	cout << MyAdd()(10, 20) << endl;//30
          }
          int main()
          {
          	test1();//Hello World
          	test2();//30
          	system("pause");
          
          	return 0;
          }
          

8. 继承

   • 继承是面向对象三大特性之一
   • 继承的基本语法：class 子类名：继承方式 父类名{}
     • 继承方式
       1. 公共继承
       2. 保护继承
       3. 私有继承
       • 示意图
         1. 父类中私有的内容什么继承方式都访问不到
         2. 公共继承访问时成员属性访问权限没有变化
         3. 保护继承访问时除了私有不能访问，其余访问权限都变成保护权限
         4. 私有继承访问时除了私有不能访问,其余访问权限都变成私有权限
     • 子类也称为派生类
       • 派生类包含基类成员和本类成员
       • 从基类从基类继承过来的表现其共性，而新增的成员体现了其个性
     • 父类也称为基类
   • 对象模型
     1. 父类中所有非静态成员属性都会被子类继承下去
        • 父类中私有成员也是被子类继承下去了，只是由编译器给隐藏后访问不到
   • 继承中的构造和析构
     • 顺序：先构造父类，再构造子类。再析构子类，再析构父类
   • 继承同名成员处理方式（即父类和子类同时拥有相同名字的成员）
     1. 直接访问就可以访问自身的同名成员，父类.成员名就是访问父类的成员，子类.成员名就是访问子类的成员
     2. 加作用域就可以通过子类去访问父类同名成员

     • 注意：

       • 如果子类中出现和父类同名的成员函数，子类的同名成员会隐藏掉父类中所有同名成员函数（包括父类中重载的），加作用域后就可以访问父类同名函数（包括父类重载的）

     • 代码：

       #include<iostream>
       using namespace std;
       
       //继承同名成员处理
       class A
       {
       public:
       	A()
       	{
       		m_A = 100;
       	}
       	void func()
       	{
       		cout << "父类" << endl;
       	}
       	int m_A;
       };
       
       
       class B :public A
       {
       public:
       	B()
       	{
       		m_A = 200;
       	}
       	void func()
       	{
       		cout << "子类" << endl;
       	}
       	int m_A;
       };
       
       void test1()
       {
       	A a;
       	B b;
       	cout << a.m_A << endl;//父类100
       	cout << b.m_A << endl;//子类200
       	cout << b.A::m_A << endl;//父类100
       
       }
       
       void test2()
       {
       	A a;
       	a.func();//父类
       	B b;
       	b.func();//子类
       	b.A::func();//父类
       }
       
       int main()
       {
       	test1();
       	test2();
       	system("pause");
       	return 0;
       }
       

   • 继承同名静态成员处理方式（和非静态成员处理方式一致）

     • 代码：

       #include<iostream>
       using namespace std;
       
       //继承同名静态成员处理
       class A
       {
       public:
       
       	static void func()
       	{
       		cout << "父类" << endl;
       	}
       	static int m_A;
       };
       int A::m_A = 100;
       
       class B :public A
       {
       public:
       	static void func()
       	{
       		cout << "子类" << endl;
       	}
       	static int m_A;
       };
       int B::m_A = 200;
       
       //属性
       void test1()
       {
       	//1.通过对象来访问数据
       	cout << "通过对象来访问数据" << endl;
       	A a;
       	B b;
       	cout << a.m_A << endl;//父类100
       	cout << b.m_A << endl;//子类200
       	cout << b.A::m_A << endl;//父类100
       
       	//2.通过类名来访问数据
       	cout << "通过类名来访问数据" << endl;
       	cout << A::m_A << endl;//父类100
       	cout << B::m_A << endl;//子类200
       	//第一个双冒号表示通过类名方式访问//第二个双冒号表示访问父类作用域下
       	cout << B::A::m_A << endl;//父类100
       
       }
       
       //函数
       void test2()
       {
       	//1.通过对象来访问函数
       	cout << "通过对象来访问函数" << endl;
       	A a;
       	a.func();//父类
       	B b;
       	b.func();//子类
       	b.A::func();//父类
       
       	//2.通过类名来访问函数
       	cout << "通过类名来访问函数" << endl;
       	A::func();//父类
       	B::func();//子类
       	//第一个双冒号表示通过类名方式访问//第二个双冒号表示访问父类作用域下
       	B::A::func();//父类
       }
       
       int main()
       {
       	test1();
       	test2();
       	system("pause");
       	return 0;
       }
       

   • 多继承语法

     • 语法：class 子类：继承方式 父类1,继承方式 父类2{};

     • 注意：

       • C++实际开发中不建议用多继承
       • 多继承中父类出现同名情况时，通过子类去访问需要加作用域

     • 代码：

       #include<iostream>
       using namespace std;
       
       //多继承语法
       
       
       class A1
       {
       public:
       	A1()
       	{
       		m_A = 100;
       	}
       	int m_A;
       };
       
       class A2
       {
       public:
       	A2()
       	{
       		m_A = 200;
       	}
       	int m_A;
       };
       
       class B :public A1, public A2
       {
       public:
       	B()
       	{
       		m_C = 300;
       	}
       	int m_C;
       };
       
       void test()
       {
       
       	B b;
       	cout << sizeof(b) << endl;//12
       	cout << b.A1::m_A << endl;//100
       	cout << b.A2::m_A << endl;//200
       	cout << b.m_C << endl;//300
       
       }
       
       int main()
       {
       	test();
       
       	system("pause");
       	return 0;
       }
       

   • 菱形继承
     • 概念：
       1. 两个子类继承同一个父类，接着有一个新的类同时继承这两个子类，这种继承方式称为菱形继承，或者钻石继承
     • 示意图：
       
     • 使用虚继承(继承指针)可以解决会同时继承A中的两份相同数据的问题，使得数据只有一份
       • 语法：class B1:virtual 继承方式 A{}; 对中间的两个子类都写关键字virtual
         • A叫做虚基类

9. 多态（多种形态）(父类的指针或引用指向子类的对象)（一个函数有多种形态，使用不同的子类时对应同一个函数的不同具体实现）

   • 多态是C++面向对象三大特性之一

   1. 优点

      • 组织结构清晰
      • 可读性强
      • 对于前期和后期扩展一级维护性高

   2. 分类

      • 静态多态：函数重载和运算符重载属于静态多态，复用函数名
        • 静态多态的函数地址早绑定-编译阶段确定函数地址
      • 动态多态：派生类和虚函数实现运行时多态

        • 动态多态的函数地址晚绑定-运行阶段确定函数地址

        • 满足条件：

          1. 有继承关系
          2. 子类要重写（函数返回值类型，函数名，形参列表都完全相同）父类的虚函数

        • 使用方法：

          1. 父类的指针或者引用指向子类对象

        • 代码：

          #include<iostream>
          using namespace std;
          
          
          class Animal
          {
          public:
          	virtual void speak()//虚函数//可以实现地址晚绑定//一开始不能确定哪个类，得传进来才能确定
          	{
          		cout << "动物在说话" << endl;
          	}
          };
          
          //猫类
          class Cat :public Animal
          {
          public:
          	void speak()
          	{
          		cout << "小猫在说话" << endl;
          	}
          
          
          };
          
          void doSpeak(Animal &animal)//Animal &animal=Cat；
          {
          	animal.speak();
          
          }
          
          void test1()
          {
          	Cat cat;
          	doSpeak(cat);//小猫在说话//如果不用虚函数则是动物在说话
          }
          
          int main()
          {
          	
          	test1();
          
          	system("pause");
          	return 0;
          }
          

        • 实现流程：
          

   3. 多态实现计算器

      • 代码：

        #include<iostream>
        #include<string>
        using namespace std;
        
        
        //普通实现计算器
        class Calculator
        {
        public:
        
        	int getResult(string opr)
        	{
        		if (opr == "+")
        		{
        			return m_Num1 + m_Num2;
        		}
        		else if(opr=="-")
        		{
        			return m_Num1 - m_Num2;
        		}
        		else if (opr == "*")
        		{
        			return m_Num1 * m_Num2;
        		}
        	}
        
        
        	int m_Num1;
        	int m_Num2;
        };
        
        void test1()
        {
        	Calculator cal;
        	cal.m_Num1 = 10;
        	cal.m_Num2 = 20;
        	cout<<cal.getResult("+")<<endl;
        	cout<<cal.getResult("-")<<endl;
        	cout<<cal.getResult("*")<<endl;
        }
        
        //利用多态实现计算器
        
        //实现计算器抽象类
        class AbstractCalculator
        {
        public:
        	virtual int getResul()
        	{
        		return 0;
        	}
        
        	int m_Num1;
        	int m_Num2;
        };
        
        //加法计算器类
        class AddCalculator :public AbstractCalculator
        {
        public:
        	virtual int getResul()//这里的virtual关键字可加可不加
        	{
        		return m_Num1+m_Num2;
        	}
        };
        //减法计算器类
        class SubCalculator :public AbstractCalculator
        {
        public:
        	virtual int getResul()//这里的virtual关键字可加可不加
        	{
        		return m_Num1-m_Num2;
        	}
        };
        //乘法计算器类
        class MulCalculator :public AbstractCalculator
        {
        public:
        	virtual int getResul()//这里的virtual关键字可加可不加
        	{
        		return m_Num1*m_Num2;
        	}
        };
        
        
        void test2()
        {
        	//父类指针或者引用指向子类对象
        
        	//加法运算
        	AbstractCalculator* abc = new AddCalculator;
        	abc->m_Num1 = 10;
        	abc->m_Num2 = 20;
        
        	cout << abc->getResul() << endl;
        	delete abc;//因为用了new创建在堆区，所以需要手动释放
        
        	//减法运算
        	abc = new SubCalculator;
        	abc->m_Num1 = 10;
        	abc->m_Num2 = 20;
        
        	cout << abc->getResul() << endl;
        	delete abc;//因为用了new创建在堆区，所以需要手动释放	
        	
        	//乘法运算
        	abc = new MulCalculator;
        	abc->m_Num1 = 10;
        	abc->m_Num2 = 20;
        
        	cout << abc->getResul() << endl;
        	delete abc;//因为用了new创建在堆区，所以需要手动释放
        
        
        }
        
        int main()
        {
        	cout << "普通计算器实现" << endl;
        	test1();
        	cout << "多态计算器实现" << endl;
        	test2();
        
        	system("pause");
        	return 0;
        }
        

   4. 纯虚函数和抽象类

      • 纯虚函数

        • 语法：virtual 返回值类型 函数名(形参列表)=0;
          • 不需要{}内的内容了
        • 作用：在多态中，通常父类中的纯虚函数的实现是毫无意义的，主要都是调用子类重写的内容

      • 抽象类
        *概念：当类中有了纯虚函数，这个类也称为抽象类

        • 特点：
          1. 无法实例化对象
             • 类名 *指针变量并不是实例化对象，是可以使用的
          2. 子类必须重写抽象类中的纯虚函数，否则也属于抽象类

      • 代码:

        #include<iostream>
        using namespace std;
        
        //纯虚函数和抽象类
        class Base
        {
        public:
        	virtual void func() = 0;//纯虚函数，即完全没有意义的函数，不需要具体实现
        };
        
        
        class Son :public Base
        {
        public:
        };
        void test1()
        {
        	//Base b;//抽象类无法实例化对象
        	//new Base;//抽象类无法实例化对象
        
        	//Son s;//子类因为没有重写虚函数，所以也是抽象类，抽象类无法实例化对象
        	//new Son;//子类因为没有重写虚函数，所以也是抽象类，抽象类无法实例化对象
        }
        
        int main()
        {
        
        	system("pause");
        	return 0;
        }
        

   5. 虚析构和纯虚析构

      • 作用：解决在多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用子类的析构代码（如果子类中没有开辟的堆区数据，可以不把父类的析构写为虚析构或纯虚析构）

      • 虚析构和纯虚析构共性

        • 可以解决父类指针释放子类对象
        • 都需要有具体的函数实现

      • 虚析构和纯虚析构区别

        • 如果是纯虚析构，该类属于抽象类，无法实例化对象

      • 纯虚析构和纯虚函数区别

        • 纯虚析构需要类外定义，纯虚函数不需要类外定义，纯虚函数需要子类重写

      • 虚析构

        • 语法：virtual ~类名(){}

      • 纯虚析构（类内声明，类外定义）

        • 语法：virtual ~类名()=0;类名::(){具体实现}

      • 代码：

        #include<iostream>
        #include<string>
        using namespace std;
        
        //虚析构和纯虚析构
        
        class Animal
        {
        public:
        	Animal()
        	{
        		cout << "Animal构造函数调用" << endl;
        	}
        
        	利用虚析构可以解决父类指针释放子类对象不干净的问题
        	//virtual ~Animal()
        	//{
        	//	cout << "Animal析构函数调用" << endl;
        	//}
        
        	//纯虚析构 纯虚析构需要自己声明也需要自己实现
        	virtual ~Animal() = 0;
        
        	//纯虚函数
        	virtual void speak() = 0;
        };
        //纯虚析构
        Animal::~Animal()
        {
        	cout << "Animal析构函数调用" << endl;
        }
        
        class Cat :public Animal
        {
        public:
        	Cat(string name)
        	{
        		cout << "Cat构造函数调用" << endl;
        		m_Name=new string(name);//堆区创建了，需要释放
        	}
        	virtual void speak()
        	{
        		cout << *m_Name<<"小猫在说话" << endl;
        	}
        	 ~Cat()
        	{
        		cout << "Cat析构函数调用" << endl;
        		if (m_Name != NULL)//如果指针存储的地址不为空，说明该地址有内存空间存在
        		{
        			delete m_Name;
        			m_Name = NULL;//把指针变量存储的内容（地址）置为空
        		}
        	}
        
        
        	string* m_Name;
        };
        
        void test1()
        {
        	Animal *animal = new Cat("Tom");//父类指向子类对象
        	animal->speak();
        	//父类指针在delete时不会调用用子类中析构函数，导致子类如果有堆区数据会出现内存泄露
        	delete animal;
        
        }
        
        int main()
        {
        	test1();
        	system("pause");
        	return 0;
        }
        

七.C++文件操作

• 文件类型：
  1. 文本文件：文件以文本的ASCII码形式存储在计算机中
  2. 二进制文件：文件以文本的二进制形式存储在计算机中，用户一般不能直接读懂它们
• 操作文件的三大类
  1. ofstream：写操作
     • o代码output,
     • f代表file
     • output to file(输出到文件)
  2. ifstream：读操作
     • i代表input
     • f代表file
     • input from file
  3. fstream：读写操作
     • 没有前缀字母表示读和写都行

1. 文本文件
   1. 写文件（类似cout）

      • 步骤

        1. 包含头文件：#include<fstream>
        2. 创建流对象：ofstream ofs
        3. 打开文件：ofs.open("文件路径",打开方式);
           • 打开方式：
             
           • 注意：文件打开方式可以配合使用，利用|操作符
             • 如用二进制方式写文件：ios::binary | ios::out
        4. 写数据：ofs<<写入的数据;
           • 向文件写入数据
        5. 关闭文件：ofs.close();

      • 代码：

        #include<iostream>
        #include<fstream>
        using namespace std;
        
        //文本文件 写文件
        void test1()
        {
        	ofstream ofs;
        	ofs.open("test.txt", ios::out);
        	ofs << "Hello" << endl;
        	ofs << "World" << endl;
        	ofs.close();
        
        }
        
        int main()
        {
        	test1();
        	system("pause");
        	return 0;
        }
        

   2. 读文件(类似cin)
      • 步骤
        1. 包含头文件：#include<fstream>
        2. 创建流对象：ifstream ifs
        3. 打开文件并判断文件是否打开成功：ifs.open("文件路径",打开方式);
           • 打开方式：
             
           • 注意：文件打开方式可以配合使用，利用|操作符
             • 如用二进制方式写文件：ios::binary | ios::out
        4. 读数据（4种方式读取）：

           • 代码：

             #include<iostream>
             #include<string>
             //1
             #include<fstream>
             using namespace std;
             
             //文本文件 读文件
             void test()
             {
             	//2
             	ifstream ifs;
             	//3
             	ifs.open("test.txt", ios::in);
             
             	if (!ifs.is_open())
             	{
             		cout << "文件打开失败" << endl;
             	}
             
             	//4
             
             	第一种
             	//char buf[1024] = { 0 };
             	//while (ifs >> buf)//读到EOF，输入流对象就会变成假，跳出循环
             	//{
             	//	cout << buf << endl;
             	//}
             
             	第二种
             	//char buf[1024] = { 0 };
             	//while (ifs.getline(buf,1024))
             	//{
             	//	cout << buf << endl;
             	//}
             
             	第三种
             	//string buf;
             
             	//while (getline(ifs, buf))
             	//{
             	//	cout << buf << endl;
             	//}
             
             	第四种（不太推荐用）
             	//char c;
             	//while ((c = ifs.get()) != EOF)//如果读取字符没读到文件尾，则一直读
             	//{
             	//	cout << c;
             	//}
             
             	//5
             	ifs.close();
             
             
             
             
             }
             
             int main()
             {
             	test();
             
             	system("pause");
             	return 0;
             }
             

        5. 关闭文件：ifs.close();
2. 二进制文件
   • 以二进制的方式对文件进行读写操作，打开方式要指定为ios::binary
   1. 写文件(write)

      • 代码：

        #include<iostream>
        #include<fstream>
        using namespace std;
        
        //二进制文件 写文件
        class Person
        {
        public:
        	char m_Name[64];
        	int m_Age;
        };
        
        
        void test()
        {
        	ofstream ofs;
        	ofs.open("person.txt", ios::out | ios::binary);
        	
        	Person p = { "张三",18 };
        	ofs.write((const char*)&p, sizeof(Person));//强制转化成const char *
        
        	ofs.close();
        
        
        }
        int main()
        {
        	test();
        	system("pause");
        	return 0;
        }
        

   2. 读文件(read)

      • 代码：

        #include<iostream>
        #include<fstream>
        using namespace std;
        
        class Person
        {
        public:
        	char m_Name[64];
        	int m_Age;
        
        };
        
        
        //二进制文件 读文件
        void test()
        {
        	ifstream ifs;
        	ifs.open("Person.txt", ios::in | ios::binary);
        	if (!ifs.is_open())
        	{
        		cout << "文件打开失败" << endl;
        		return;
        	}
        	Person p;
        	ifs.read((char*)&p, sizeof(Person));//强制转化成char *
        
        	cout << p.m_Name << endl;
        	cout << p.m_Age << endl;
        
        	ifs.close();
        
        
        }
        
        int main()
        {
        	test();
        	system("pause");
        	return 0;
        }
        

八.模板

1. 作用：建立通用的模具，大大提高复用性

8.1函数模板

1. 作用：建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来代表

2. 函数模板定义语法：

   template<typename T>
   函数声明或定义
   

   • 第一行不加分号
   • template–声明创建模板
   • typename–表明其后面的符号是一种数据类型，可以用class代替
   • T–通用的数据类型，名称可以替换，通常为大写字母

3. 函数模板调用语法：

   • 自动类型推导

     函数名(形参);
     

   • 显示指定类型(建议使用这种方法)（就类似一种传参，只不过传的不再是变量，而是传数据类型）

     函数名<形参的类型>(形参);
     

4. 注意事项

   • 自动类型推导,必须推导出一致的数据类型T才可以使用
   • 声明了函数模板后必须让T确定自己的数据类型(有形参传形参，没形参就使用显示指定类型使T确定自己类型)，否则调用函数会报错

5. 普通函数和函数模板区别（能否发生隐式类型转换）

   • 普通函数调用时，可以发生自动类型转换(隐式类型转换)
   • 函数模板使用自动类型推导时，不会发生隐式类型转换
   • 函数模板使用显示指定类型时，可以发生隐式类型转换

6. 普通函数与函数模板同名时的调用规则

   • 如果函数模板和普通函数都可以实现，优先调用普通函数

   • 可以通过空模板参数列表来强制调用函数模板

   • 函数模板也可以发生重载

   • 如果函数模板可以产生更好的匹配优先调用函数模板

   • 代码：

     #include<iostream>
     using namespace std;
     
     
     void myPrint(int a, int b)
     {
     	cout << "调用普通函数" << endl;
     }
     
     template<typename T>
     void myPrint(T a, T b,T c)//函数模板重载
     {
     	cout << "调用函数重载模板" << endl;
     }
     
     template<typename T>
     void myPrint(T a, T b)
     {
     	cout << "调用函数模板" << endl;
     }
     
     void test1()//1.普通函数和函数模板都可以实现的话，优先调用普通函数
     {
     	int a = 10;
     	int b = 20;
     	myPrint(a, b);
     }
     
     void test2()//2.通过空模板参数列表强制调用函数模板
     {
     	int a = 10;
     	int b = 20;
     	myPrint<>(a, b);
     }
     
     void test3()//3.函数模板重载调用
     {
     	int a = 10;
     	int b = 20;
     	int c = 30;
     	myPrint(a, b,c);//或者myPrint<>(a, b,c)这样也是一样的结果
     }
     
     void test4()//4.如果函数模板产生更好的匹配（大概指不用隐式类型转换），优先调用函数模板
     {
     	char c1 = 'a';
     	char c2 = 'b';
     	myPrint(c1, c2);
     }
     
     int main()
     {
     	test1();//普通函数
     	test2();//函数模板
     	test3();//函数重载模板
     	test4();//函数模板
     
     	system("pause");
     	return 0;
     }
     

7. 模板的局限性

   • 模板的通用性不是万能的，自定义数据类型无法实现

   • 用具体化模板解决自定义类型的通用化

     • 语法：template<> 函数模板的定义
       • 之前的通用化函数模板还保留，只是多加这一个具体化函数模板

   • 代码：

     #include<iostream>
     #include<string >
     using namespace std;
     
     class Person
     {
     public:
     	Person(string name, int age)
     	{
     		m_Name = name;
     		m_Age = age;
     	}
     
     	string m_Name;
     	int m_Age;
     };
     
     template<typename T>
     bool myCompare(T &a, T &b)
     {
     	if (a == b)
     	{
     		return true;
     	}
     	else
     	{
     		return false;
     	}
     }
     
     //利用具体化的Person的版本实现代码，具体化优先调用
     template<> bool myCompare(Person& p1, Person& p2)
     {
     	if (p1.m_Name == p2.m_Name && p1.m_Age == p2.m_Age)
     	{
     		return true;
     	}
     	else
     	{
     		return false;
     	}
     }
     
     void test1()
     {
     	int a = 10;
     	int b = 10;
     	cout << myCompare(a, b) << endl;
     }
     
     void test2()
     {
     	Person p1("Tom",10);
     	Person p2("Tom",10);
     
     	cout<<myCompare(p1, p2)<<endl;
     
     }
     
     int main()
     {
     	test1();//1
     	test2();//1//具体化函数模板
     	system("pause");
     	return 0;
     }
     

8.2类模板

1. 作用：建立一个通用类，类中的成员数据类型可以先不确定，用一个虚拟的类型来代替

2. 语法：

   • 不带默认参数

     template<class T>
     类
     

   • 带默认参数

     template<class T=int>
     类
     

   • 第一行不加分号
   • template–声明创建模板
   • class–表明其后面的符号是一种数据类型，可以用typename代替
   • T–通用的数据类型，名称可以替换，通常为大写字母

3. 类模板调用语法：

   • 显示指定类型(只有这种调用语法，没有自动类型推导)

     类名<类中成员的形参列表类型> 变量名;
     

4. 类模板中成员函数创建时机

   • 类模板中成员函数和普通类中成员函数创建时机
     • 普通类中的成员函数一开始就可以创建
     • 类模板中的成员函数在被调用时才创建

5. 类模板对象做函数参数

   • 传入方式

     1. 指定传入的类型 – 直接显示对象的数据类型（最常用）
     2. 参数模板化 – 将对象中的参数变为模板进行传递
     3. 整个类模板化 – 将这个对象类型模板化进行传递

   • 代码

     #include<iostream>
     #include<string>
     using namespace std;
     
     //类模板对象做函数参数
     
     template<class T1,class T2>
     class Person
     {
     public:
     
     	Person(T1 name, T2 age)
     	{
     		m_Name = name;
     		m_Age = age;
     	}
     
     
     	void showPerson()
     	{
     		cout << m_Name << " " << m_Age << endl;
     	}
     
     	T1 m_Name;
     	T2 m_Age;
     
     
     };
     
     
     
     //1.指定传入类型
     
     void printPerson1(Person<string, int> &p)
     {
     	p.showPerson();
     }
     
     void test1()
     {
     	Person<string, int> p("张三", 10);
     	printPerson1(p);
     
     }
     
     //2.参数模板化
     template<class T1, class T2>
     void printPerson2(Person<T1, T2>& p)
     {
     	p.showPerson();
     	//看模板推出的数据类型是什么
     	cout << "T1的类型为：" << typeid(T1).name() << endl;
     	cout << "T2的类型为：" << typeid(T2).name() << endl;
     }
     
     void test2()
     {
     	Person<string, int> p("李四", 20);
     	printPerson2(p);
     
     }
     
     
     //3.类模板化
     template<class T>
     void printPerson3(T &p)
     {
     	p.showPerson();
     	//看模板推出的数据类型是什么
     	cout << "T1的类型为：" << typeid(T).name() << endl;
     
     }
     
     
     void test3()
     {
     	Person<string, int> p("王五", 30);
     	printPerson3(p);
     
     }
     
     int main()
     {
     
     	test1();
     	test2();
     	test3();
     	system("pause");
     
     	return 0;
     
     }
     

6. 类模板与继承

   • 当子类继承的父类是一个类模板时，子类在声明的时候要指定出父类中T的类型

   • 如果不指定，编译器无法给子类分配内存

   • 如果想灵活指定出父类中T的类型，子类也需变为类模板

   • 代码：

     #include<iostream>
     using namespace std;
     
     //类模板与继承
     
     template<class T>
     class Base
     {
     	T m;
     };
     
     
     //class Son:public Base//必须要知道父类中的T具体类型才能继承给子类
     class Son1 :public Base<int>
     {
     
     
     };
     
     void test1()
     {
     	Son1 s;
     }
     
     //如果想灵活指定父类中T类型，子类也需要变成类模板
     template<class T1,class T2>
     class Son2 :public Base<T2>//T2是父类中的成员类型
     {
     public:
     	Son2()
     	{
     		cout << typeid(T1).name() << endl;//int
     		cout << typeid(T2).name() << endl;//char
     	}
     
     	T1 obj;//T1是子类中的成员类型
     };
     
     void test2()
     {
     	Son2<int, char> s2;
     }
     
     int main()
     {
     	test1();
     	test2();
     
     	system("pause");
     	return 0;
     }
     

7. 类模板成员函数类外实现

   • 语法：

     类模板声明
     成员函数返回类型 类名<类模板形参列表>::成员函数名(){}//相对于类的成员函数类外实现需要加类模板声明以及类模板形参列表，都是必加的，即使成员函数没用到形参列表也要加类模板形参列表
     

   • 代码：

     #include<iostream>
     using namespace std;
     
     
     //类模板成员函数类外实现
     template<class T1,class T2>
     class Person
     {
     public:
     	Person(T1 name, T2 age);
     
     	void showPerson();
     
     	T1 m_Name;
     	T2 m_Age;
     
     };
     
     //构造函数类外实现
     template<class T1, class T2>
     Person<T1,T2>::Person(T1 name, T2 age)
     {
     	m_Name = name;
     	m_Age = age;
     }
     
     //成员函数类外实现
     template<class T1, class T2>
     void Person<T1,T2>::showPerson()
     {
     	cout << m_Name << endl;
     	cout << m_Age << endl;
     }
     
     void test1()
     {
     	Person<string,int> p1("张三",10);
     	p1.showPerson();
     }
     
     int main()
     {
     	test1();
     	system("pause");
     	return 0;
     }
     

8. 类模板分文件编写

   • 问题：类模板中成员函数创建时机是在成员函数被调用阶段，导致分文件编写时链接不到
   • 解决方法：
     1. 直接包含.cpp源文件
     2. 将声明和实现写到同一个文件中，并更改后缀名为.hpp，hpp（.h头文件+.cpp源文件）是约定的名称，不是一定要这个名字（常用）

9. 类模板与友元

   • 全局函数类内实现-直接在类内声明友元即可（建议用这个）

   • 全局函数类外实现-需要提前让编译器知道全局函数的存在（黑马P181，好复杂）

   • 代码：

     #include<iostream>
     #include<string>
     using namespace std;
     
     
     //通过全局函数 打印Person信息
     
     
     
     //2.全局函数类外实现
     //提前让编译器知道Person类的存在
     template<class T1, class T2>
     class Person;
     
     //提前让编译器知道全局函数的存在
     template<class T1, class T2>
     void printPerson2(Person<T1, T2> p)//参数模板化
     {
     	cout << p.m_Name << endl;
     	cout << p.m_Age << endl;
     }
     
     template<class T1, class T2>
     class Person
     {
     	//全局函数 类内实现
     	friend void printPerson1(Person<T1, T2> p)//参数模板化
     	{
     		cout << p.m_Name << endl;
     		cout << p.m_Age << endl;
     	}
     
     	//全局函数 类外实现
     	//需要加类模板的空参数列表
     	//提前让编译器知道这个普通函数的存在
     	friend void printPerson2<>(Person<T1, T2> p);//参数模板化
     
     public:
     	Person(T1 name, T2 age)
     	{
     		m_Name = name;
     		m_Age = age;
     	}
     
     
     private:
     	T1 m_Name;
     	T2 m_Age;
     
     };
     
     //1.全局函数类内实现
     void test1()
     {
     	Person<string, int> p("张三", 10);
     	printPerson1(p);
     }
     
     
     
     void test2()
     {
     	Person<string, int> p("李四", 20);
     	printPerson2(p);
     }
     
     int main()
     {
     	test1();
     	test2();
     	system("pause");
     	return 0;
     }
     

10. 类模板案例

    • 功能
    • 代码：待更新

九.STL（Standard Template Library标准模板库）

1. 概念：分为容器（container），算法（algorithm），迭代器（ierator）
2. STL六大组件
   1. 容器：各种数据结构，如vetor、list、deque、set、map等，用来存放数据
   2. 算法：各种常用的算法，如sort、find、copy、for_each等
   3. 迭代器：容器与算法之间的桥梁
   4. 仿函数：行为类似函数，可以作为算法的某种策略
   5. 适配器：一种用来修饰容器或者仿函数或迭代器接口的东西
   6. 空间配置器（配接器）：负责空间的配置与管理
3. STL中容器、算法、迭代器
   • STL容器：将运用最广泛的一些数据结构实现出来
     • 序列式容器：强调值的排序，序列式容器中的每个元素均有固定的位置
     • 关联式容器：二叉树结构，各元素之间没有严格的物理上的顺序关系
   • 算法：
     • 质变算法：运算过程中会更改去间内的元素的内容，例如拷贝，替换，删除等等
     • 非质变算法：是指运算过程中不会更改去间的元素内容，例如查找、计数、遍历、寻找极值等等
   • 迭代器（类似指针）：提供一种方法，使之能够依序寻访某个容器中所含的各个元素，而又无需暴露该容器的内部表示方式。每个容器都有自己专属的迭代器。算法要通过迭代器才能访问容器里的元素
     • 种类：（常用双向迭代器和随机访问迭代器）
       

4.容器

1. vector容器

   • 小技巧：尖括号内是什么类型，解引用出来后就是什么类型

   • 代码：

     #include<iostream>
     #include<string>
     #include<vector>
     using namespace std;
     
     //vector容器中存放自定义数据类型
     class Person
     {
     public:
     	Person(string name, int age)
     	{
     		m_Name = name;
     		m_Age = age;
     	}
     
     	string m_Name;
     	int m_Age;
     };
     
     //存放类
     void test1()
     {
     	vector<Person> v;
     	Person p1("a", 10);
     	Person p2("b", 20);
     	Person p3("c", 30);
     	Person p4("d", 40);
     	Person p5("e", 50);
     
     	//向容器中添加数据
     	v.push_back(p1);
     	v.push_back(p2);
     	v.push_back(p3);
     	v.push_back(p4);
     	v.push_back(p5);
     
     	//遍历容器中的数据
     	for (vector<Person>::iterator it = v.begin(); it != v.end(); it++)
     	{
     		cout << "姓名：" << (*it).m_Name << endl;
     		cout << "年龄：" << (*it).m_Age << endl;
     	}
     
     }
     
     //2.存放自定义数据类型 指针
     void test2()
     {
     	vector<Person*> v;
     	Person p1("a", 10);
     	Person p2("b", 20);
     	Person p3("c", 30);
     	Person p4("d", 40);
     	Person p5("e", 50);
     
     	//向容器中添加数据
     	v.push_back(&p1);
     	v.push_back(&p2);
     	v.push_back(&p3);
     	v.push_back(&p4);
     	v.push_back(&p5);
     
     	//遍历容器中的数据
     	for (vector<Person*>::iterator it = v.begin(); it != v.end(); it++)
     	{
     		cout << "姓名：" << (*it)->m_Name << endl;
     		cout << "年龄：" << (*it)->m_Age << endl;
     	}
     
     }
     
     
     
     int main()
     {
     	test2();
     	system("pause");
     	return 0;
     }
     

   • 嵌套代码：

     #include<iostream>
     #include<vector>
     using namespace std;
     
     void test()
     {
     	vector<vector<int>> v;
     
     	vector<int> v1;
     	vector<int> v2;
     	vector<int> v3;
     
     	v1.push_back(1);
     	v1.push_back(2);
     	v1.push_back(3);
     	v2.push_back(4);
     	v2.push_back(5);
     	v2.push_back(6);
     	v3.push_back(7);
     	v3.push_back(8);
     	v3.push_back(9);
     
     	v.push_back(v1);
     	v.push_back(v2);
     	v.push_back(v3);
     
     	for (vector<vector<int>> ::iterator it = v.begin(); it != v.end(); it++)
     	{
     		for (vector<int> ::iterator vit = (*it).begin(); vit != (*it).end(); vit++)
     		{
     			cout << *vit << " ";
     		}
     		cout << endl;
     	}
     }
     
     int main()
     {
     	test();
     
     	system("pause");
     	return 0;
     }
     

4.1string容器

• string的构造函数
  1. string(); //创建一个空的字符串，如string str
  2. string(const char *s); //使用字符串s初始化
  3. string(const string& str); //使用一个string对象初始化另一个string对象
  4. string(int n,char c); //使用n个字符c初始化
  • 代码：

    #include<iostream>
    #include<string>
    using namespace std;
    
    void test1()
    {
    	string s1;//默认构造
    
    	const char* str = "hello world";
    
    	string s2(str);
    	cout <<"s2:" << s2 << endl;
    
    	string s3(s2);
    	cout << "s3:" << s3 << endl;
    
    	string s4(10, 'a');
    	cout << "s4:" << s4 << endl;
    }
    
    int main()
    {
    	test1();
    
    	system("pause");
    	return 0;
    }
    

• string的赋值操作
  • 作用：给string字符串进行赋值
  • 赋值的函数原型：

    string& operator=(const char* s);  //把char *类型字符串赋值给当前的string类型字符串
    string& operator=(const string &s);//把string类型字符串赋值给当前的string类型字符串
    string& operator=(char c);		   //把char类型字符赋值给当前的string类型字符串
    string& assign(const char *s);		//把char*类型字符串赋值给当前的string类型字符串
    string& assign(const char *s,int n);//把char*类型字符串的前n个字符赋给当前的string类型字符串
    string& assign(const string &s);	//把string类型字符串赋值给当前string类型字符串
    string& assign(int n,char c);		//把n个char类型字符赋值给当前string类型字符串
    

  • 代码：

    #include<iostream>
    #include<string>
    using namespace std;
    
    /*
    string& operator=(const char* s);  //把char *类型字符串赋值给当前的string类型字符串
    string& operator=(const string &s);//把string类型字符串赋值给当前的string类型字符串
    string& operator=(char c);		   //把char类型字符赋值给当前的string类型字符串
    string& assign(const char *s);		//把char*类型字符串赋值给当前的string类型字符串
    string& assign(const char *s,int n);//把char*类型字符串的前n个字符赋给当前的string类型字符串
    string& assign(const string &s);	//把string类型字符串赋值给当前string类型字符串
    string& assign(int n,char c);		//把n个char类型字符赋值给当前string类型字符串
    */
    
    void test1()
    {
    
    	string str1;
    	str1 = "hello world";
    	cout << "str1=" << str1 << endl;//hello world
    
    	string str2;
    	str2 = str1;
    	cout << "str2=" << str2 << endl;//hello world
    
    	string str3;
    	str3 = 'a';
    	cout << "str3=" << str3 << endl;//a
    
    	string str4;
    	str4.assign("hello C++");
    	cout << "str4=" << str4 << endl;//hello C++
    
    	string str5;
    	str5.assign("hello C++",5);
    	cout << "str5=" << str5 << endl; //hello
    
    	string str6;
    	str6.assign(str5);
    	cout << "str6=" << str6 << endl;//hello
    
    	string str7;
    	str7.assign(10, 'w');
    	cout << "str7=" << str7 << endl;//wwwwwwwwww
    
    }
    
    int main()
    {
    
    	test1();
    	system("pause");
    	return 0;
    }
    

• string字符串拼接
  • 作用：实现在字符串末尾拼接字符串
  • 函数原型：

    string& operator+=(const char* str);			//把char*类型字符串连接到当前string类型字符串结尾
    string& operator+=(const char c);				//把char类型字符连接到当前sring类型字符串结尾
    string& operator+=(const string& str);			//把string类型字符串连接到当前string类型字符串结尾
    string& append(const char *s);					//把char*类型字符串连接到当前string类型字符串结尾
    string& append(const char *s,int n);			//把char*类型字符串的前n个字符连接到当前sring类型字符串结尾
    string& append(const string &s);				//把string类型字符串连接到当前string类型字符串结尾
    string& append(const string &s,int pos,int n);	//把string类型字符串的pos下标位置开始的共n个字符连接到当前string类型字符串结尾
    

  • 代码：

    #include<iostream>
    #include<string>
    using namespace std;
    
    /*
    string& operator+=(const char* str);			//把char*类型字符串连接到当前string类型字符串结尾
    string& operator+=(const char c);				//把char类型字符连接到当前sring类型字符串结尾
    string& operator+=(const string& str);			//把string类型字符串连接到当前string类型字符串结尾
    string& append(const char *s);					//把char*类型字符串连接到当前string类型字符串结尾
    string& append(const char *s,int n);			//把char*类型字符串的前n个字符连接到当前sring类型字符串结尾
    string& append(const string &s);				//把string类型字符串连接到当前string类型字符串结尾
    string& append(const string &s,int pos,int n);	//把string类型字符串的pos下标位置开始的共n个字符连接到当前string类型字符串结尾
    
    */
    
    void test1()
    {
    	string str1 = "hello";
    	str1 += " world";
    	cout << "str1=" << str1 << endl;//hello world
    
    	string str2 = "hell";
    	str2 += 'o';
    	cout << "str2=" << str2 << endl;//hello
    
    	string str3 = "!!!";
    	str3 += str1;
    	cout << "str3=" << str3 << endl;//!!!hello world
    
    	string str4 = "hello ";
    	str4.append("C++");
    	cout << "str4=" << str4 << endl;//hello C++
    
    	string str5 = "hello ";
    	str5.append("C++!!!", 3);
    	cout << "str5=" << str5 << endl;//hello C++
    
    	string str6 = "!!!";
    	str6.append(str4);
    	cout << "str6=" << str6 << endl;//!!!hello C++
    
    	string str7 = "hello ";
    	str7.append(str4, 6, 3);
    	cout << "str7=" << str7 << endl;//hello C++
    
    }
    
    int main()
    {
    
    	test1();
    	system("pause");
    	return 0;
    
    }
    

• string查找和替换
  • 功能：
    • 查找：查找指定字符串是否存在
    • 替换：在指定的位置替换字符串
  • 函数原型
    • find
      • 从左往右查找
    • rfind
      • 从右往左查找
    • replace
      • 指定从哪个位置起，多少个字符，替换成什么样的字符串
  • 代码：

    #include<iostream>
    #include<string>
    using namespace std;
    
    //函数原型
    
    //1.查找
    void test1()
    {
    	string str1 = "abcdefgbc";
    
    	int pos1;
    	pos1=str1.find("bc");//从左往右查
    	cout << pos1 << endl;//1
    
    	int pos2;
    	pos2 = str1.rfind("bc");//从右往左查
    	cout << pos2 << endl;//7
    }
    //2.替换
    void test2()
    {
    	string str1 = "abcdefg";
    	str1.replace(1, 3, "1111");
    	cout << str1 << endl;//a1111efg
    
    }
    
    
    int main()
    {
    
    	test1();
    	test2();
    	system("pause");
    
    	return 0;
    
    }
    

• string字符串比较
  • 功能：
    • 字符串之间的比较
  • 比较方式：
    • 字符串比较是按字符的ASCII码进行对比
      • 等于=返回 0
      • 大于>返回 1
      • 小于<返回 -1
  • 函数原型：

    int compare(const char *s) const;//与char *类型字符串比较
    int compare(const string &s) const;//与string类型字符串比较
    

  • 代码：

    #include<iostream>
    #include<string>
    using namespace std;
    
    /*
    int compare(const char *s) const;//与char *类型字符串比较
    int compare(const string &s) const;//与string类型字符串比较
    */
    
    void test1()
    {
    	string str11 = "hello";
    	string str12 = "hello";
    	cout << str11.compare(str12) << endl;//0
    
    	string str21 = "xello";
    	string str22 = "hello";
    	cout << str21.compare(str22) << endl;//1
    
    	string str31 = "aello";
    	string str32 = "hello";
    	cout << str31.compare(str32) << endl;//-1
    }
    
    int main()
    {
    	test1();
    
    	system("pause");
    	return 0;
    }
    

• string 字符存取
  • 功能：存取字符
  • 函数原型

    char &operator[](int n);通过[]方式存取字符
    char &at(int n);通过at方法获存取字符
    

  • 代码

    #include<iostream>
    #include<string>
    using namespace std;
    
    /*
    char &operator[](int n);通过[]方式存取字符
    char &at(int n);通过at方法获存取字符
    */
    
    
    void test1()
    {
    	string str = "hello";
    
    	//1.通过[]访问单个字符
    	for (int i = 0; i < str.size(); i++)
    	{
    		cout << str[i] << " ";//h e l l o
    	}
    	cout << endl;
    	
    	// 
    	//2.通过at方式访问单字符
    	for (int i = 0; i < str.size(); i++)
    	{
    		cout << str.at(i) << " ";//h e l l o
    	}
    	cout << endl;
    
    	//3.通过[]修改单个字符
    	str[0] = 'H';
    	cout << "str=" << str << endl;//Hello
    
    	//4.通过at修改单个字符
    	str.at(1) = 'E';
    	cout << "str=" << str << endl;//HEllo
    
    
    
    }
    
    int main()
    {
    
    	test1();
    
    	system("pause");
    	return 0;
    }
    

• string字符串插入和删除
  • 功能：对string字符串进行插入和删除操作
  • 函数原型

    string &insert(int pos,const char* s);		//在pos下标位置插入char*类型字符串
    string &insert(int pos,const string &str);	//在pos下标位置插入string 类型字符串
    string insert(int pos,int n,char c);		//在指定位置插入n个字符c
    string &erase(int pos,int n=npos);			//删除从pos下标开始的n个字符
    

  • 代码

    #include<iostream>
    #include<string>
    using namespace std;
    
    /*
    string &insert(int pos,const char* s);		//在pos下标位置插入char*类型字符串
    string &insert(int pos,const string &str);	//在pos下标位置插入string 类型字符串
    string insert(int pos,int n,char c);		//在指定位置插入n个字符c
    string &erase(int pos,int n=npos);			//删除从pos下标开始的n个字符
    */
    
    void test1()
    {
    	string str = "hllo";
    
    	//1.插入
    	str.insert(1, "e");
    	cout << "str=" << str << endl;//hello
    
    	//2.删除
    	str.erase(1, 3);
    	cout << "str=" << str << endl;//ho
    
    }
    
    int main()
    {
    	test1();
    	system("pause");
    	return 0;
    }
    

• string截取子串
  • 功能：从字符串中获取想要的子串
  • 函数原型

    string substr(int pos=0,int n=npos) const;//返回由pos开始的n个字符组成的string类型字符串
    

  • 代码

    #include<iostream>
    #include<string>
    using namespace std;
    
    /*
    string substr(int pos=0,int n=npos) const;//返回由pos开始的n个字符组成的string类型字符串
    */
    
    void test1()
    {
    	string str = "abcdef";
    	string subStr = str.substr(1, 3);
    	cout << "subStr=" << subStr << endl;
    
    }
    
    int main()
    {
    	test1();
    	
    	system("pause");
    	return 0;
    }