个人C++学习笔记

2020-07-02

个人C++学习笔记，有需要的可以拿走（可能做的不详细）。

/**********************************************************************************************************************************************/
                                                                      封装
/**********************************************************************************************************************************************/

    为什么使用堆内存：
    1.使用比较大的内存时，可能超过栈内存限制
    2.使用手动控制内存的释放，跨函数使用内存
    3.可以根据程序实际需要来分配内存大小
    
    new delete与malloc()，free()的区别：
    1、new delete 是操作符，而malloc() free()是函数，在申请内存时会创建函数栈，所以new delete效率要高。
    2、new会自动调用构造函数、delete会自动调用析构函数，而malloc和free没有这些。

引用的定义（&）：int &ref = num (ref为num的引用，绑定后不可更改)
         注：int *p = &num (这里的&是取地址符)

       ->C++没有提供读取引用地址的方式，访问引用的地址，实际上就是去访问了变量的地址。<-

         引用的类型必须和变量的类型是一样的（error: int num; long &ref = num;）。
             正确： int num = 10;
                   int &ref = num;
         引用常量的引用必须是常引用（error: int &ref = 10;）
             正确： const int &ref = 10;
引用和指针使用上的区别：1、引用在声明时必须初始化，而指针可以是野指针
                   2、引用的绑定关系不可更改，而指针可以改变指针指向
                   3、有void的指针 但是没有void的引用，有二级指针，没有二级引用
                   4、有指针引用，没有引用指针
                   5、有数组指针，也有数组引用
                   引用的本质其实是指针常量，一样的不可更改绑定关系，但C++编译器在处理引用时会自动在指针常量前加上“*”号，而处理指针常量时则依旧时地址

引用在C++中的使用：1、能作参数
                2、调用简单又能得到地址传递
                3、效率高
                既有指针做参数的效率，又比指针方便安全

                引用作返回值注意：千万不能返回一个局部变量的引用

