c++基础笔记

目录

==c++基本笔记==

赋值运算符有=，+=，-=，*=，/=，%=
作用：例如a+=2相当于a=a+2，其他以此类推



=====比较运算符=====

运算符     含义     例子     结果
 ==        相等     4==3      0
 !=        不相等   4!=3      1
 <         小于     4<3       0
 >         大于     4>3       1
 <=      小于等于   4<=3      0
 >=      大于等于   4>=3      1

=====逻辑运算符=====
!为逻辑非，例如有事件a，如果a为真，则!a为假（注：在c++中，除了0以为的数字都为真，int a = 10，则!a = 0,!!a = 1）
&&为逻辑与，例如有事件a和事件b，如果a和b同时为真，则结果为真
||为逻辑或，例如有事件a和事件b，如果a或b为真，则a||b为真
=====程序流程结构=====
c++支持最基本的三种程序结构有三种，分别为顺序结构、选择结构和循环结构
1、顺序结构：程序按顺序执行，不发生跳转
2、选择结构：依据条件是否满足，有选择的执行相应功能
3、循环结构：依据条件是否满足，循环多次执行某个代码
======if语句======
单行格式if语句：if（条件） {条件满足时执行的语句}
多行格式if语句：if（条件） {条件满足时执行的语句} else{条件不满足时执行的语句}
多条件的if语句
嵌套if语句：if条件中再加if语句

//多条件if语句
#include
using namespace std;
int main()
{
    //输入一个分数，大于等于500分视为考上一本大学，大于等于300分视为考上二本大学，否则视为没有考上大学
    int score = 0;
    cout << "请输入您的分数" << endl;
    cin >> score;
    cout << "您输入的分数是" << score << endl;
    if (score >= 500)
    {
        cout << "恭喜您考上一本大学" << endl;
        if (score > 700)
        {
            cout << "您能考入A大学" << endl;
        }
        else if (score > 650)
        {
            cout << "您能考入B大学" << endl;
        }
        else if (score > 600)
        {
            cout << "您能考入C大学" << endl;
        }
    }
    else if (score >= 300)
    {
        cout << "恭喜您考上二本大学" << endl;
    }
    else


    {
        cout << "很遗憾您没有考上大学" << endl;
    }
    system("pause");
    return 0;
}

获取到一个三位数的个位、十位、百位的方法：
#将一个三位数取模于10就得到了这个三位数的个位；
#将一个三位数先除以10，再取模于10得到了这个三位数的十位；（在c++中，两个整数相除还是一个整数，小数部分去掉）
#将一个三位数除以100就得到了这个三位数的百位。


查看ASCII值的代码：cout<<(int)变量< ASCII值：a对应97，A对应65，依次递推
=====转义字符=====
常用的转义字符：
*n是换行符
*t是水平制表符
*\是一个反斜线字符“”
=====三目运算符=====
作用：通过三目运算符实现简单的判断
语法：表达式1?表达式2:表达式3（注：在c++中三目运算符返回的变量，可以继续赋值）

//三目运算符
#include
using namespace std;
int main()
{

    int a = 10;
    int b = 20;
    (a > b ? a : b) = 100;
        
    cout <<"a="<< a << endl;   //a=10
    cout << "b=" << b << endl; //b=100


    system("pause");
    return 0;
}

=====switch语句=====
作用：执行多条件分支语句
语法：switch（表达式）
{
case结果1：执行语句；break；
case结果2：执行语句；break；
....
default：执行语句；break；
}

//switch语句的练习
#include
using namespace std;
int main() {

    //switch语句
    int score = 0;
    cout << "请给电影进行打分" << endl;
    cin >> score;
    cout << "您打的分数为：" << score << endl;
    switch (score)
    {
    case 10:
        cout << "您认为是经典电影" << endl;
        break;    //用于退出当前分支
    case 9:cout << "您认为是经典电影" << endl; break;
    case 7:cout << "您认为电影比较好" << endl; break;
    case 6:cout << "您认为电影一般" << endl; break;
    case 5:cout << "您认为电影一般" << endl; break;
    default:cout << "您认为电影是烂片" << endl; break;
    }

    system("pause");
    return 0;
}

=====循环结构=====
======while循环语句======
语法：
while（循环条件）
{循环语句}

//while循环语句
#include
using namespace std;
int main(){
    
    //while循环语句
    int a = 0;
    while (a < 10)
    {
        cout << a << endl;
        a++;
    }

    system("pause");
    return 0;
}

======补充小点======
rand（）%100表示0到99的随机数字；rand（）%100+1表示1到100的随机数字
=====do...while循环语句=====
语法：do{执行语句}   while（循环条件）;

//do...while语句练习：找出所有的水仙花数
#include
using namespace std;
int main()
{
    
    //用do...while循环语句得到全部的水仙花数
    
    //1.打印所有的三位数字
    int num = 100;
    do
    {
        //2.从所有的三位数中找到所有的水仙花数
        int a = 0;  //用于获得三位数的个位
        int b = 0;  //用于获得三位数的十位
        int c = 0;  // 用于获得三位数的百位

        a = num % 10;
        b = num / 10 % 10;  //两个整数相除，结果仍未整数，若有小数则小数部分去掉
        c = num / 100;
        if (a*a*a+b*b*b+c*c*c==num)
        {
            cout << num << endl;
        }
        num++;
    }     while (num < 1000);
    

    system("pause");
    return 0;
}

//循环语句练习：设计猜数字游戏
#include
using namespace std;
#include    //time系统时间头文件包含
int main() {

    //设计一个猜数字的游戏

    srand((unsigned int)time(NULL));   //srand用作添加随机数种子，作用：利用当前系统时间生成随机数，防止每次随机数都一样
    int num = rand() % 100 + 1;  //rand()%100表示的是从0到99的一个随机数
    //cout << num << endl;
    int val = 0;
    cout << "请输入您猜测的数字" << endl;

    while (1)
    {
        cin >> val;

        if (val > num)
        {
            cout << "猜测过大" << endl;
        }
        else if (val < num)
            {
                cout << "猜测过小" << endl;
            }
        else if(val=num)
        {
            cout << "恭喜您猜对了" << endl;
            break;  //break, 利用该关键字退出当前循环
        }
    }

    system("pause");
    return 0;
}

=====for循环=====
作用：满足循环条件，执行循环语句
语法：for（起始表达式；条件表达式；末尾循环体）
{循环语句}

//for语句练习
#include
using namespace std;
int main() {

    //for循环语句练习，并包含嵌套结构
    for (int i = 1; i <= 100; i++)
    {
        '''''if (i % 7 ==0||i%10==7||i/10==7)'''''
        {
            cout << "敲桌子" << endl;
        }
        else {
            cout << i << endl;
        }    
    }

    system("pause");
    return 0;
}

=====跳转语句=====
1.break
2.continue语句
作用：在循环语句中，跳过本次循环中余下尚未执行的语句，继续执行下一循环
3.goto语句
作用：如果标记存在，执行goto语句时，会跳转到标记的位置
=====一维数组数组名=====
一维数组名的用途：
1.可以统计整个数组在内存中的长度
2.可以获取数组在内存中的首地址
//arr[0]用于访问第一个元素；数组中第一个元素地址为（int）&arr[0]；获取首地址：cout<<(int)arr<

//一维数组的应用一：找到数组中最大的元素
#include
using namespace std;
int main() {

    //sizeof数组名
    int arr[5] = { 300,350,200,400,250 };
    int max = 0;
    for (int i = 0; i <= 4; i++)
    {
        if (max < arr[i])
        {
            max = arr[i];
        }
    }
    cout << "max=" << max << endl;


    system("pause");
    return 0;
}

//一维数组应用二：数组元素的倒置（利用for语句的嵌套循环）
#include
using namespace std;
int main() {

    //实现数组元素的逆置
    int arr[5] = { 1,3,2,5,4 };
    cout << "逆置前的数组元素：" << endl;
    for (int i = 0; i < 5; i++)
    {
        cout << arr[i]<<" ";
    }

    int start = 0;
    int end = sizeof(arr) / sizeof(arr[0]) - 1;

    while (start < end)
    {
        int temp = arr[start];
        arr[start] = arr[end];
        arr[end] = temp;
        start++;
        end--;
    }
    cout << endl;

    cout << "逆置后的数组元素:" << endl;
    for (int j = 0; j < 5; j++)
    {
        cout << arr[j] << " ";
    }

    system("pause");
    return 0;
}

=====冒泡排序=====
作用：最常用的排序算法，对数组内元素进行排序
1、比较相邻的元素，如果第一个比第二个大，就交换他们两个//内循环，每次外循环进行的内循环次数：总元素个数-外循环次数-1
2、对每一对相邻元素做同样的工作，执行完毕后，找到第一个最大值//外循环次数：总元素个数-1
3、重复以上的步骤，每次比较的次数-1

