C++学习2

前言

C++学习笔记

一、模板

模版就是建立通用的模具，大大提高复用性。

函数模版

• C++另一种编程思想称为泛型编程，主要利用的技术就是模版
• C++提供两种模板机制：函数模板和类模板

函数模版语法

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

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

解释：

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

注意：

1. 自动类型推导，必须推导出一致的数据类型T，才可以使用
2. 模版必须要确定出T的数据类型，才可以使用

普通函数与函数模版的区别

1. 普通函数调用时可以发生自动类型转换（隐式类型转换）
2. 函数模版调用时，如果利用自动类型推导，不会发生隐式类型转换
3. 如果利用显示指定类型的方式，可以发生隐式类型转换
   建议使用显示指定类型的方式，调用函数模版，因为可以自己确定通用类型T

普通函数与函数模版的调用规则

1. 如果函数模版和普通函数都可以实现，优先调用普通函数
2. 可以通过空模版参数列表来强制调用函数模版
3. 函数模版也可以发生重载
4. 如果函数模版可以产生更好的匹配，优先调用函数模版

提供了函数模版就不要提供普通函数了

类模版

template<class NameType, class AgeType=int> // 默认参数
class Person{
    public:
        Person(NameType name, AgeType age){
            this->name = name;
            this->age = age;
        }
        NameType name;
        AgeType age;
};

int main(){
    Person<string, int> p1("zhangsan", 18);
}

函数模版和类模版的区别

• 类模版没有自动类型推导的使用方式
• 类模版在模版参数列表中可以有默认参数

类模版中成员函数创建时机

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

类模版对象做函数参数

• 类模版实例化出的对象，向函数传参的方式
  

template<class T1, class T2>
class Person{
    public:
        Person(T1 name, T2 age){
            this->name = name;
            this->age = age;
        }
        void showPerson(){
            cout << "姓名：" << this->name << "年龄：" << this->age << endl;
        }
        T1 name;
        T2 age;
};
// 1、指定传入类型
void prinPerson1(Person<string, int> &p){
    p.showPerson();
}
void test01(){
    Person<string, int> p("孙悟空", 100);
    prinPerson1(p);
}
// 2、参数模版化
template<class T1, class T2>
void printPerson2(Person<T1, T2> &p){
    p.showPerson();
    cout << "T1的类型为：" << typeid(T1).name() << endl;
} 
void test02(){
    Person<string, int> p("猪八戒", 90);
    printPerson2(p);
}

// 3、整个类模版化
template<class T>
void printPerson3(T &p){
    p.showPerson();
}
void test03(){
    Person<string, int> p("沙僧", 80);
    printPerson3(p);
}
int main(){
    //test01();
    //test02();
    test03();
}

类模版与继承

template<class T>
class Base{
	T m;
};
class Son:public Base<int>{};
// 如果想灵活指定父类中T类型，子类也需要变类模版
template<class T1, class T2>
class Son2:public Base<T2>{
	T1 obj;
};

类模版成员函数类外实现

template<class T1, class T2>
class Person{
    public:
        Person(T1 name, T2 age);
        void showPerson();
        T1 name;
        T2 age;
};
// 构造函数类外实现
template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age){
    this->name = name;
    this->age = age;
}
// 成员函数的类外实现
template<class T1, class T2>
void Person<T1, T2>::showPerson(){
    cout << "姓名：" << this->name << "年龄：" << this->age << endl;
}
void prinPerson1(Person<string, int> &p){
    p.showPerson();
}
void test01(){
    Person<string, int> p("孙悟空", 100);
    prinPerson1(p);
}
int main(){
    test01();
}

类模版分文件编写

类模版与友元

• 全局函数类内实现-直接在类内声明友元即可
• 全局函数类外实现-需要提前让编译器知道全局函数的存在

// 提前让编译器知道Person类存在
template<class T1, class T2>
class Person;