C++新增的函数特性：
                1、内联函数（inline）：在函数名前面加个inline就是内联函数
                一般函数在调用的时候，都会创建函数栈和销毁函数栈，对于一下比较简短的函数，会比较浪费时间
                而使用内联函数的话。在调用的时候会将函数内的逻辑语句替换到函数被调用的位置，这样就不会有
                创建和销毁函数栈的动作。相当于一个带参宏替换，但是带参宏的话不会检查参数类型是否正确，不
                安全，因此就有了内联函数，既会对参数类型进行检查，而且在调用的时候会将函数内的逻辑语句替
                换到函数被调用的位置。
                注意：内联函数中逻辑语句不能超过5行，否则编译器会识别为一般函数处理。
                     内联函数不能有循环体和switch语句，否则也会当作一般函数处理。
                     内联函数中不能抛出异常，例如（throw），否则也会当作一般函数处理。
                     内联函数中不能递归，否则也会当作一般函数处理。

                2、函数重载(overload)：允许在同一范围内（同一个类，同一文件），函数名相同，参数不同（参数个数不同/参数类型不同），
                        ->与返回值类型无关。
                          调用时会根据实参的个数和类型来调用函数。
                        ->注意不要定义容易产生二义性的函数,函数要具有唯一性。

                3、函数缺省值：定义的时候必须从右往左，因为函数参数的使用顺序时从右往左。
                如果函数参数右边的参数没有设置缺省值，则当前函数也不能设置缺省值，只有右边参数定义了缺省值
                左边的才能定义。
                ->注意防止二义性


 *面向对象编程：
 * 封装、继承、多态
 * 封装成类
 * 类的继承
 * 成员函数的多态
 *
 * class 与 struct比较，在创建类时只有默认的权限不一样，class创建类时默认权限是private（私有的），
    而struct在创建类时默认权限是Public（公共的）
 *
 * 创建对象：
 * 1、一般对象创建（栈内存）：类名+对象名
 * 2、对象指针 （堆内存）：类名+对象指针名 = new + 类名   delete + 对象指针名
 * 3、对象数组 （堆内存）：类名+对象指针名 = new + 类名[ ] delete[ ] + 对象指针名
             （栈内存）：类名+对象名[i];
              
 * 4、使用构造函数创建对象（栈内存）
 * 5、匿名对象
 *
 * 特殊对象：
 *       常对象（const + 类名 + 对象名），常对象只能调用
 常函数
 *       一般对象既能调用一般函数，又能调用常函数
 
 * 常函数：（类型+函数名（）+const）例：void show（）const{}
 *       常函数中不能修改对象的值
 
 * 特殊的重载：常函数重载（例：void show（）{}   和void show（）const {}
 *                      这两个函数虽然函数名相同，参数列表相同，但是一样构成重载）
               操作符重载
 *
 * 类中的特殊数据成员：例如static int studentname； 
 *       静态数据成员：不能在类内初始化只能在类内声明，只能在类外初始化，并且初始化时不需要带static,但要加上类域
 *      一般数据成员必须通过对象才能访问，而静态数据对象可以直接通过类名直接访问。例如：cout <<student::studentname<<endl;，也可以通过对象调用。

        不管有多少个对象，如果只创建了一个静态成员变量，那就永远只会有一个，通过任意对象去调用这个变量，都会是那一个变量。
        一般数据成员对于不同的对象会有不同的成员。

         静态成员函数：静态成员函数中不能访问一般成员变量，同时也不能使用this指针，可以使用类名直接调用，也可以使用对象调用。
         只能访问静态成员变量，或者静态成员函数。
         静态成员函数中不能访问一般成员变量，一般成员函数，同时也不能使用this指针的原因是因为静态成员函数不需要对象就可以使用，而一般函数、一般成员变量、this都需要先创建对象才可以使用。

   用静态成员函数作单例模式：
         单例模式：保证在同一时刻只有一个对象存在（常用在文件管理对象）（线程池的管理对象）
         将构造函数、析构函数私有化（private），创建一个静态成员函数来获取一个对象和一个析构函数来销毁对象

/***********************************************************************/
访问权限：
                        本类             子类             类外
            默认：          可以             不可以          不可以
            private：   可以            不可以            不可以
            public:        可以            可以                  可以
            protected:    可以            可以                不可以
/************************************************************************/


-->20200422
构造函数：函数名与类名相同，并且没有任何返回值
          构造函数重载时一样需要避免二义性。
        class student
        {
        public:
            string name;
            int age;
            static int num;
        public:
            student();            <--默认构造函数
            student(string name,int age):name(name),age(age)<--带参构造函数
            {
                num++;
            }
            void SetName(string name);
            void show()const;
            static int StudentAge();
            ~student();
        };

        student stu；                            //调用无参的构造函数
        student stu("zhangsan",10);//调用带参的构造函数
        //student stu();                        //没有调用构造函数，调用的是()系统自动创建操作符重载
        student *stu = new student;//调用默认的构造函数

没有调用构造函数的情况：
        student stu4("lisi",23);
        student stu5 = stu4;                //对象stu5的创建不是调用的构造函数，而是调用的拷贝构造函数

        void  showstudent(student   stu)        //把实参值拷贝给形参时不会调用构造函数
        {    
                stu.show();
        }


写类时需要先把默认构造函数写了
默认构造函数：
            在类里没有写任何构造函数时，在创建对象时会自动创建一个默认构造函数，但值会是个随机值。
            但是如果类里面一旦写了一个带参的构造函数，那么就不会自动生成默认构造函数。
            （带参的构造函数会把系统创建的默认构造函数给屏蔽掉，所以默认构造函数必须要显示定义）


构造函数特殊其情况：
          ->类内有成员变量为指针时:
            浅拷贝：只是拷贝地址，这样有可能产生问题，如果地址指向的内存被销毁，那么指针将会变成野指针
            深拷贝：重新为指针分配内存并把值拷贝过来（相当于原封不动的Copy）。