//冒泡排序练习：将一组数字从大到小排序
#include
using namespace std;
int main() {

    
    int arr[9] = { 4,2,8,0,5,7,1,3,9 };
    for (int a = 0; a < 9; a++)
    {
        cout << arr[a] << " ";
    }
    cout << endl;


    //外部循环，总共排序轮数为总元素个数-1
    for (int i = 0; i < sizeof(arr) / sizeof(arr[0]) - 1; i++)
    {

        //内部循环  对比次数：元素个数-当前轮数-1
        for (int j = 0; j < sizeof(arr) / sizeof(arr[0]) - i - 1;j ++ )
        {
            if (arr[j] < arr[j + 1])
            {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }

        }
    }

    //打印排序后的结果
    cout << "排序后的结果为" << endl;
    for (int b = 0; b < 9; b++)
    {
        cout << arr[b] << " ";
    }
    cout << endl;

    system("pause");
    return 0;
}

=====二维数组=====
矩阵可以用嵌套循环打印：
二维数组定义方式：
1、数据类型  数组名[行数][列数]，然后逐个写，比如arr[0][0] = 3;
2、数据类型  数组名[行数][列数]={{数据1，数据2}，{数据3，数数据4}}
3、数据类型  数组名[行数][列数]={数据1，数据2，数据3，数据4}
4、数据类型 数组名[][列数]={数据1，数据2，数据3，数据4}