// 类外实现
template<class T1, class T2>
void printPerson1(Person<T1, T2> &p){
    cout << "姓名：" << p.name << "年龄：" << p.age << endl;
}
template<class T1, class T2>
class Person{
    // 全局函数类内实现
    friend void printPerson(Person<T1, T2> &p){
         cout << "姓名：" << p.name << "年龄：" << p.age << endl;
    }
    // 全局函数类外实现
    // 加空模版参数列表
    friend void printPerson1<>(Person<T1, T2> &p);
    public:
        Person(string name, int age){
            this->name = name;
            this->age = age;
        }
    private:
        T1 name;
        T2 age;
};

void test(){
    Person<string, int> p("tom", 19);
    printPerson(p);
}
void test01(){
    Person<string, int> p("tom", 19);
    printPerson1(p);
}
int main(){
    test01();
    return 0;
}

二、STL

STL基本概念

• STL（Standard Template Library，标准模板库）
• STL从广义上分为：容器、算法、迭代器
• 容器和算法之间通过迭代器进行无缝连接
• STL几乎所有的代码都采用了模版类或者模版函数

STL六大组建

算法通过迭代器才能访问容器中的元素

string

在这里插入代码片

void test(){
    string s1; // 默认构造

    const char * str = "hello world"; // c语言风格字符串
    string s2(str);
    cout << "s2 = " << s2 << endl;

    string s3(s2); // 拷贝构造
    cout << "s3 = " << s3 << endl;

    string s4(10, 'a');
     cout << "s4 = " << s4 << endl; // aaaaaaaaa
}
int main(){
    test();
}

#include <iostream>
using namespace std;

void test(){
    string str1;
    str1 = "hello world";
    cout << "str1=" << str1 << endl;

    string str2 = str1;
    cout << "str2=" << str2 << endl;

    string str3;
    str3 = 'a';
    cout << "str3=" << str3 << endl;

    string str4;
    str4.assign("hello world");
    cout << "str4=" << str4 << endl;

    string str5;
    str5.assign(str4, 0, 5);
    cout << "str5=" << str5 << endl;

    string str6;
    str6.assign(str5);
    cout << "str6=" << str6 << endl;

    string str7;
    str7.assign(10, 'w');
    cout << "str7=" << str7 << endl;

}
int main(){
    test();
}

void test(){
    string str1 = "I ";
    str1 += "love you";
    cout << "str1 = " << str1 << endl;

    string str2 = "I ";
    str2.append("love you");
    cout << "str2 = " << str2 << endl;

    string str3 = "I ";
    str3.append("love", 2);
    cout << "str3 = " << str3<< endl; // I lo

}
int main(){
    test();
}

vector

#include <iostream>
using namespace std;
#include <vector>

void print(vector<int> &v){
    for(vector<int>::iterator it=v.begin(); it!=v.end(); it++){
        cout << *it << " ";
    }
    cout << endl;
}
// vector容器构造
void test(){
    vector<int> v1; // 默认构造 无参构造
    for(int i=0; i<10; i++){
        v1.push_back(i);
    }
    print(v1);

    // 通过区间方式进行构造
    vector<int> v2(v1.begin(), v1.end());
    print(v2);

    // n个elem构造
    vector<int> v3(10,100);
    print(v3);

    // 拷贝构造
    vector<int> v4(v3);
    print(v4);

}
int main(){
    test();
}

#include <iostream>
using namespace std;
#include<vector>

void print(vector<int> & v){
    for(vector<int>::iterator it = v.begin(); it!=v.end(); it++){
        cout << * it << " ";
    }
    cout << endl;
}
void test(){
    vector<int> v;
    for(int i=0; i<10000; i++){
        v.push_back(i);
    }
    v.resize(3);
    cout << v.size() << endl; // 3
    cout << v.capacity() << endl; // 16384
    /*
        vector<int>(v)  匿名函数+拷贝函数
    */
    vector<int>(v).swap(v); // 容器交换
    cout << v.size() << endl; // 3
    cout << v.capacity() << endl; // 3
}
int main(){
    test();
}

deque

stack

list（双向循环链表）

set/multiset

map/multimap