对象初始化的方式：
            构造函数初始化：
            初始化列表：在形参列表右边加上“：”再将参数赋值给成员变量。
            例如：student（string name，int age）:name(name),age(age)
            {                                        ^           ^                            
            }
            "name(name),age(age)",括号外面的name和age是参数，括号内的是成员变量。

            ->初始化列表是在给对象分配内存的时候就调用的，在构造函数之前调用
            ->常量数据成员初始化必须在初始化列表中初始化
            ->引用数据成员初始化时必须在初始化列表中初始化
            ->其他类的对象作本类的数据成员时必须在初始化列表里初始化，不能放在构造函数内部初始化，放在内部初始化会多创建一个对象
            ->父类构造一般也在初始化列表中初始化，指定调用父类的哪种构造函数
            
            class Body
            {
            public:
                Body()
                {
                    cout << "Body()" << endl;
                    this->year = 0;
                    this->month = 0;
                    this->day = 0;
                }
                Body(int year,int month,int day)
                {
                    cout << "Body(int year,int month,int day)" << endl;
                    this->year = year;
                    this->month = month;
                    this->day = day;
                }
                void showData()
                {
                    cout << this->year << "-" << this->month << "-" << this->day << endl;
                }
            private:
                int year;
                int month;
                int day;
            };

            class student
            {
            public:
                student()
                {

                }
                student (string name,int age,int year,int month ,int day):name(name),age(age),Bd(year,month,day)
                {

                }
                void show()
                {
                    cout << this->name << "," << this->age << ",";
                    this->Bd.showData();
                    cout << endl;
                }
            private:
                string name;
                int age;
                Body Bd;
            };

            int main(int argc, char *argv[])
            {
                student stu("zhangsan",21,1998,11,18);
                stu.show();
                return 0;
            }
            
初始化列表执行顺序：
            1、先执行初始化列表，再执行构造函数
          ->2、类中有多个其他类对象作数据成员时，初始化列表执行的顺势是按照成员声明顺序来执行的,与初始化列表书写顺序无关。

析构函数定义和执行：
            ->析构函数：函数名与类名相同，前面有"~",且不能有参数，所以析构函数不能重载，在一个类里只有一个析构函数。
            ->析构函数跟构造函数一样也是自动调用，不过是在销毁对象或作用域结束时自动调用
            ->析构函数执行得顺序与构造函数完全相反，先创建的对象最后析构，后创建的对象最先析构

类内有成员为指针时析构：
            

STL(标准库)的string类：
        C++中的string跟C中字符串的区别；
                C的字符串是 const char *str = "hello";必须以结尾；
                C++中的字符串是typedef basic_string<char> string;
                C++中的string是只能装char的容器，不再是、0作结束；
                
                string str1 = "高弟"；
                cout << sizeof(str1) << endl;//24
                cout << str1.size() << endl; //字节数
                cout << str1.length() << endl; //字符个数
                cout << str1.capacity() << endl; //容量
                cout << str1.max_size() << endl; //最大容量

                str1.append("好嗨哟");        //追加
                str1.resever();
                str1.resize();'
                
                C语音字符串转C++字符串-> string data = "hello";
                C++ 字符串转C语言字符串->const char * = data.c_str/data.data;