//二位数组名的作用
#include
using namespace std;
int main() {
    
    int arr[2][3] =
    {
        {1,2,3},
        {4,5,6}
    };

    //1、查看占用内存空间大小
    cout << "二维数组占用的内存空间大小为 " << sizeof(arr) << endl;
    cout << "二维数组第一行占用的内存空间大小为 " << sizeof(arr[0]) << endl;
    cout << "二维数组的第一个元素所占用的内存空间大小为 " << sizeof(arr[0][0]) << endl;
    cout << "二维数组的行数为 " << sizeof(arr) / sizeof(arr[0]) << endl;
    cout << "二维数组的列数为 " << sizeof(arr[0]) / sizeof(arr[0][0])< 

 =====函数=====
 作用：将一段经常使用的代码封装起来，减少重复代码
一个较大的程序一般分为若干个程序块，每个模块实现特定的功能
 ======函数的定义与调用======
 1、返回值类型
2、函数名
3、参数列表
4、函数体语句
5、return表达式
 语法：
 返回值类型  函数名（参数列表）
 {
 函数体语句
 return表达式
 }
 
//函数的定义与调用
#include
using namespace std;

//定义一个加法函数
//函数定义的时候，num1和num2并没有真实数据，它们只是形式上的参数，简称形参
int add(int num1, int num2)
{
    int sum = num1 + num2;
    return sum;
}


int main() {

    //调用定义的加法函数
    int a = 10;
    int b = 20;
    int c = add(a, b);    //a和b为实际参数，简称实参    当调用函数的时候，实参的值会传递给形参
    cout << " c = " << c << endl;

    system("pause");  //打印“按任意键继续”
    return 0;
}

 
======值传递======
 所谓值传递，就是函数调用时实参将值传入给形参
//值传递时，如果形参发生改变，并不会影响实参
总结：值传递时，形参是修饰不了实参的
 函数的常见样式
1、无参无返
2、有参无返
3、无参有返
4、有参有返
 
//值传递
#include
using namespace std;

//值传递：定义函数，实现两个数字进行交换

void swap(int num1, int num2)    //如果函数不需要返回值，声明的时候可以写void
{
    cout << "交换前： " << endl;
    cout << "num1= " << num1 << endl;
    cout << "num2= " << num2 << endl;
    int temp = num1;
    num1 = num2;
    num2 = temp;
    cout << "交换后： " << endl;
    cout << "num1= " << num1 << endl;
    cout << "num2= " << num2 << endl;
    return;  //返回值不需要的时候，可以不写return
}

int main() {

    int a = 10;
    int b = 20;
    cout << "a= " << a << "  " << "b= " << b << endl;
    swap(a, b);
    cout << "a= " << a << "  " << "b= " << b << endl;
    //做值传递的时候，函数的形参发生改变，并不会影响实参

    system("pause");
    return 0;
}
 

 ======函数的声明======
 函数定义在main函数之后出现，要先在main函数进行函数声明
声明的使用：返回值类型  函数名（参数列表）
注：声明可以写多次，但定义只能有一次
 ======函数的分文件编写======
 作用：让代码结构更加清晰
函数分文件编写一般有4个步骤
1.创建一个.h的头文件
2、创建一个.cpp的源文件
3、在头文件中写函数的声明
4、在源文件中写函数的定义
 =====指针=====
 作用：通过指针间接访问内存
 可以通过指针来保存一个地址
 指针定义的语法：数据类型  *  指针变量名 int * p;
  int a = 10;     让指针记录变量a的地址 p = &a  (&为取址符号）  //int * p  = &a;
 
//指针和数组
#include
using namespace std;
int main() {

    int a = 10;
    int b = 20;

    //1、const修饰指针，称为常量指针    此时，指针的指向可以修改，指针指向的值不可以修改
    const int* p1 = &a;
    cout << "*p1= " << *p1 << endl;
    /
public:

    
    double m_r;

    
    double calculateZC()
    {
        return 2 * PI * m_r;
    }
};

int main() {

    //通过圆类，创建具体的圆（对象）
    circle c1;

    //给圆对象的属性进行赋值
    c1.m_r = 5.20;
    cout << "圆c1的周长为： " << c1.calculateZC() << endl;

    system("pause");
    return 0;
}
 

 封装的意义二：
 类在设计时，可以把属性和行为放在不同的权限下，加以控制

 访问权限有三种：

 1、public  公共权限       类内可以访问，类外可以访问

 2、protected 保护权限  类内可以访问，类外不可以访问      儿子可以访问父亲中的保护内容

 3、private  私有权限      类内可以访问，类外不可以访问     儿子不可以访问父亲的私有内容
 
#include
using namespace std;

class student {

public:

    string name;
    int ID;

    void print() {

        cout << "学生的姓名： " << name << endl;
        cout << "学生的学号： " << ID << endl;
    }
};


int main() {

    student s1;
    s1.name = "张三";
    s1.ID = 173962;
    s1.print();

    student s2;
    s2.name = "李四";
    s2.ID = 174615;
    s2.print();

    system("pause");
    return 0;
}
 
======struct和class的区别======
 在c++中 struct和class唯一的区别在于默认的访问权限不同

 struct默认权限为公共

 class默认权限为私有

 ======成员属性设置为私有======
 优点：将所有成员属性设置为私有，可以自己控制读写权限。对于写权限，我们可以检测数据的有效性 

 将成员属性放在private下，想改动属性，则将相应的函数放在public下

 =====对象的初始化和清理=====
 构造函数和析构函数：初始化和清理

 如果我们不提供构造和析构，编译器会提供编译器自动调动。编译器提供的构造函数和析构函数时空实现

 构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用

 析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作

 构造函数语法：类名（）{ }

 1、构造函数，没有返回值也不写void

 2、函数名称与类名相同

 3、构造函数可以有参数，因此可以发生重载

 4、程序在调用对象时候会自动调用构造函数，无需手动调用，而且只会调用一次

 析构函数语法：~类名（）{ }

 1、析构函数没有返回值也不写void

 2、函数名称与类名相同，在名称前加~

 3、析构函数不可以有参数，因此不可以发生重载

 4、程序在对象销毁前会自动调用析构，无需手动调用，而且只会调用一次
=====构造函数的分类及调用=====
 两种分类方式：

    按参数分为：有参构造和无参构造

    按类型分为：普通构造和拷贝构造
 
 class person
 {
 public:
   person( )
  {
     cout<<"person的无参构造函数调用"< 

 三种调用方式：括号法  显示法  隐式转换法
 调用：
 void test1( )
   {
    //1、括号法
    person p1;            //默认构造函数调用，调用无参构造函数               注意事项： 调用默认构造函数的时候，不要加（）；不要利用拷贝函数来初始化匿名对象
    person p2(10);     //调用有参构造函数
    person p3(p2);    //调用拷贝构造函数
 
   //2、显示法
    person p1;                //调用无参构造
    person p2 = person(10);    //调用有参构造
    person p3 = person(p3);   //调用拷贝构造
 
匿名对象 ，如person(10 )   特点：当前行执行结构后，系统会立即回收掉匿名对象
    //3、隐式转换法
    person p4 = 10;    // 相当于写了 person p4 = person(10);   调用有参构造函数
    person p5 = p4;    // 调用拷贝构造函数
   }=====STL的基本概念=====
 STL（standard template library，标准模板库）

 STL从广义上分为：容器（container）、算法（algorithm）、迭代器（iterator）

 容器和算法之间通过迭代器进行无缝衔接

 STL几乎所有的代码都采用了模板类和模板函数

 ======STL六大组件======
 分别为容器、算法、迭代器、仿函数、适配器（配接器）、空间配置器

 1、容器：各种数据结构，如vector、list、deque、set、map等，用来存放数据

 2、算法：各种常用的算法，如sort、find、copy、for_each等

 3、迭代器：扮演了容器和算法之间的胶合剂

 4、仿函数：行为类似函数，可作为算法的某种策略

 5、适配器：一种用来修饰容器或者仿函数或迭代器接口的东西

 6、空间配置器：负责空间的配置与管理

 ======容器算法迭代器======
 =======vector存放内置数据类型=======
 容器：vector

 算法：for_each

 迭代器：vector::iterator
 
//用vector容器存放数据并实现数据的遍历
#include
using namespace std;
#include

//第一种遍历方式
void test1()
{
  //创建一个vector容器，把容器看作一个数组数组
    vector v;

    //向容器中插入数据
    v.push_back(10);
    v.push_back(20);
    v.push_back(30);
    v.push_back(40);
    v.push_back(50);

    //通过迭代器访问容器中的数据
    vector::iterator itBegin = v.begin();    //v.begin（）为起始迭代器，指向容器第一个元素
    vector::iterator itEnd = v.end();   //v.end()为结束迭代器，指向容器中最后一个元素的下一个位置

    while (itBegin != itEnd)
    {
        cout << *itBegin << endl;
        itBegin++;
    }
    //第二种遍历方式


    for (vector::iterator it = v.begin(); it != v.end(); it++)
    {
        cout << *it << endl;
    }
}

int main() {

    test1();

    system("pause");
    return 0;
}
 

 =====拷贝构造=====
 拷贝构造函数调用时机通常有三种：
 1、使用一个已经创建完成的对象来初始化一个对象
 2、值传递的方式给函数参数传值
 3、以值方式返回局部对象
 
//拷贝构造函数调用时机
#include
using namespace std;


class person {

public:
    person()
    {
        cout << "person的无参构造函数调用" << endl;
    }

    person(int age)
    {
        m_age = age;
        cout << "有参构造函数的调用" << endl;
    }

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

    ~person()
    {
        cout << "person析构函数调用" << endl;
    }
private:
    int m_age;

};


int main() {

    //情况一
    person p1(10);
    person p2(p1);

    system("pause");
    return 0;
}
 

 =====构造函数调用规则=====
 默认情况下，c++编译器至少给一个类添加3个函数

 1、默认构造函数（无参，函数体为空）

 2、默认析构函数（无参，函数体为空）

 3、默认拷贝构造函数，对属性进行值拷贝

 构造函数调用规则如下：

 如果用户定义有参构造函数，c++不再提供无参构造，但是会提供默认拷贝构造

 如果用户定义拷贝构造函数，c++不会再提供其他构造函数

 =====深拷贝和浅拷贝=====
 浅拷贝：简单的赋值拷贝操作

 深拷贝：在堆区重新申请空间，进行拷贝操作

 浅拷贝带来的问题就是堆区的内存重复释放，浅拷贝的问题要利用深拷贝来解决
 
//用深拷贝解决浅拷贝的问题
#include
using namespace std;

class Person
{

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

    Person(int age, int height)
    {
        m_age = age;
        m_height = new int(height);       //用new操作符在堆区开辟数据
        cout << "Person有参构造函数的调用" << endl;
    }

    //自己创建拷贝构造函数，解决浅拷贝带来的问题
    Person(const Person& p)
    {
        cout << "Person拷贝构造函数调用" << endl;
        m_age =p.m_age;
           //编译器默认实现就是这行代码

        m_height = new int(*p.m_height);
    }

    ~Person()              //析构函数，将堆区开辟的数据局做释放操作
    {
        if (m_height != NULL)
        {
            delete m_height;
            m_height = NULL;    // 防止野指针的出现
        }
        cout << "Person析构函数调用" << endl;
    }

    int m_age;
    int *m_height;      //用new操作符在堆区开辟数据，用指针进行数据的接收
};

void test01()
{
    Person p1(10, 160);
    cout << "p1的年龄为： " << p1.m_age << " p1的体重为： " << *p1.m_height << endl;    //用指针接收堆区的返回值

    Person p2(p1);
    cout << "p1的年龄为： " << p1.m_age << " p1的体重为： " << *p1.m_height << endl;
}

int main() {

    test01();

    system("pause");
    return 0;
}
 

 =====初始化列表=====
 作用：c++提供了初始化列表语法，用来初始化属性

 语法：构造函数（）：属性1（值1），属性2（值2）...{ }
 
//
#include
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;
};

void test01()
{
    Person p(10,20,30);
    cout << "A为： " << p.m_A< 

 =====c++对象模型和this指针=====
 成员变量和成员函数分开存储

 在c++中，类内的成员变量和成员函数分开存储

 只有非静态成员变量才属于类的对象上

 c++编译器会给每个空对象也分配一个字节空间，是为了区分空对象占内存的位置。每个空对象也应该有一个独一无二的内存地址

 ======this指针概念======
 成员变量和成员指针是分开存储的，这一块代码的区分调用是通过this指针完成的。this指针指向被调用的成员函数所属的对象

 this指针是隐含每一个非静态成员函数内的一种指针

 this指针不需要定义，直接使用即可

 this指针的用处：当形参和成员变量同名时，可用this指针来区分；在类的非静态成员函数中返回对象本身，可使用return*this
 
//this指针的使用两种情况
#include
using namespace std;
class Person {

public:
    Person(int age)
    {
        this->age = age;    //this指针指向被调用的成员函数所属的对象
    }

    Person& PersonAddAge(Person p)
    {
        this->age += p.age;
        return *this;   //this指向p2的指针，而*this指向的就是p2这个对象本体
    }
    int age;
};

//1、解决名称冲突问题
void test1()
{
    Person p1(18);
    std::cout << "p1的年龄： " << p1.age << std::endl;
}

//2、返回对象本身用*this
void test2()
{
    Person p1(5);
    Person p2(3);
    p2.PersonAddAge(p1).PersonAddAge(p1).PersonAddAge(p1);
    cout << "p2 的年龄： " < 

 =====空指针调用成员函数=====
 c++中空指针也是可以调用成员函数的，但是也要注意有没有用到this指针

 如果用到this指针，需要加以判断保证代码的健壮性

 =====const修饰成员函数=====
 常函数：

 成员函数后加const后我们称这个函数为常函数

 常函数内不可以修改成员属性

 成员属性声明时加关键字mutable后，在常函数中依然可以修改

 常对象：

 声明对象前加const称该对象为常对象

 常对象只能调用常函数

 =====友元=====
 友元的目的就是让一个函数或者类访问另外一个类中私有成员

 友元的关键字 friend

 友元的三种实现方式：全局函数做友元    类做友元   成员函数做友元
 
//友元friend   在类中写入成员变量和成员函数之前写入
#include
using namespace std;

class Building {
    
    friend void person1(Building* building);
public:
    Building()
    {
        m_SittingRoom = "客厅";
        m_BedRoom = "卧室";
    }
    string m_SittingRoom;
private:
    string m_BedRoom;
};

void person1(Building *building)
{
    cout << "一个人正在访问  " << building->m_SittingRoom << endl;
    cout << "一个人正在访问  " << building->m_BedRoom << endl;
}

void test1() {
    Building building;
    person1(&building);
}

int main() {

    test1();

    system("pause");
    return 0;
}
 

 =====继承=====
 
//继承的基本语法
#include
using namespace std;

class basePage
{
public:
    void header()
    {
        cout << "首页、公开课" << endl;
    }
    void footer()
    {
        cout << "帮助中心、交流合作" << endl;
    }
    void left()
    {
        cout << "学习内容" << endl;
    }
};

//继承的基本语法
class Java : public basePage   //Jave页面
{
public:
    void content()
    {
        cout << "Java学科视频" << endl;
    }
};

//Python页面
class Python : public basePage
{
public:
    void content()
    {
        cout << "Python学习视频" << endl;
    }
};

//c++页面
class Cpp: public basePage
{
public:
    void content()
    {
        cout << "c++学习资料" << endl;
    }
};

void test01()
{
    cout << "Java页面如下 " << endl;
    Java ja;
    ja.header();
    ja.content();
    ja.left();
    ja.footer();
    cout << "--------------" << endl;
}
void test02()
{
    cout << "Python页面如下 " << endl;
    Python py;
    py.header();
    py.content();
    py.left();
    py.footer();
    cout << "--------------" << endl;
}
void test03()
{
    cout << "c++页面如下 " << endl;
    Cpp cpp;
    cpp.header();
    cpp.content();
    cpp.left();
    cpp.footer();
    cout << "--------------" << endl;
}
int main() {

    test01();
    test02();
    test03();

    system("pause");
    return 0;

}
 

 =====继承方式=====
 继承的语法： class 子类 ： 继承方式  父类

 继承方式一共有三种：公共继承  保护继承  私有继承

 
 继承方式区别.jpg
 
 子类也称为派生类，父类也称为基类

 父类中的私有成员在子类中无法访问，但是私有成员只是被隐藏了，还是会继承下去

 =====继承中的对象模型=====
 父类中所有非静态成员属性都会被子类继承下去

 父类中私有成员属性是被编译器给隐藏了，因此是访问不到的，但是确实被继承下去了

 =====继承中的构造和析构顺序=====
 先构造父类，再构造子类；析构的顺序与构造正好相反

 =====继承同名成员处理方式=====
 访问子类同名成员，直接访问即可

 访问父类同名成员，需要加作用域（：：  即双冒号）
 
//同名函数处理，访问父类同名成员时需要加作用域
#include
using namespace std;

class base
{
public:
    base()
    {
        m_A = 100;
    }
    int m_A;
    void func(int a)
    {
        cout << "base  func 调用" << endl;
    }
};

class Son : public base
{
public:
    Son() {
        m_A = 200;
    }
    int m_A;
    void func()
    {
        cout << "Son  func 调用" << endl;
    }
};
//同名成员属性的处理方式
void test01()
{
    Son s;
    cout << "Son 下 m_A = " << s.m_A << endl;
    cout << "base 下 m_A = " << s.base::m_A << endl;     //如果通过子类对象访问父类中同名成员，需要加作用域
}
//同名成员函数处理
void teat02()
{
    Son s;
    s.func();   //直接调用，调用的是子类中的同名成员
        // 加作用域调用父类中的同名函数

    //如果子类中出现和父类同名的成员函数，子类的同名成员会隐藏父类中所有同名成员函数
    //如果想访问父类中被隐藏的同名成员函数，需要加作用域
    s.base::func(100);
}

int main()
{
    test01();

    system("pause");
    return 0;
}
 

 =====继承中同名静态成员处理方式=====
 访问子类同名成员，直接访问即可

 访问父类同名成员，需要加作用域

 =====多继承语法=====
 c++允许一个类继承多个类

 语法：class 子类 ： 继承方式 父类1 ， 继承方式 父类2 ， ............

 多继承可能会引发父类中有同名成员出现，需要加作用域区分

 c++实际开发中不建议用多继承

 =====菱形继承（钻石继承）=====
 菱形继承的概念：

 两个派生类继承同一个基类

 又有某个类同时继承两个派生类
 
//菱形继承
#include
using namespace std;

class Animal 
{
public:
    int m_Age;
};
//利用虚继承解决菱形继承的问题
//继承之前加上关键字virtual变为虚继承
//Animal类称为虚基类
class Sheep : virtual public Animal{};
class Tuo : virtual public Animal{};
class SheepTuo : public Sheep,public Tuo{};

void test1()
{
    SheepTuo st;
    //当菱形继承，；两个父类拥有相同数据，需要加以作用域区分
    st.Sheep::m_Age = 10;
    st.Tuo::m_Age = 12;
    cout << "羊的年龄 " << st.Sheep::m_Age << endl;
    cout << "坨的年龄 " << st.Tuo::m_Age << endl;
}

int main()
{
    test1();
    system("pause");
    return 0;
}
 

 =====多态=====
 静态多态：函数重载和运算符重载属于静态多态 复用函数名

 动态多态：派生类和虚函数（函数前加上virtual关键字成为虚函数）实现时多态

 静态多态额动态多态的区别：1、静态多态的函数地址早绑定-编译阶段确定函数地址  2、动态多态的函数地址晚绑定-运行阶段确定函数地址

 多态满足条件：1、有继承关系 2、子类重写父类中的虚函数

 多态使用条件：1、父类指针或引用指向子类对象

 重写：函数返回值类型 函数名 参数列表 完全一致称为重写
 
//多态的基本语法
#include
using namespace std;

class Animal
{
public:
    virtual void speak()     //虚函数    通过构造虚函数实现动态多态，进而实现地址的晚绑定
    {
        cout << "动物在说话" << endl;
    }
};

class Cat : public Animal
{
public:
    void speak()
    {
        cout << "小猫在说话" << endl;
    }
};

class Dog : public Animal
{
public:
    void speak() 
    {
        cout << "小狗在说话" << endl;
    }
};

void doSpeak(Animal &animal)     //地址早绑定  在编译阶段确定函数地址。如果想执行让猫说话，那么这个函数地址不能提前绑定，需要在运行阶段进行绑定，地址晚绑定
{
    animal.speak();
}

void test1()
{
    Cat cat;
    doSpeak(cat);

    Dog dog;
    doSpeak(dog);
}
int main()
{
    test1();

    system("pause");
    return 0;
}
 

 ======纯虚函数和抽象类======
 父类中的虚函数没有实际意义，所以将父类中的虚函数改为纯虚函数

 纯虚函数语法：virtual 返回值类型 函数名 （参数列表）= 0；

 当类中有了纯虚函数，这个类也称为抽象类

 抽象类特点：1、无法实例化对象 2、子类必须重写抽象类中的纯虚函数，否则也属于抽象类

 例如：在父类中有一个成员函数为 virtual void func() = 0;   父类中存在纯虚函数，则在子类中必须重写抽象类中的纯虚函数 即virtual void func()  {....}

 ======虚析构和纯虚析构======
 多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码

 解决方式：将父类中的析构函数改为虚析构或者纯虚析构

 虚析构和纯虚析构共性：1、可以解决父类指针释放子类对象 2、都需要有具体的函数实现

 虚析构和纯虚析构区别：如果是纯虚虚构，该类属于抽象类，无法实例化对象
 
//虚析构和纯虚析构
#include
using namespace std;
#include

class Animal
{
public:
    virtual void speak() = 0;
    Animal()
    {
        cout << "animal的构造函数调用" << endl;
    }
    virtual ~Animal()      //利用虚析构解决堆区释放不干净的问题
    {
        cout << "animal的析构函数调用" << endl;
    }
};

class Dog : public Animal
{
public:
    Dog(string name)
    {
        cout << "dog的构造函数调用" << endl;
        m_Name = new string(name);
    }
    virtual void speak()
    {
        cout <<*m_Name<< "小狗在说话" << endl;
    }
    ~Dog()
    {
        cout << "dog的析构函数调用" << endl;
        if (m_Name != NULL)
        {
            delete m_Name;
            m_Name = NULL;
        }
    }
    string *m_Name;
};

void test2()
{
    Animal* animal = new Dog("Tim");
    animal->speak();
    //父类指针在析构时候 不会调用子类中析构函数，导致子类如果有堆区属性，出现内存泄露
    delete animal;
}

int main()
{
    test2();
    system("pause");
    return 0;
}
 

 虚析构：在父类析构函数前加virtual

 纯虚析构：在父类中，令虚析构函数 = 0改为纯虚析构。

 纯虚析构需要在父类中进行声明，也需要有具体实现

 例如：父类为

 class Animal{
 public:
           virtual ~Animal() = 0;      //纯虚析构
 };
 //具体实现
 Animal::~Animal()
 {
      cout<<"Animal纯虚析构函数的调用"< }
 =====文件操作=====
 程序运行时产生的数据都属于临时数据，程序一旦运行结束都会被释放

 通过文件可以将数据持久化

 c++中对文件操作需要包含头文件

 文件类型分为两种：

 1、文本文件：文件以文本的ASCII码形式存储在计算机中

 2、二进制文件：文件以文本的二进制形式存储在计算机中，用户一般不能直接读它们

 操作文件的三大类：1、ofstream：写操作（o代表output）  2、ifstream：读操作（i代表input）  3、fstream：读写操作

 ======文本文件======
 =======写文件=======
 1、包含头文件     #include

 2、创建流对象     ofstream  ofs；

 3、打开文件       ofs.open("文件路径",打开方式);

 4、写数据         ofs<<"写入的数据";

 5、关闭文件       ofs.close();

 文件打开方式

 ios::in          为读文件而打开文件

 ios::out         为写文件而打开文件

 ios::ate         初始位置：文件尾

 ios::app         追加方式写文件

 ios::trunc       如果文件存在先删除，再创建

 ios::binary      二进制方式

 注意：文件打开方式可以配合使用，利用 | 操作符
 
//文本文件  写文件
#include
using namespace std;
#include
//文本文件  写文件
void test01()
{
    //1、包含头文件fstream

    //2、创建流对象
    ofstream ofs;
    //3、打开文件
    ofs.open("test.txt", ios::out);
        //4、写数据
        ofs << "姓名：张三" << endl;
        ofs << "性别：男" << endl;
    //5.关闭文件
        ofs.close();

}

int main()
{

    test01();
    system("pause");
    return 0;
}
 

 总结：

 1、文件操作必须包含头文件fstream

 2、写文件可以利用ofstream，或者fstream

 3、打开文件时候需要操作文件的路径，以及打开方式

 4、利用<<可以向文件中写数据

 5、操作完毕，要关闭文件
=======读文件=======
 1、包含头文件     #include

 2、创建流对象     ifstream  ifs；

 3、打开文件并判断打开是否成功   ifs.open("文件路径",打开方式);

 4、读数据      四种方式读取

 5、关闭文件       ifs.close();
 
///文本文件 读文件
#include
#include
using namespace std;
#include

//文本文件 读文件
void test02()
{
    //1、包含头文件
    //2、创建流对象
    ifstream ifs;
    //3、打开文件，判断文件打开是否成功
    ifs.open("test.txt", ios::in);
    if (!ifs.is_open())
    {
        cout << "文件打开失败" << endl;
        return;
    }
    //4、读文件
    //4.1第一种方式读文件
    char buf[1024] = { 0 };
    while (ifs >> buf)
    {
        cout << buf << endl;
    }
    //4.2第二种方式读文件
    char buf[1024] = { 0 };
    while (ifs.getline(buf,sizeof(buf)))
    {
        cout << buf << endl;
    }
    //4.3第三种方式读文件
    string buf;
    while (getline(ifs, buf))             //getline表示得到一行，把ifs中的一行写入buf
    {
        cout << buf << endl;
    }
    //4.4第四种方式读文件
    char c;
    while ((c = ifs.get()) != EOF)      //EOF : end of file
    {
        cout << c;
    }
    //5、关闭文件
    ifs.close();
}

int main()
{

    test02();
    system("pause");
    return 0;
}
 

 总结：

 1、读文件可以利用ifstream，或者fstream

 2、利用is_open函数可以判断文件是否打开成功

 3、close关闭文件

 ======二进制文件======
 以二进制的方式对文件进行读写操作

 打开方式要制定为ios::binary

 =======写文件=======
 二进制方式写文件主要利用流对象调用成员函数write

 函数原型：ostream& write(const char * buffer,int len);

 参数解释：字符指针buffer指向内存中一段存储空间，len是读写的字节数
 
//二进制文件  写文件
#include
#include
using namespace std;

class Person
{
public:
    char m_Name[64];
    int m_Age;
};

void test1()
{
    ofstream ofs;
    ofs.open("person.txt", ios::binary | ios::out);

    Person p = { "张三",18 };
    ofs.write((const char*)&p, sizeof(Person));
    ofs.close();
}

int main()
{

    test1();
    system("pause");
    return 0;
}
 

 =======读文件=======
 二进制方式读文件主要利用流对象调用成员函数read

 函数原型： istream& read(char *buffer,int len);

 参数解释：字符指针buffer指向内存中一段存储空间，len是读写的字节数
 
//二进制文件  读文件
#include
#include
using namespace std;

class Person
{
public:
    char m_Name[64];
    int m_Age;
};

void test2()
{
    ifstream ifs;
    ifs.open("Person.txt", ios::binary|ios::in);
    if (!ifs.is_open())
    {
        cout << "文件打开失败" << endl;
    }
    Person p;
    ifs.read((char*)&p, sizeof(Person));
    ifs.close();
}
int main()
{

    test2();
    system("pause");
    return 0;
}


=====vector容器中存放自定义的数据类型=====
 

//=vector容器中存放自定义的数据类型
#include
using namespace std;
#include

class Person
{
public:

    Person(string name, int age)
    {
        this->m_Name = name; this->m_Age = age;
    }
    string m_Name;
    int m_Age;
};

void test1()
{
    
    //v.push_back(p1);
    向容器中添加数据
    //v.push_back(p2);
    //v.push_back(p3);
    //v.push_back(p4);
    //遍历容器中的数据
    for (vector::iterator it = v.begin(); it != v.end(); it++)
    {
        cout << "姓名:" << (*it).m_Name << "  年龄：" << (*it).m_Age << endl;     //it相当于一个指针，指向<>中的数据类型，*it为解引用操作，解出来的是Person数据类型
    //解引用再.出Person的属性，或者it指针指向Person的属性也可以，即it->m_Age
    }
}

//向vector容器中存放自定义数据类型的指针
void test2()
{
    vector v;
    Person p1("张三", 19);
    Person p2("李四", 56);
    Person p3("王五", 49);
    Person p4("赵六", 29);
    v.push_back(&p1);
    v.push_back(&p2);
    v.push_back(&p3);
    v.push_back(&p4);
    for (vector::iterator it = v.begin(); it != v.end(); it++)
    {
        cout << "姓名： " << (*it)->m_Name << " 年龄： " << (*it)->m_Age << endl;
    }
}

int main()
{
    test2();

    system("pause");
    return 0;
}
 

 =====vector容器嵌套容器=====
 
//
#include
using namespace std;
#include

//容器嵌套容器
void test3()
{
    vector> v;
    //创建小容器
    vector v1;
    vector v2;
    vector v3;
    vector v4;
    //向小容器中投放数据
    for (int i = 0; i < 4; i++)
    {
        v1.push_back(i + 1);
        v1.push_back(i + 2);
        v1.push_back(i + 3);
        v1.push_back(i + 4);
    }
    //将小容器插入到大容器中
    v.push_back(v1);
    v.push_back(v2);
    v.push_back(v3);
    v.push_back(v4);
    //通过大容器，把所有数据遍历一遍
    for (vector>::iterator it = v.begin(); it != v.end(); it++)
    {
        //(*it)  就是小容器vector
        for (vector::iterator vit = (*it).begin(); vit != (*it).end(); vit++)
        {
            cout << *vit << " ";
        }
        cout << endl;
    }
}

int main()
{
    test3();

    system("pause");
    return 0;
}
 

 =====string=====
 本质：string是c++风格的字符串，而string本质上是一个类

 string和char*的区别：char*是一个指针；string是一个类，类内部封装了char*，管理这个字符串，是一个char*型的容器

 特点：string类内部封装了很多成员方法。例如：查找find，拷贝copy，删除delete，替换replace，插入insert； string管理char*分配的内存，不用担心赋值越界和取址越界等，由类内部进行负责

 =====string构造函数=====
 构造函数原型：

 string();                               //创建一个空的字符串，例如：string str；

 string(const char* s);          //使用字符串s初始化

 string(const string& str);    //使用一个string对象初始化另一个string对象

 string(int n,char c);            //使用n个字符c初始化
 
//
#include
using namespace std;

void test01()
{
    string s1;   //默认构造函数
    const char* str = "hello world";   //c语言风格的字符串类型
    string s2(str);    //有参构造函数
    cout << "s2= "< 

 =====string赋值操作=====
 赋值的函数原型

 string& operator=(const char* s);               //char*类型字符串 赋值给当前的字符串

 string& operator=(const string &s);           //把字符串s赋值给当前的字符串

 string& operator=(char c);                        //字符赋值给当前的字符串

 string& assign(const char* s);                    //把字符串s赋值给当前的字符串

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

 string& assign(const string &s);                //把字符串s赋给当前字符串

 string& assign(int n,char c);                      //用n个字符c赋给当前字符串

 =====字符串拼接=====
 
//字符串拼接  append（ ， ） 参数1为拼接内容，参数2为取前几个字符
#include
using namespace std;

void test01()
{
    string str1 = "我";
    str1 += "爱科研";
    cout << "str1= " << str1 << endl;

    str1 += '!';
    cout << "str1= " << str1 << endl;

    string str2 = "UE c++";
    str1 += str2;
    cout << "str1= " << str1 << endl;
    
    string str3 = "I ";
    str3.append("love ");
    cout << "str3= " << str3 << endl;

    str3.append("ccc xxx sss", 4);    //取前四个字符，空格也算一个字符
    cout << "str3= " << str3 << endl;

    str3.append(str2);
    cout << "str3= " << str3 << endl;

    str3.append(str2, 0, 2);       //拼接str2,参数1是拼接的对象，参数2是拼接截取的起始位置，参数3是截取的字符个数
    cout << "str3= " << str3 << endl;
}

int main()
{
    test01();

    system("pause");
    return 0;
}
 

 =====字符串的查找与替换=====
 
//字符串的查找
#include
using namespace std;

//字符串的查找
void test1()
{
    string str1 = "lxkcxs";
    int pos = str1.find('c');
    if (pos == -1)
    {
        cout << "未找到相关内容" << endl;
    }
    else
    {
        cout << "找到相关内容 pos= " << pos << endl;
    }

    int pos2 = str1.rfind('x');             //rfind是查询内容的最后出现位置
    cout << "pos2= " << pos2 << endl;
}
//字符串的替换
void test2()
{
    string str2 = "aaabbbccc";
    str2.replace(2, 2, "1111");           //参数1是替换起始位置，参数2是替换字符个数，参数3是要替换的内容，内容都会替换进去
    cout << "str2= " << str2 << endl;    
}

int main()
{
    test1();
    test2();

    system("pause");
    return 0;
}
 

 =====字符串比较=====
 功能描述：字符串之间的比较

 比较方式：字符串比较是按字符的ASCII码进行对比

 =返回 0；>返回 1；<返回-1

 函数原型：

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

 int compare(const char *s) const;           //与字符串s比较
 
//字符串的比较
#include
using namespace std;

void test()
{
    string str1 = "lxk";
    string str2 = "cxk";

    if (str1.compare(str2) == 0)
    {
        cout << "str1 等于 str2" << endl;
    }
    else if (str1.compare(str2) > 0)
    {
        cout << "str1 大于 str2" << endl;
    }
    else if (str1.compare(str2) < 0)
    {
        cout << "str1 小于 str2" << endl;
    }
}

int main()
{
    test();

    system("pause");
    return 0;
}
 

 =====string字符存取=====
 string中单个字符存取方式有两种

 char& operator[ ](int n);          //通过[]方式取字符

 char& at(int n);                        //通过at方法获取字符
 
//字符串存取
#include
using namespace std;

void test()
{
    string str = "hello";

    //通过[]访问单个字符
    for (int i = 0; i < str.size(); i++)
    {
        cout << str[i] << " " << endl;
    }

    //通过at方式访问单个字符
    for (int i = 0; i < str.size(); i++)
    {
        cout << str.at(i) << endl;
    }

    //修改单个字符
    str[0] = 'x';
    str.at(1) = 'x';
}
int main()
{
    test();

    system("pause");
    return 0;
}
 

 =====string插入和删除=====
 
//string插入和删除
#include
using namespace std;

void test()
{
    string str = "hello";

    //插入
    str.insert(1, "111");    //insert函数的参数1是插入位置，参数2是插入内容
    cout << "str= " << str << endl;

    //删除
    str.erase(1, 3);       //erase函数的参数1是删除开始位置，参数2是删除的字符个数
}

int main()
{
    test();

    system("pause");
    return 0;
}
 

 =====string子串=====
 功能描述：从字符串中获得想要的子串

 函数原型：string substr(int pos = 0,int n = npos) const;     //返回由pos开始的n个字符组成的字符串
 
//string子串
include
using namespace std;

void test()
{
    string str = "asdfgh";
    string subStr = str.substr(1, 3);            //substr函数的参数1是子串截取起始位置，参数2是截取的字符个数
    cout << "subStr= " << subStr << endl;
}

//实用操作
void email()
{
    string email = "xk_li@bupt.edu.cn";
    int pos = email.find('@');
    string Name = email.substr(0, pos);
    cout << "邮箱的主人是 " << Name << endl;
}

int main()
{
    test();
    email();

    system("pause");
    return 0;
}
 

 =====vector容器=====
 vector基本概念

 功能：vector数据结构和数组非常相似，也称为单端数组

 vector与普通数组区别：不同之处在于数组是静态空间，而vector可以动态扩展

 动态扩展：并不是在原空间之后续接新空间，而是找更大的内存空间，然后将原数据拷贝新空间，释放原空间

 ======vector构造函数======
 函数原型：

 vector v;                               //采用模板实现类实现，默认构造函数

 vector(v.begin( ), v.end( ) );             // 将v[begin(),end())区间中的元素拷贝给本身

 vector(n, elem);                          //构造函数将n个elem拷贝给本身

 vector(const vector &vec);                //拷贝构造函数
 
//vector容器构造函数
#include
using namespace std;
#include

void printVector(vector &v)
{
    for (vector::iterator it = v.begin(); it != v.end(); it++)
    {
        cout << *it << " " ;
    }
    cout << endl;
}

void test01()
{
    vector v1;    //默认构造  无参构造
    for (int i = 0; i < 10; i++)
    {
        v1.push_back(i);
    }

    vector v2(v1.begin(), v1.end());   //通过区间方式进行构造
    vector v3(10, 100);     //n个elem方式构造,参数1是插入内容，参数2是个数
    vector v4(v3);         //拷贝构造函数
    printVector(v1);
    printVector(v2);
    printVector(v3);
    printVector(v4);
}

int main()
{
    test01();

    system("pause");
    return 0;
}
 

 ======vector赋值操作======
 给vector容器进行赋值

 函数原型

 vector& operator=( const vector &vec);     //重载等号操作符

 assign(beg,end);                           //将[beg,end）区间中的数据拷贝赋值给本身

 assign(n,elem);                           //将n个elem拷贝给本身
 
//vector容器赋值操作
#include
using namespace std;
#include

void printVector(vector& v)
{
    for (vector::iterator it = v.begin(); it != v.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;
}

void test01()
{
    vector v1;    //默认构造  无参构造
    for (int i = 0; i < 10; i++)
    {
        v1.push_back(i);
    }
    printVector(v1);

    //直接等号赋值
    vector v2;
    v2 = v1;
    printVector(v2);

    //assign
    vector v3;
    v3.assign(v1.begin(), v1.end());
    printVector(v3);

    //n个elem方式赋值
    vector v4;
    v4.assign(10, 100);
    printVector(v4);
}

int main()
{
    test01();

    system("pause");
    return 0;
}
 

 ======vector容量和大小======
 函数原型

 empty();                         //判断容器是否为空 
 
 capacity();                      //容器的容量

 size();                         //返回容器中元素的个数

 resize(int num);               //重新制定容器的长度为num，若容器变长，则以默认值0填充新位置；如果容器变短，则末尾超出容器长度的元素被删除

 resize(int num,elem);          //重新制定容器的长度为num，若容器变长，则以elem值填充新位置；如果容器变短，则末尾超出容器长度的元素被删除

 ======vector的插入与删除======
 函数原型：

 push_back(ele);                                                         //尾部插入ele

 pop_back();                                                             //删除最后一个元素

 insert(const_iterator pos,ele);                                         //迭代器指向位置pos插入元素ele

 insert(const_iterator pos,int count,ele);                              //迭代器指向位置pos插入count个元素ele

 erase(const_iterator pos);                                             //删除迭代器指向元素

 erase(const_iterator start,const_iterator end);                        //删除迭代器从start到end之间的元素

 clear();                                                                //删除容器中所有元素

 ======vector数据存取======
 函数原型：

 at(int idx);         //返回索引idx所指的数据

 operator[];         //返回索引idx所指的数据

 front();            //返回容器中第一个数据元素

 back();             //返回容器中最后一个数据元素
 
//vector数据存取
#include
using namespace std;
#include

void printVector(vector&v)
{
    for (vector::iterator it = v.begin(); it != v.end(); it++)
    {
        cout << *it << " " ;
    }
    cout << endl;
}

void test01()
{
    vector v1;
    for (int i = 0; i < 10; i++)
    {
        v1.push_back(i + 2);
    }
    printVector(v1);

    //利用[]方式访问数组中的元素
    for (int j = 0; j < v1.size(); j++)
    {
        cout << v1[j] << " ";
    }
    cout << endl;

    //利用at方式访问元素
    for (int k = 0; k < v1.size(); k++)
    {
        cout << v1.at(k) << " ";
    }
    cout << endl;

    //获取第一个元素
    cout << "第一个元素为：" << v1.front() << endl;
    //获取最后一个元素
    cout << "最后一个元素为：" << v1.back() << endl;
}

int main()
{
    test01();
    system("pause");
    return 0;
 

 ======vector互换容器======
 函数原型：

 swap（vec）；           //将vec与本身的元素互换

 v1.swap(v2);            //v1和v2元素互换

 巧用swap收缩内存      vector(v).swap(v);v
 ======vector预留空间======
 功能描述：减少vector在动态扩展容量时的扩展次数

 函数原型：   reserve(int len);    //容器预留len个元素长度，预留位置不初始化，元素不可访问

 =====deque容器=====
 ：  双端数组，可以对头端进行插入删除操作

 deque容器的迭代器也是支持随机访问的

 （函数接口基本同vector容器的构造函数）

 ======deque构造函数====== 
 函数原型：

 dequedeqT;                        //默认构造形式

 deque(beg,end);                      //构造函数将[beg,end]区间中的元素拷贝给本身

 deque(n,elem);                       //构造函数将n个elem拷贝给本身

 deque(const deque &deq);    //拷贝构造函数

 ======deque赋值操作======
 函数原型：

 deque& operator=(const deque &deq);                      //重载等号操作符

 assign(beg,end);                                         //将[beg,end]区间中的数据拷贝赋值给本身

 assign(n,elem);                                          //将n个elem拷贝赋值给本身
 
//deque构造函数
#include
using namespace std;
#include

void printDeque(const deque &d)
{
    for (deque::const_iterator it = d.begin(); it != d.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;
}

void test01()
{
    deque d1;

    for (int i = 0; i < 10; i++)
    {
        d1.push_back(i);
    }

    printDeque(d1);

    //等号赋值
    deque d2;
    d2 = d1;
    printDeque(d2);

    //assign赋值
    deque d3;
    d3.assign(d1.begin(), d1.end());
    printDeque(d3);

    //n个elem赋值
    deque d4;
    d4.assign(10, 100);
    printDeque(d4);
}

int main()
{
    test01();

    system("pause");
    return 0;
}
 

 ======deque大小操作======
 函数原型：

 deque.empty();                         //判断容器是否为空  

 deque.size();                          //容器的容量

 deque.resize(num);                     //重新制定容器的长度为num，若容器变长，则以默认值0填充新位置；如果容器变短，则末尾超出容器长度的元素被删除

 deque.resize(num,elem);                //重新制定容器的长度为num，若容器变长，则以elem值填充新位置；如果容器变短，则末尾超出容器长度的元素被删除

 ======deque插入和删除======
 函数原型：

 push_back(elem);         //在容器尾部添加一个数据

 push_front(elem);       //在容器头部插入一个数据

 pop_back();             //删除容器最后一个数据

 pop_front();            //删除容器第一个数据

 指定位置操作：       
    
 insert（pos,elem);              //在pos位置插入一个elem元素的拷贝，返回新数据的位置

 insert(pos,n,elem);             //在pos位置插入n个elem数据，无返回值

 insert(pos,beg,end);           //在pos位置插入[beg,end]区间的数据，无返回值

 clear();                       //清空容器的所有数据

 erase(beg,end);               //删除[beg,end]区间的数据，返回下一个数据的位置

 erase(pos);                   //删除pos位置的数据，返回下一个数据的位置

 ======deque数据存取======
 函数原型：

 at(int idx);       //返回索引idx所指的数据

 operator[];        //返回索引idx所指的数据

 front();           //返回容器中第一个数据元素

 back();           //返回容器中最后一个数据元素

 ======deque排序======
 sort(d.begin(),d.end());  使用算法sort需要包含algorithm头文件   默认排序规则从小到大的升序
 
//sort排序
#include
using namespace std;
#include
#include   //标准算法头文件

void printDeque(const deque& d)
{
    for (deque::const_iterator it = d.begin(); it != d.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;
}

void test1()
{
    deque d1;
    d1.push_back(10);
    d1.push_back(20);
    d1.push_back(30);
    d1.push_front(100);
    d1.push_front(300);
    d1.push_front(200);

    cout << "排序前： " << endl;
    printDeque(d1);

    cout << "排序后： " << endl;
    sort(d1.begin(), d1.end());  //排序  默认排序规则从小到大的升序

}

int main()
{
    test1();

    system("pause");
    return 0;
}
 

 ====stack容器=====
 stack是一种先进后出的数据结构，它只有一个出口

 栈中只有顶端的元素才可以被外界使用，因此栈不允许有遍历行为

 栈中进入数据为——入栈push

 栈中弹出数据为——出栈pop

 栈可以判断容器是否为空吗？可以  empty()

 栈可以返回元素个数吗？  可以  size()

 ======stack常用接口======
 构造函数：

 stack stk;                     //stack采用模板类实现，stack对象的默认构造形式

 stack(const stack &stk);          //拷贝构造函数

 赋值操作：stack& operator= (const stack &stk);     //重载等号操作符

 数据存取：

 push(elem);         //向栈顶添加元素

 pop();              //从栈顶移除第一个元素（出栈）

 top();              //返回栈顶元素

 大小操作：

 empty();      //判断堆栈是否为空

 size();       //返回栈的大小
 
//stack容器常用接口的使用
#include
using namespace std;
#include

void test01()
{
    stack s;
    s.push(10);
    s.push(20);
    s.push(30);
    s.push(40);

    while (!s.empty())
    {
        cout << "栈顶的元素为： " << s.top() << endl;   //查看栈顶元素

        s.pop();    //出栈
    }

    cout <<"栈的大小 "<< s.size() << endl;
}

int main()
{
    test01();

    system("pause");
    return 0;
}
 

 =====queue容器=====
 概念：queue是一种先进先出的数据结构，它有两个出口

 队列容器允许从一端新增元素，从另一端移除元素

 队列中只有对头和队尾才可以被外界使用，因此队列不允许有遍历行为

 队列中进数据称为  入队push

 队列出数据称为    出队pop

 queue只有队头和队尾能被外界访问，所以不允许有遍历行为

 ======queue常用接口======
 构造函数：

 queue que;                    //queue采用模板类实现，queue对象的默认构造形式

 queue(const queue &que);        //拷贝构造函数

 赋值操作：

 queue& operator= (const queue &que);   //重载等号操作符

 数据存取：

 push(elem);   //往队尾添加元素

 pop();        //从队头移除第一个元素

 back();       //返回最后一个元素

 front();      //返回第一个元素

 大小操作：

 empty();      //判断堆栈是否为空

 size();       //返回栈的大小
 
//queue容器常用接口
#include
using namespace std;
#include

class Person
{
public:
    Person(string name,int age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }

    string m_Name;
    int m_Age;
};

void test01()
{
    queue q;

    Person p1("张三", 30);
    Person p2("李四", 36);
    Person p3("王五", 22);
    Person p4("赵六", 20);

    q.push(p1);
    q.push(p2);
    q.push(p3);
    q.push(p4);

    while (!q.empty())
    {
        //查看队头元素
        cout <<"队头数据元素------姓名： " << q.front().m_Name <<" "<<"年龄： "< 
=====list容器=====
 功能：将数据进行链式存储

 链表是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的

 链表是由一系列结点组成的

 结点的组成：一个是存储数据元素的数据域，另一个是存储下一个结点的指针域

 优点：可以对任意位置进行快速插入和删除元素

 缺点：容器的遍历速度没有数组快，占用空间比数组大

 STL中的链表是一个双向循环链表

 ======list构造函数======
 
//list构造函数
#include
using namespace std;
#include

void printList(const list& L)
{
    for (list::const_iterator it = L.begin(); it != L.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;
}

void test1()
{
    listL1;     //默认构造
    L1.push_back(10);
    L1.push_back(20);
    L1.push_back(30);
    L1.push_back(40);

    printList(L1);

    list L2(L1.begin(), L1.end());
    printList(L2);

    listL3(10, 100);
    printList(L3);

    list L4(L3);
    printList(L4);
}

int main()
{
    test1();

    system("pause");
    return 0;
}
 

 ======list赋值和交换======
 等号赋值

 assign函数

 swap函数进行交换

  
//类型
#include
using namespace std;
#include

void printList(const list& L)
{
    for (list::const_iterator it = L.begin(); it != L.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;
}

void test1()
{
    listL1;    
    L1.push_back(10);
    L1.push_back(20);
    L1.push_back(30);
    L1.push_back(40);

    listL2;
    L2 = L1;     //等号赋值

    listL3;
    L3.assign(L2.begin(), L2.end());

    list L4;
    L4.assign(10,100);

    printList(L1);
    printList(L2);
    printList(L3);

    printList(L4);
}

void test2()
{
    listL1;
    L1.push_back(10);
    L1.push_back(20);
    L1.push_back(30);
    L1.push_back(40);

    list L2;
    L2.assign(10, 100);

    L1.swap(L2);

    printList(L1);
    printList(L2);
}

int main()
{
    test1();

    test2();

    system("pause");
    return 0;
}
 

 ======list大小操作======
 list.empty();                      //判断容器是否为空  

 list.size();                          //容器的容量

 list.resize(num);               //重新制定容器的长度为num，若容器变长，则以默认值0填充新位置；如果容器变短，则末尾超出容器长度的元素被删除

 list.resize(num,elem);      //重新制定容器的长度为num，若容器变长，则以elem值填充新位置；如果容器变短，则末尾超出容器长度的元素被删除

 ======list插入和删除======
 push_back(elem);       //在容器尾部加入一个元素

 pop_back();               //删除容器中最后一个元素

 push_front();             //在容器开头插入一个元素

 pop_front();              //从容器开头移除一个元素

 insert(pos,elem);       //在pos位置插入elem元素的拷贝，返回新数据的位置

 insert(pos,n,elem);    //在pos位置插入n个elem数据，无返回值

 insert(pos,beg,end);   //在pos位置插入[beg,end]区间的数据，无返回值

 clear();                      //移除容器的所有数据

 erase(beg,end);         //删除[beg,end]区间的数据，返回下一个数据的位置

 erase(pos);             //删除pos位置的数据，返回下一个数据的位置

 remove(elem);        //删除容器中所有与elem值匹配的元素

 ======list数据存取======
 函数原型：

 front();          //返回第一个元素

 back();          //返回最后一个元素

 ======list反转和排序======
 函数原型:

 reverse();    //反转链表

 sort();        //链表排序
 
//list反转和排序
#include
using namespace std;
#include

void printList(const list& L)
{
    for (list::const_iterator it = L.begin(); it != L.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;
}

void test01()
{
    //反转
    listL1;
    L1.push_back(20);
    L1.push_back(5);
    L1.push_back(55);
    L1.push_back(40);
    cout << "反转前：" << endl;
    printList(L1);

    L1.reverse();
    cout << "反转后：" << endl;
    printList(L1);
}

bool myCompare(int v1,int v2)
{
    //降序，就让第一个数>第二个数
    return v1 > v2;
}

void test02()
{
    //排序
    listL1;
    L1.push_back(20);
    L1.push_back(5);
    L1.push_back(55);
    L1.push_back(40);
    cout << "排序前：" << endl;
    printList(L1);

    
    L1.sort();              //默认排序规则 从小到大  升序
    cout << "排序后：" << endl;
    printList(L1);

    L1.sort(myCompare);   //降序操作
    printList(L1);
}

int main()
{
    test01();

    system("pause");
    return 0;
}
 

 =====set/mutliset容器=====
 所有元素都会在插入时自动排序

 本质：set/mutliset是属于关联式容器，地层结构是用二叉树实现

 ======set和mutliset的区别======
 set不允许容器中有重复的元素

 mutliset允许容器中有重复的元素

 ======构造======
 set st;   //默认构造函数

 set(const set &st);    //拷贝构造函数

 ======赋值======
 set& operator=(const set &st);   //重载等号操作符

 插入数据只有insert()方式

 ======set大小和交换======
 size();                //返回容器中元素的数目

 empty();           //判断容器是否为空

 swap(st);           //交换两个集合容器

 ======set插入和删除======
 函数原型：

 insert(elem);        //在容器中插入元素

 clear();                //清除所有数据

 erase(pos);          //删除pos迭代器所指的元素，返回下一个元素的迭代器

 erase(beg,end);  //删除区间[beg,end]的所有元素，返回下一个元素的迭代器

 erase(elem);     //删除容器中值为elem的元素

 ======set查找和统计======
 函数原型：

 find(key);   //查找key是否存在，若存在，返回该键的迭代器；若不存在，返回set.end();

 count(key);     //统计key的元素个数
 
//查找和统计
#include
using namespace std;
#include

void printSet(set& s)
{
    for (set::iterator it = s.begin(); it != s.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;
}

void test1()
{
    //查找
    set s1;
    s1.insert(20);
    s1.insert(30);
    s1.insert(10);
    s1.insert(50);

    printSet(s1);

    set::iterator pos = s1.find(30);

    if (pos != s1.end())
    {
        cout << "找到元素：" <<* pos << endl;
    }
    else {
        cout << "未找到元素：" << *pos << endl;
    }
}

void test2()
{
    //统计
    set s1;
    s1.insert(20);
    s1.insert(30);
    s1.insert(10);
    s1.insert(50);

    int num = s1.count(30);
    cout << "num= " << num << endl;
}

int main()
{
    test1();
    test2();

    system("pause");
    return 0;
}
 

 ======pair对组创建======
 功能描述：成对出现的数据，利用对组可以返回两个数据

 两种创建方式：

 pair p (value1,value2);     
                
 pair p =make_pair(value1,value2);
 
//pair对组创建
#include
using namespace std;

void test1()
{
    //第一种方式创建对组
    pairp("Tom", 22);
    

    //第二种方式创建对组
    pairp2 = make_pair("Tim", 33);
    cout << "姓名：" << p2.first << " 年龄：" << p2.second << endl;
}

int main()
{
    test1();

    system("pause");
    return 0;
}
 

 ======set容器排序======
 利用仿函数可以改变排序规则
 
//存放内置数据类型
#include
using namespace std;
#include

void printSet(set& s)
{
    for (set::iterator it = s.begin(); it != s.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;
}

class myCompare      //创建一个类，返回一个数大于另一个数为真
{
public:
    bool operator()(int v1, int v2)   //仿函数
    {
        return v1 > v2;
    }
};

void test1()
{
    set s1;

    s1.insert(20);
    s1.insert(40);
    s1.insert(10);
    s1.insert(30);

    printSet(s1);

    set s2;    //指定排序规则为从大到小

    s2.insert(20);
    s2.insert(40);
    s2.insert(10);
    s2.insert(30);

    for (set::iterator it = s2.begin(); it != s2.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;
}
 
 
//存放自定义数据类型
#include
using namespace std;
#include

class Person
{
public:
    Person(string name, int age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }

    string m_Name;
    int m_Age;
};

class comparePerson
{
public:
    bool operator()(const Person& p1, const Person& p2)const
    {
        return p1.m_Age > p2.m_Age;
    }
};

void test1()
{

    //自定义数据类型 都会指定排序规则
    sets;
    Person p1("刘备", 25);
    Person p2("关羽", 23);
    Person p3("张飞", 22);
    Person p4("赵云", 26);

    s.insert(p1);
    s.insert(p2);
    s.insert(p3);
    s.insert(p4);

    for (set::iterator it = s.begin(); it != s.end(); it++)
    {
        cout << "姓名： " << it->m_Name << "  年龄： " << it->m_Age < 

 =====map/mutlimap容器=====
 map容器中所有元素都是pair

 pair中第一个元素为key（键值），起到索引作用，第二个元素为value（实值）

 所有元素都会根据元素的键值自动排序

 map/mutlimap属于关联式容器，底层结构是用二叉树实现

 优点：可以根据key值快速找到value值

 ======map和mutlimap区别：======
 map不允许容器中有重复key值元素

 mutlimap允许有重复key值元素

 ======map构造和赋值======
 函数原型：

 构造：

 mapmap;          //map默认构造函数

 map(const map &mp);  //拷贝构造函数

 赋值：

 map& operator=(const map &mp);    //重载符号操作符
 
//map容器构造和赋值
#include
using namespace std;
#include
 

 ======map大小和交换======
 函数原型：

 size();             //返回容器中元素的数目

 empty();        //判断容器是否为空

 swap(mp);    //交换两个集合容器

 ======map插入和删除======
 函数原型：

 insert(elem);            //在容器中插入元素

 clear();                 //清除所有元素

 erase(pos);             //删除pos迭代器所指的元素，返回下一个元素的迭代器

 erase(beg,end);       //删除区间[beg,end]的所有元素，返回下一个元素的迭代器

 erase(key);            //删除容器中值为key的元素
 
//插入和删除
#include
using namespace std;
#include
 

 ======map查找和统计======
 函数原型：

 find(key);            //查找key是否存在，若存在，返回该键的元素的迭代器；若不存在，返回set.end();

 count(key);         //统计key的元素个数
 
//查找和统计
#include
using namespace std;
#include
 

 ======map排序======
 默认从小到大排序

 利用仿函数，可以改变排序规则
 
//排序  利用仿函数实现从大到小排序
#include
using namespace std;
#include
 

 =====STL-函数对象=====
 函数对象：重载函数调用操作符的类，其对象称为函数对象；函数对象使用重载的（）时，行为类似函数调用，也叫仿函数

 本质：函数对象（仿函数）是一个类，不是一个函数

 函数对象使用：

 特点：

 函数对象在使用时，可以像普通函数那样调用，可以有参数，可以有返回值

 函数对象超出普通函数的概念，函数对象有自己的状态

 函数对象可以作为参数传递

 =====谓词=====
 返回bool类型的仿函数称为谓词

 如果operator()接受一个参数，那么叫做一元谓词
 
//仿函数返回bool类型，参数为1是一元谓词
#include
using namespace std;
#include

class GeaterFive
{
public:
    bool operator()(int val)    //返回布尔类型的仿函数称为谓词，一个参数为一元谓词
    {
        return val > 5;
    }
};

void test01()
{
    vectorv;
    for (int i = 0; i < 10; i++)
    {
        v.push_back(i);
    }

    //查找容器中  有没有大于5的数字
    vector::iterator it = find_if(v.begin(), v.end(), GeaterFive());   //GeaterFive()匿名函数对象
    if (it == v.end())
    {
        cout << "未找到" << endl;
    }
    else {
        cout << "找到了大于5的数" << *it << endl;
    }
}

int main()
{
    test01();

    system("pause");
    return 0;
}
 

 如果operator()接受两个参数，那么叫做二元谓词
 
//仿函数参数为2则为二元谓词
#include
using namespace std;
#include
#include

class MyCompare
{
public:
    bool operator()(int val1, int val2)   //两个参数为二元谓词
    {
        return val1 > val2;
    }
};

void test01()
{
    vector v;
    v.push_back(10);
    v.push_back(20);
    v.push_back(30);
    v.push_back(40);

    sort(v.begin(), v.end());
    for (vector::iterator it = v.begin(); it != v.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;

    //使用函数对象 改变算法策略  变为排序顺序为从大到小
    sort(v.begin(), v.end(), MyCompare());
    for (vector::iterator it = v.begin(); it != v.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;
}

int main()
{
    test01();

    system("pause");
    return 0;
}
 

 =====泛型编程 模板=====
 模板就是建立通用的模具，大大提高复用性

 模板的特点：

 模板不可以直接使用，它只是一个框架

 模板的通用并不是万能的

 c++另一种编程的思想称为泛型编程，主要利用的技术就是模板

 c++提供两种模板机制：函数模板和类模板

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

 语法：

 template

 函数声明或定义

 template  --声明创建模板

 typename --表面其后面的符号是一种数据类型，可以用class代替

 T  --通用的数据类型，名称可以替换，通常为大写字母

 注意事项：

 自动类型推导，必须推导出一致的数据类型T，才可以使用

 模板必须要确定出T的数据类型，才可以使用
 
//函数模板
#include
using namespace std;

//函数模板
template    //声明一个模板，T是一个通用的函数模板

void Swap(T& a, T& b)
{
    T temp = a;
    a = b;
    b = temp;
}

void test01()
{
    int a = 10;
    int b = 20;

    //利用函数模板进行交换
    //两种方式使用函数模板
    //1、自动类型推导  
    Swap(a, b);
    cout << "a=" << a << " b=" << b << endl;
    //2、显示指定类型
    Swap(a, b);
    cout << "a=" << a << " b=" << b << endl;
}

int main()
{
    test01();

    system("pause");
    return 0;
}
 

 ======普通函数和函数模板的调用规则======
 1、如果函数模板和普通函数都可以实现，优先调用普通函数

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

 3、函数模板也可以发生重载

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

 ======类模板======
 类模板对象做函数参数

 一共有三种：

 1、指定传入的类型  --直接显示对象的数据类型

 2、参数模板化 ----将对象中的参数变为模板进行传递

 3、整个类模板化 ----将这个对象类型 模板化进行传递
 
//类模板
#include
using namespace std;

template
class Person
{
public:
    Person(NameType name, AgeType age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }

    void showPerson()
    {
        cout << "name: " << this->m_Name << " age: " << this->m_Age << endl;
    }

    NameType m_Name;
    AgeType m_Age;
};

void test01()
{
    Person p1("张三",22);
    p1.showPerson();
}

int main()
{
    test01();

    system("pause");
    return 0;
}
 

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

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

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

 ======类模板成员函数的类外实现======
 
//类模板的类外实现
#include
#include
using namespace std;

//类模板
template
class Person
{
public:
    Person(T1 name, T2 age);

    void showPerson();

    T1 m_Name;
    T2 m_Age;
};

template
void Person::showPerson()
{
    cout << "姓名：" << this->m_Name << " 年龄：" << this->m_Age << endl;
}

void test01()
{
    Person p1("张飒", 21);
    p1.showPerson();
}


int main()
{
    test01();

    system("pause");
    return 0;
}
 

 ======类模板的分文件编写======
 分文件编写时包括头文件.h和源文件.cpp，调用标准库时include用< >，调用自己定义的库时include用“”