string的增删改查：
        访问：
            1、通过下标访问
            for(int i = 0;i<str.size();i++)
            {
                cout << str1[i] << endl;            //这种方法不会查找是否越界
                cout << str1.at(i) << endl;            //这种方法会查找是否越界（推荐使用）
            }
            
            2、迭代子访问：
            //string::iterator it;                   //迭代子的本质是指针
            for(string::iterator it = str.begin();it != str.end();it++)
            {
                cout << *it << endl;
            }
            
            可以通过一般迭代子去修改字符值
            it = str.begin();
            *it = "H";
            cout << str1 << endl;

            3、常迭代子：const_iterator
            for(string::const_iterator it = str.cbegin();it != str.cend();it++)
            {
                cout << *it << endl;
            }
            不能用常迭代子改变值
            
            4、反向迭代子：reverse_iterator
            for(string::reverse_iterator it = str.rbegin();it != str.rend();it++)
            {
                cout << *it << endl;
            }
    /**************************************************************************************************************************************/
  ->增：
            string src = "hello abc world abc linux abc";
            string str1 = "hello";
            string str2 = "world";
          ->/*append    只能往string类的末尾添加字符串*/
            //str1.append("abc");                        //往str1后面增加字符串abc
            //str1.append(str2.begin()+2,str2.end());    //将str2从中的“rld”增加到str1后面
            //str1.append(5,'6');                        //在Str1后面增加5个字符6
            //str1.append("hello world",1,4);            //将字符串从下标1到下标5加到str1后面
            
          ->/*insert    可以往string类的任意位置添加*/
            //str1.insert(str1.begin() + 1,'H');        //往str1的下标1处插入字符H
            //str1.insert(1,3,'H');                        //往str1的下标1处插入三个字符H
            //str1.insert(1,"hello linux");                //往str1的下标1处插入字符串“hello linux”
            //str1.insert(0," hello world ",5);            //往str1的下标0处插入字符串的前五个字符“hello”
            //str1.insert(0,"hello world",0,5);            //往str1的下标0处插入字符串“hello world”第0个下标到第5个下标的字符，既“hello”
    /**************************************************************************************************************************************/
  ->删：
    erse
    clear  ->可用empty来判断是否为空
    pop
    /**************************************************************************************************************************************/
  ->改：(用'='可以直接全部改0变)
    assign
    replace
      /**************************************************************************************************************************************/
  ->查：
    ->find(从左往右查)返回的是查找到的字符的下标，没找到返回-1
            string src = "hello abc world abc linux abc";
            string str1 = "hello";
            string str2 = "world";
    ->rfind(从右往左查)返回的是查找到的下标，没找到报错
    
    ->find_first_of(从左往右)查找子串中任意一个字符出现的位置
    
    ->find_first_not_of(从左往右)查找不是子串中任意一个字符出现的位置
     
     find_last_of
     
     find_last_not_of
      /****************************** ********************************************************************************************************/
  ->截取:
        substr
            
            
只有把已初始化对象赋值给为初始化对象的时候才会调用拷贝构造函数
把实参对象转换成形参对象时会

                                                                                                                         
无名对象：
        创建对象时没有对象名，用完后就销毁，更节省内存，而用一般对象则会一直知道主函数结束才会销毁，占用内存比较高。

临时对象：
        由函数返回的对象，如果有对象去接收这个对象，那么它的作用域将会得到延申

友元类：
        在一个类中用friend声明的函数（友元函数）
        1、把一个类的成员函数作为另一个类的友元函数
        2、把一个普通函数声明为类的友元
        3、声明为友元类后，则这个类的所有函数都能直接访问另一个类的所有数据。

        友元是为了突破类的数据访问限制（private、protected）
        
        友元会破坏类的封装性，所以尽量不要用友元突破私有限制。

内部类：
        在一个类中声明的类，相对于内部类的外部（外部类）
        内部类的一般函数要用两层类域才能在外部类外面实现

内部类的访问特性：
        内部类可以直接访问外部类的所有静态数据，但是外部类不能直接访问内部类的成员。内部类相当于外部类的一个成员。

局部类：定义在函数中的类    常用在接口设置
        作用范围只能在这个函数
        void Test（）
        {
            class Locale        //这个类的作用域仅在这个函数里
            {
                public:
                    .
                    .
                    .
                private:
                    int data;
                    //static int staticdata    //error  局部类中不能定义静态数据成员，因为一般函数需要对象调用
            
            };
            //函数调用
            locale l(10);
            l.show();
        }


/**********************************************************************************************************************************************/
                                                                      继承
/**********************************************************************************************************************************************/
用“:”来继承
格式：子类 ： 权限 父类名

继承以后：
        ->创建子类对象的时候，需要先生父类对象再生子类对象（辈分高的最先创建），可以在初始化列表中指定使用父类哪个构造函数构造父类对象    格式：子类构造函数名 + ； +父类构造函数名
        ->析构的时候，先析构子类再析构父类
        ->子类继承父类的数据成员、成员函数（代码重用，体系（创建子类时只需要注意子类比父类多的属性、动作））
        ->父类私有数据成员，私有成员函数既不能被调用也不能被继承，构造函数、析构函数、拷贝构造函数、运算符重载不能被继承但是可以被子类调用

继承权限：
        public:继承过来后，原来是public的还是public,protected的还是protected(父类的访问权限在子类中保持不变)
        private:继承过来后，继承过来的公共/保护父类成员函数，公共/保护数据成员权限全部变成private
        protected:继承过来后，继承过来的公共父类成员函数，公共数据成员权限变成protected，保护的成员权限不变，私有的还是私有
        默认： private

多继承：
        格式：子类 ： 权限 父类1 ， 权限 父类2...
        多继承时的构造和析构顺序：
                        构造的时候，按照继承顺序构造父类，再按声明顺序构造子类中其他类对象或数据成员，再构造子类对象。析构的顺序与构造顺序相反。

                    #include <iostream>
                    #include <string>

                    using namespace std;

                    class A
                    {
                    public:
                        int public_data;
                    private:
                        int private_data;
                    protected:
                        int protected_data;

                    public:
                        A()
                        {
                            cout << "A()" << endl;
                            this->public_data = 0;
                            this->private_data = 0;
                            this->protected_data = 0;
                        }
                        A(int i,int j,int k)
                        {
                            cout << "A(int i,int j,int k)" << endl;
                            this->public_data = i;
                            this->private_data = j;
                            this->protected_data = k;
                        }
                        ~A()
                        {
                            cout << "~A()" << endl;
                        }
                        void showA()
                        {
                            cout << this->public_data << "," << this->private_data << "," << this->protected_data << endl;
                        }
                    };
                    
                    class B: public A
                    {
                    private:
                        string name;
                    public:
                        B()
                        {
                            cout << "B()" << endl;
                        }
                        B(string name,int i,int j,int k):A(i,j,k)
                        {
                            cout << "B(string name ,int i,int j, int k)" << endl;
                            this->name =  name;
                        }
                        ~B()
                        {
                            cout << "~B()" << endl;
                        }
                        void showB()
                        {
                            cout << this->name << endl;
                        }
                    };

                    class  C: public B
                    {
                    public:
                        C()
                        {
                            cout << "C()" << endl;
                        }
                        ~C()
                        {
                            cout << "~C()" << endl;
                        }
                        void showC()
                        {
                            cout << "showC()" << endl;
                            cout << this->public_data << endl;
                            cout << this->protected_data << endl;
                        }
                    };

                    int main(int argc, char *argv[])
                    {
                        B b("zhangsan",1,2,3);
                        b.public_data = 3;
                        b.showA();
                        C().showC();
                        cout << "main over" << endl;
                        return 0;
                    }


静态联编（早期联编）：根据指针或引用的类型来判断调用哪个类的函数，而不是根据对象类型来决定调用哪个类的
            （子类指针不能指向父类对象，子类引用不能引用父类对象）
动态联编（晚期联编）：在运行时确定函数的调用，根据指针或引用实际指向的对象来决定调用哪个类的函数
        要实现动态连编：
                    1、在父类的同名成员函数前面加virtual(虚函数)，子类可加可不加
                    2、父类的同名函数加了virtual，不一定是动态联编

virtual的本质：加了virtual后在本类中会增加一个指针，这个指针指向了底层的虚函数表，虚函数表里放的就是子类的同名函数。
               把父类指针或引用作参数，子类的指针或引用都能都当参数传递进去


动态联编从另外一种角度来讲，其实就相当于重写
重写：
            在父子类，子类的函数名与父类的函数名相同，参数列表相同，父类的同名函数必须有vritual
            重写一定是动态联编，由引用和指针指向的对象来决定调用哪个类的函数
            
多态（重写）（重载）：
            调用同名函数时，由于参数不同或由于所调用的对象不同造成调用结果不同
            同名函数参数不同，就是重载
            同名同参数，但调用对象不同，就是重写

重载和重写的区别：
            重载是在同一个类，而重写是在不同的类
            重载要求函数名相同，但参数不同，而重写两者都要相同
            virtual要求不同
            重载是静态联编，重写是动态联编
            
重写容易发生的错误：
            1、父类函数缺少virtual关键字，只能发送静态联编
            2、参数不同，此时不管父类有没有vritual关键字，都会屏蔽子类的同名函数，发生静态联编

父/子类的构造/析构函数问题：
          ->父类的默认构造函数不能省，否则子类对象会无法创建
          ->使用父类指针指向子类对象，并通过父类指针去删除子类对象时，无法调用子类的析构函数，需要将
            父类的析构函数定义成虚析构（虚析构是能够被子类继承的）

抽象类：有纯虚函数的类就是抽象类；
        抽象类不能创建对象，只能声明指针或引用
        抽象类能做框架，接口
        抽象类的对象必须由它的子类去实现，子类要创建抽象类的对象，必须将父类中的纯虚函数全部实现
        
纯虚函数：在虚函数的形参列表右边写上=0   例：vritual void fun() = 0;
                            
纯虚析构函数：（必须在抽象类内部声明，在类外实现）
        格式： virtual ~类名（） = 0；
            实现：类域::类名（）{}；

一般纯虚函数可以在抽象类中实现，也可以不实现。


多继承问题：
        1、菱形继承时会出现二义性，需要利用虚继承来解决二义性
        
                class A
                {
                private:
                    string name;
                public:
                    void show()
                    {
                        cout << "A" << endl;
                    }
                };

                class B : virtual public A
                {

                };

                class C : virtual public A
                {

                };

                class D : public B,public C
                {

                };

                int main(int argc, char *argv[])
                {
                    D d;
                    d.show();

                    cout << "Hello World!" << endl;
                    return 0;
                }

2、V形继承  ： 使用类域指定使用哪个类的成员；


操作符重载：
1、类内重载：把操作符重载为函数，当使用这个我操作符时会调用这个函数
            格式：返回类型 operator 重载的操作符（形参列表）、
            参数个数由操作符的操作数决定，单目运算符一般不需要参数a++,操作this
                                          双目运算符 例：a + b ;则需要1个参数，this是左操作数
2、类外重载：
            类外重载需要把操作符的所有操作数都卸载参数列表里。

操作符重载时要注意的问题：
            1、重载不能改变操作符的本义
            2、不要改变操作符的返回值
            3、下面的操作符不能重载： :: .  ->*  .*   ?:  标准类型转换(static_cast ,const_cast,reinterpret_cast,dynamic_cast),sizeof
            4、=操作符必须在类内重载不能在类外重载

输入输出流的重载（iostream）：

            typedef struct student
            {
                string name;
                int age;
            }stu_t;
                
            ostream & operator <<(ostream &out,const stu_t &val)  //重载一个stu_t类型的输出流
            {
                out<<val.name<<" "<<val.age<<endl;
                return out;
            }

            istream & operator >> (istream &in,stu_t &val)        //重载一个stu_t类型的输入流
            {
                cout<<"input name:";
                in>>val.name;
                cout<<"input age:";
                in>>val.age;
                return in;
            }


指向类内成员指针：数据成员、成员函数

.*
->*
                class Student
                {
                public:
                    string name;
                    int age;
                public:
                    Student()
                    {

                    }
                    Student(string name ,int age)
                    {
                        this->name = name;
                        this->age = age;
                    }
                    ~Student()
                    {

                    }
                    void show()
                    {
                        cout << "show()" << endl;
                        cout << this->name << "," << this->age << endl;
                    }
                };

                int main(int argc, char *argv[])
                {
                #if 0
                    int Student::*p;                            //创建一个指向数据成员的指针
                    Student stu("zhangsan",20);
                    p = &Student::age;                            //将数据成员地址传递给指针，但应注意这里需要使用类域
                    cout << stu.*p << endl;                        //创建的对象stu为普通对象，所以调用的时候用.*

                    Student *pfun = new Student("lisi",21);        //这里创建的对象为指针，因此去调用之创建的指向数据成员的指针时需要用->*
                    cout << pfun->*p << endl;
                    delete pfun;
                #endif

                #if 1
                    void (Student::*pfun)();                    //创建一个指向成员函数的指针
                    pfun = Student::show;                        //将show函数的地址传递给pfun
                    Student stu1("zhaosi",50);                    //创建一般对象
                    (stu1.*pfun)();                                //一般对象使用.*调用之前创建的pfun指针

                    Student *stu2 = new Student("lisi",30);        这里创建的对象为指针，因此去调用之创建的指向成员函数的指针时需要用->*
                    (stu2->*pfun)();
                    delete stu2;
                #endif
                    return 0;


因为重载或重写时，虽然降低了调用者的工作量，但并没有降低编写者的工作量，所以有；1模板                                                                                                                                                                            

模板的本质：将类型做参数    把类型做形参传递，实际的参数类型在调用的时候才确定

模板函数：只适用于函数体相同，参数个数相同，类型不同的情况
模板类：

模板函数例子：
        template <typename T>                    //定义了一个模板类型名，也可以用template <class T>来定义
        void add(T a,T b)                        //实现的模板函数
        {
            cout << "add()" << endl;
            cout << a + b << endl;
        }

        int main()
        {
            float f1 = 1.6f,f2 = 1.7f;
            add(f1,f2);                            //如果参数列表里的类型不一样，需要在调用前先声明参数类型
            add<int>(10, 10);                    //如果参数列表里的类型都一样，可以用这种方法调用
            return 0;
        }

模板类例子：
        template<typename T1,typename T2>                //声明模板类型
        class Student
        {
        private:
            T1 name;                                    //将数据成员定义成模板类型
            T2 age;
        public:
            Student()
            {

            }
            Student(T1 name ,T2 age);                    //参数需要定义成模板类型
            ~Student()
            {

            }
            void show();
        };

        template<typename T1,typename T2>                //在类外实现时需要将模板类型在函数前声明
        Student<T1,T2>::Student(T1 name ,T2 age)        //实现时需要在类域后面说明一下类型的个数和类型
        {
            this->name = name;
            this->age = age;
        }

        template<typename T1,typename T2>
        void Student<T1,T2>::show()
        {
            cout << "show()" << endl;
            cout << this->name << "," << this->age << endl;
        }

        int main()
        {
            Student<string,int> stu("zhangsan",20);        //在创建对象时调用构造函数，需要在函数名后面说明类型模板里的类型
            stu.show();
            return 0;
        }


模板类是实现容器得技术基础

标准容器库STL:(standard  template  library)容器所存储得类型是未知的
容器：顺序 （线性）容器
关联容器：键值对key-value

vector:
使用push_back()往容器尾部添加元素
可以使用下标去遍历容器，也可以使用迭代子去便利容器
//迭代子的本质是指针
    
    特点：底层是数组实现的
          查找效率高
          无序容器
          允许有重复值
          
          
vevtor例子：
        #include <iostream>
        #include <vector>    //导入头文件

        using namespoace std;

        template<typename T1,typename T2>                //声明模板类型
                class Student
                {
                ...
                };
                ...
                
        int main（）
        {
           vector<string>  V;                            //定义一个string类型的容器V
           V.push_back("zhangsan");                        //往容器类放入数据
           V.push_back("lisi");

           Student<string ,int> stu0("wangwu",20);
           vector<Student<string,int>> stu;
           stu.push_back(stu0);

           for(vector<string>::iterator it = V.begin(); it != V.end(); it++)   //使用迭代子的方式去遍历容器
           {
                cout << *it << endl;
           }
            return 0;
        }




通用算法遍历for_each();

vector查找：find(自动调用==操作符重载比较（类外重载）),
            find_if(_Predicate：一个类中的（）操纵符重载)
            find_end();从右往左找连续子集，_BinaryPredicate
            find_if_not()查找不是
            
            


        一般类型容器可以用==操作符判断两个容器是否相等，而自定义类型容器可以用equal进行比较，但需要重载==操作符。

        使用count和count_if对成员进行数量统计
        
        普通排序sort
        堆排序sort_heap

        去重unique：只能去除连续重复，它属于通用算法，不能改变容器大小
        在去重前需要先排序，再统计容器大小，再去重，再改变容器大小。
        
        使用pop_back删除容器最后一个数据，使用clear清空容器，使用erase删除指定位置的数据
        
        去重的两种方法：
        
                        vector<Student> stu1;
                        stu1.push_back(Student("wangwu",20));
                        stu1.push_back(Student("zhangsan",21));
                        stu1.push_back(Student("lisi",32));
                        stu1.push_back(Student("zhaoliu",89));
                        stu1.push_back(Student("gaodi",18));
                        stu1.push_back(Student("lisi",32));
                        stu1.push_back(Student("lisi",32));
                        
                        #if 0       //去重，不改变原有顺序
                        bool flag = true;
                        vector<Student>::iterator it = stu1.begin();
                        while((it = find_if(it ,stu1.end(),Find_lisi())) != stu1.end())
                        {
                            if(flag)
                            {
                                it++;
                                flag = false;
                            }
                            else
                            {
                                stu1.erase(it);
                            }
                        }
                    #endif

                    #if 1   //使用unique去重，但是会改变原有顺序
                        sort(stu1.begin(),stu1.end(),cmpstr);                           //排序
                        int n = count(stu1.begin(),stu1.end(),Student("lisi",32));      //统计个数
                        unique(stu1.begin(),stu1.end());                                //去重
                        stu1.reserve(stu1.size()-n+1);                                  //改变容器大小
                    #endif
         

双端队列deque：
        
单端队列queue：没有at函数，不能通过下标去遍历 不能用迭代子遍历 不能用通用函数遍历
                只能边删边遍历




set的容器特性：（在存数据的时候会自动排序）
        1、底层实现（二叉树，链表），增删效率低，查询非常高
        2、有序的容器（自动排序）
        3、值不允许有重复
        4、有自己的find()按值查找 erase()按值删除。不需要sort(),unique()
        
        
map：一个数据包含两部分：key value（键值对存在）

默认升序排序
less显式升序排序
greator显式降序排序


map 允许value重复，不允许key重复.     

map数据的操作：查改删，只能通过key去操作value

一次存两个数据key value 以pair存在，key和value一一对应，通过key操作value
有序容器,对key排序
不允许key重复，允许value重复
增效率低，查询效率高


int main()
{
    map<string ,student> stumap;
}




随机
有种随机：每次运行都随机 在运行时确定
          制种  有效范围，在函数内有效
srand(time(NULL));
int num = rand()%10000;


无种随机：随机一次，以后每次运行都一样，在编译时确认
int num = rand()%10000;


随机打乱(洗牌)把容器内的数据随机打乱，只能对无序的容器打乱。
randdom_shuffle();


/**********************************************************************************************************************************************/
                                                                      多态
/**********************************************************************************************************************************************/
重载和重写是构成多态的两种方式





     

17:35:59