C++ 提高编程

作者: c枫_撸码的日子 | 来源:发表于2021-01-06 16:50 被阅读0次

0.前言

最近在做算法移植的时候，发现自己对c++的知识忘得很多，于是就计划重新捡起来。
纸上得来终觉浅，绝知此事要躬行
一直都是我学习和工作的原则，我比较喜欢动手。
于是我把c++的基础知识一行行代码敲了一遍。

1.模板

1.1 模板的概念

模板就是建立通用的摸具，提高复用性。

模板的特点：

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

1.2 函数模板

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

1.2.1 函数模板的语法

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

语法：

template<typename T>
函数声明或者定义
**解释：**
* template ---声明创建模板
* typename --- 表面一种数据类型，可以用class代替
* T --- 通用的数据类型，名字可以随便取，通常为大写字母
template <typename T> //或者template <class T>
void mySwap(T &a,T &b)
{
    T temp;
    temp = a;
    a = b;
    b = temp;
}
int main(int argc, char** argv) {
    int a = 10;
    int b = 20;
    //2种方式使用函数模板 
    //1.自动推导类型 
    mySwap(a,b);
    //2.显示指定类型
    mySwap<int>(a,b);
    cout<<"a="<<a<<" b="<<b<<endl; 
    return 0;
}

2种方式使用函数模板

1.自动推导类型
mySwap(a,b);
2.显示指定类型
mySwap<int>(a,b);

1.2.2 函数模板的注意事项

注意事项：

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

template <typename T>//或者template <class T>
void mySwap(T &a,T &b)
{
    //省略    
} 
void test1()
{
    int a = 10;
    char b = 'c';
    //mySwap(a,b);报错，a和b类型不一致
}

模板必须要确定出T的数据类型，才可以使用

template <class Z>
void func()//函数模板 
{
    
}

void test2()
{
    //func();//报错，没指定类型 
    func<int>();//正确 
}

1.2.3 普通函数和函数模板的区别

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

//普通函数
int add(int a,int b)
{
    cout<<a+b<<endl;
    return a+b;
} 
//函数模板 
template <class T>
T myAdd(T a,T b)
{
    cout<<a+b<<endl;
    return a+b;
}

int main(int argc, char** argv) {
    int a=10;
    char b ='a';
    add(a,b);
    //myAdd(a,b);//报错 
    myAdd<int>(a,b);
    return 0;
}

1.2.4 普通函数和函数模板的调用规则

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

//普通函数
void myPrint(int a,int b)
{
    cout<<"普通函数 调用"<<endl;
} 

//函数模板
template <class T>
void myPrint(T a,T b)
{
    cout<<"函数模板 调用"<<endl;
} 
//函数模板重载 
template <class T>
void myPrint(T a,T b,T c)
{
    cout<<"函数模板 重载调用"<<endl;
} 
int main(int argc, char** argv) {
    myPrint(10,20);//调用普通函数
    myPrint<>(10,20);//强制调用模板函数 
    myPrint(10,20,30);//调用重载的函数模板 
    myPrint('a','b');//函数模板更匹配 
    return 0;
}

1.2.5 模板的局限性

局限性：
模板通用性不是万能的

class Person
{
public:
    Person(string n,int a):name(n),age(a){}
    string name;
    int age;    
} ;

template<class T>
bool myCompare(T &a,T &b)
{
    if(a == b)//无法比较Person类 
        return true;
    return false;
}
//利用具体化Person的版本实现代码，具体化优先调用 
template<> bool myCompare(Person &a,Person &b)
{
    if(a.age == b.age && a.name == b.name)
        return true;
     
     return false;
}

void test1()
{
    Person p1("Tom",10);
    Person p2("Tom",10);
    myCompare(p1,p2);
}

利用具体化的模板，可以解决自定义类型的通用化
学习模板并不是为了写模板，而是在STL能够运用系统提供的模板

1.3 类模板

1.3.1 类模板语法

类模板的作用：

建立一个通用类，类中的成员数据类型可以不具体指定，用一个虚拟的类型来代表

语法：

template <typename T>
类

template <typename T,typename P>
class Person
{
public:
    Person(T n,P a):name(n),age(a){}
    T name;
    P age;  
};
int main() {
    Person<string,int> p1("Tom",10);
    cout<<p1.name<<" "<<p1.age<<endl;
    return 0;
}

1.3.2 类模板与函数模板的区别

1.类模板没有自动类型推导的使用方式，必须显示指定类型
2.类模板在模板参数列表中可以有默认参数

template <typename T,typename P = int>//默认整型 
class Person
{
public:
    Person(T n,P a):name(n),age(a){}
    T name;
    P age; 
};
int main(int argc, char** argv) {
    Person<string,int> p1("tom",10);
    Person<string> p2("tom",10);//<>里面的int可以省略 
    return 0;
}

1.3.3 类模板中成员函数的创建时机

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

1.3.4 类模板对象做函数参数

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

template <class T,class P> 
class Person
{
public:
    Person(T n,P a):m_age(a),m_name(n){}
    void showPerson()
    {
        cout<<this->m_name<<" "<<this->m_age<<endl;
    }
    
    T m_name;   
    P m_age;
};
//1.指定传入的类型
void printPerson1(Person<string,int> &p)
{
    p.showPerson();
}
void test1() 
{
    Person<string,int> p1("tom",10);
    printPerson1(p1);
}

//2.参数模板化 
template<class T ,class P>
void printPerson2(Person<T,P> &p)
{
    p.showPerson();
}
void test2() 
{
    Person<string,int> p1("tom2",10);
    printPerson2(p1);
}

//3.整个类模板化 
template<class T>
void printPerson3(T &p)
{
    p.showPerson();
}
void test3() 
{
    Person<string,int> p1("tom3",10);
    printPerson3(p1);
}

1.3.5 类模板与继承

当子继承的父类时一个类模板时，子类在声明的时候，要指定父类中T的类型
如果不指定，编译器无法为子类分配内存
如果想灵活指定父类中T的类型，子类也需要变成类模板

template <class T>
class Base
{
public:
    T a;    
};

class Son : public Base<int>//指定类型 
{
    
};

template<class T1,class T2>
 class Son2 : public Base<T2>//灵活指定类型 
 {
    T1 obj;
 };

1.3.6 类模板成员函数类外实现

类模板中的成员函数类外实现时，需要加上模板参数列表

template <class T1,class T2>
class Person
{
public:
    Person(T1 n,T2 a);
    void show();
    T1 m_name;
    T2 m_age;
};

template <class T1,class T2>
Person<T1,T2>::Person(T1,T2)
{
    
}

template <class T1,class T2>
void Person<T1,T2>::show()
{
    
}

1.3.7 类模板分文件编写

问题：

类模板成员函数创建时机是在调用阶段，导致分文件编写时链接不到
解决：
解决方式1：直接包含cpp文件
解决方式2：将声明和实现写到同一个文件红，然后改后缀名为hpp,hpp是约定的名称，非强制！
Person.h

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

template <class T1,class T2>
class Person
{
public:
    Person();
    Person(T1 name,T2 age);
    ~Person();
    void showPerson();
    
    T1 name;
    T2 age;
};

Person.cpp

#include "Person.h"


template <class T1,class T2>
Person<T1,T2>::Person(T1 name,T2 age)
{
    this->name = name;
    this->age = age;
}

template <class T1,class T2>
Person<T1,T2>::~Person()
{
}

template <class T1,class T2>
void Person<T1,T2>::showPerson()
{
    cout<<name<<" "<<age<<endl;
}

main.cpp

解决方式1：直接包含cpp文件很少这么做

//#include "Person.h" //类模板的成员函数编译时不会创建，因此会找不到引用
#include "Person.cpp" //* 解决方式1：直接包含cpp文件
void test()
{
    Person<string,int> p("tom1",18);
    p.showPerson();
} 
int main() {
    test(); 
    return 0;
}

解决方式2：将.h和.cpp中的内容写到一起，将后缀名改为hpp，非强制！
Person.hpp

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

template <class T1,class T2>
class Person
{
public:
    Person();
    Person(T1 name,T2 age);
    ~Person();
    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>
Person<T1,T2>::~Person()
{
}

template <class T1,class T2>
void Person<T1,T2>::showPerson()
{
    cout<<name<<" "<<age<<endl;
}

main.cpp

#include "Person.hpp" //* 解决方式2：直接包含hpp文件
void test()
{
    Person<string,int> p("tom1",18);
    p.showPerson();
} 
int main() {
    test(); 
    return 0;
}

1.3.8 类模板和友元

全局函数在类内实现：直接在类内声明友元，实现函数即可
全局函数在类外实现：需要提前让编译器知道全局函数的存在(比较麻烦的写法)

template <class T1,class T2>
class Person;
          
//提前让编译器知道全局函数
template<class T1,class T2>
void printPerson2(Person<T1,T2> p)
{
    cout<<p.name<<" "<<p.age<<endl;
}

template <class T1,class T2>
class Person
{
    //1. 全局函数 类内实现 
    friend void printPerson(Person<T1,T2> p)
    {
        cout<<p.name<<" "<<p.age<<endl;
    }
    //2.全局函数 类外实现
    //加空模板参数列表<> 
    friend void printPerson2<>(Person<T1,T2>p);//不加<>就是普通函数，加了<> 就是函数模板 
public:
    Person(T1 n,T2 a):name(n),age(a)
    {
        
    }
private:
    T1 name;
    T2 age;
};
void test1()
{
    Person<string,int> p("Tom",18);
    printPerson(p);
}

void test2()
{
    Person<string,int> p("Tom2",18);
    printPerson2(p);
}

1.3.9 类模板案例

MyArray .hpp

#pragma once
#include <iostream>
using namespace std;

template <class T>
class MyArray {
    public:
        //有参构造 参数 容量
        MyArray(int capacity) {
            cout<<"MyArray(int capacity) is call" <<endl;
            this->pAddress = new T[capacity];
            this->m_Capacity = capacity;
            this->m_Size = 0;
        }
        //拷贝构造-防止浅拷贝
        MyArray(MyArray &arr) {
            cout<<"MyArray(MyArray &arr) is call" <<endl;
            this->m_Capacity = arr.m_Capacity;
            this->m_Size = arr.m_Size;
            //this->pAddress = arr.pAddress;//编译器默认实现
            this->pAddress = new T[arr.m_Capacity]; //深拷贝
            //将arr的数据拷贝过来
            for (int i = 0; i < arr.m_Size; i++) {
                this->pAddress[i] = arr.pAddress[i];
            }
        }

        //重载= 防止浅拷贝问题
        MyArray& operator=(const MyArray &arr) {
            cout<<"MyArray& operator=(const MyArray &arr) is call" <<endl;
            //先判断原来堆区是否有数据，如果有先释放
            if (this->pAddress != NULL) {
                delete[] this->pAddress;
                this->pAddress = NULL;
                this->m_Size = 0;
                this->m_Capacity = 0;
            }
            //深拷贝
            this->m_Capacity = arr.m_Capacity;
            this->m_Size = arr.m_Size;
            this->pAddress = new T[arr.m_Capacity];
            //将arr的数据拷贝过来
            for (int i = 0; i < arr.m_Size; i++) {
                this->pAddress[i] = arr.pAddress[i];
            }
        }
        //析构函数
        ~MyArray() {
            cout<<"~MyArray() is call" <<endl;
            if (this->pAddress != NULL) {
                delete[] this->pAddress;
                this->pAddress = NULL;
            }
        }
    private:
        T * pAddress;//指针指向堆区开辟的真实数组
        int m_Capacity;//数组容量
        int m_Size;//数组大小
};

void test1()
{
    MyArray<int> arr1(5);
    MyArray<int> arr2(arr1);
    MyArray<int> arr3(100);
    arr3 = arr1;
}

2.STL

2.1 STL的诞生

长久以来，软件界一直希望建立一种可重复利用的东西
C++的面向对象和泛型编程思想，目的就是为了提升复用性
大多数情况下，数据结构和算法都没有一套标准的代码，因此STL就诞生了

2.2 SLT的基本概念

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

2.3 SLT六大组件

分别是：容器、算法、迭代器、仿函数、适配器、空间配置器

1.容器：各种数据结构，如vector、list、deque、set、map等
2.算法：各种常用的算法：如sort、find、copy、for_each等
3.迭代器：容器和算法沟通的桥梁
4.仿函数：行为类似函数。可作为算法的某种策略
5.适配器：用来修饰容器或者仿函数或者迭代器接口的东西
6.空间配置器：负责空间的配置与管理

2.4 STL中容器、算法、迭代器
1.容器：各种数据结构，如vector、list、deque、set、map等
2.算法：各种常用的算法：如sort、find、copy、for_each等
3.迭代器：容器和算法沟通的桥梁

迭代器的种类：

种类	功能	支持运算
输入迭代器	只读	只读，支持++、==、！=
输出迭代器	只写	只写，支持++
前向迭代器	读写，并能向前推进	读写，支持++、==、！=
双向迭代器	读写，并能向前和向后操作	读写写，支持++、--
随机访问迭代器	读写，能任意访问	读写，支持++ 、--、[n]、-n、<、<=、>、>=

2.5 容器算法迭代器

2.5.1 vector存放内置数据类型

容器：vector
算法：for_each
迭代器：vector<int>::iterator

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std; 
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
void myPrint(int val)
{
    cout<<val<<endl;
} 
void test()
{
    //1.创建一个容器 
    vector<int> v;
    //2.插入数据
    v.push_back(10);
    v.push_back(20);
    v.push_back(30); 
    //通过迭代器访问
    vector<int>::iterator itBegin = v.begin();//起始迭代器，指向容器第一个元素
    vector<int>::iterator itEnd = v.end();//结束迭代器，指向容器最后一个元素的下一个位置 
    //第一种遍历方式
    while(itBegin != itEnd)
    {
        cout<<*itBegin++<<endl;
    } 
    //第二种遍历方式
    for(vector<int>::iterator it = v.begin();it!=v.end();it++)
    {
        cout<<*it<<endl; 
    }
    //第三种遍历方式，STL提供的标准遍历
    for_each(v.begin(),v.end(),myPrint);
    
}

int main(int argc, char** argv) {
    test();
    return 0;
}

2.5.2 vector存放自定义数据类型

class Person
{
public:
    Person(string n,int a):name(n),age(a){}
    string name;
    int age;    
};

void myPrint(Person p)
{
    cout<<p.name<<" "<<p.age<<endl;
}

void myPrint2(Person *p)
{
    cout<<p->name<<" "<<p->age<<endl;
}
//存放自定义数据类型 
void test1()
{
    vector<Person> v;
    Person p1("a",10);
    Person p2("b",20);
    Person p3("c",30);
    Person p4("d",40);
    v.push_back(p1);
    v.push_back(p2);
    v.push_back(p3);
    v.push_back(p4);
    //方式1 遍历 
    for(vector<Person>::iterator it = v.begin();it!=v.end();it++)
    {
        cout<<(*it).name<<" "<<(*it).age<<endl;
        cout<<it->name<<" "<<it->age<<endl;     
    } 
    //方式2 遍历
    for_each(v.begin(),v.end(),myPrint); 
}
//存放 自定义数据类型 指针
void test2()
{
    vector<Person*> v;
    Person p1("a",10);
    Person p2("b",20);
    Person p3("c",30);
    Person p4("d",40);
    v.push_back(&p1);
    v.push_back(&p2);
    v.push_back(&p3);
    v.push_back(&p4);
    //方式1 遍历 
    for(vector<Person*>::iterator it = v.begin();it!=v.end();it++)
    {
        cout<<(*it)->name<<" "<<(*it)->age<<endl;
    } 
    //方式2 遍历
    for_each(v.begin(),v.end(),myPrint2); 
}

2.5.3 vector嵌套容器

//容器嵌套容器
 void test()
 {
    //1.创建大容器
     vector<vector<int>> v;
    //2.创建小容器
    vector<int> v1; 
    vector<int> v2; 

    //小容器赋值
    for(int i=0;i<2;i++)
    {
        v1.push_back(i+1);
        v1.push_back(i+1);
        v1.push_back(i+1);
        
        v2.push_back(i+2);
        v2.push_back(i+2);
        v2.push_back(i+2);
    } 
    //大容器赋值
    v.push_back(v1);
    v.push_back(v2);
    //遍历数据
    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(int argc, char** argv) {
    test();
    return 0;
}

3.1 string容器

3.1.1 string基本概念

本质：

string是c++的字符串，本质上是一个类

string和char*的区别

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

特点：
string类内封装了很多成员方法，如find，copy，delete等。
string管理char*所分配的内存，不用担心复制越界和取值越界问题，都类内部进行负责

3.1.2 string构造函数

string():创建一个空的字符串，例如string s；
string(const char *s):使用字符串s初始化
sting(const string& str):使用string对象初始化
string(int n,char c):使用n个字符c初始化

省略string的一些内容···

3.2 vector容器

3.2.1 vector基本概念

vector数据结构和数组非常相似，也称为单端数组
vector可以动态扩展空间，数组是空间是不可变的
vector容器的迭代器支持随机访问

动态扩展：

并不是原空间之后申请新的空间，而是找到更大的内存空间，然后将原有数据拷贝到新空间，释放原空间。

3.2.2 vector构造函数

函数原型：

vector<T> v:默认构造
vector(v.begin(),v.end()):将v.begin()到v.end()中的元素拷贝给自己
vector(n,elem):把n个elem拷贝给自己
vector(const vector &vec):拷贝构造函数

3.3 deque容器

3.4 stack容器-栈

3.5 queue-队列

3.6 list容器-双向循环链表

3.7 set/multiset容器-二叉树

3.8 map/multimap容器

4.STL-函数对象

4.1 函数对象

4.1.1函数对象的概念

概念

重载函数调用操作符的类，其对象常常称为函数对象
函数对象使用重载的()时，行为类似函数调用，也成为仿函数

本质：
函数对象(仿函数)是一个类，不是函数

4.1.2 函数对象的使用

特点：

函数对象在使用时，可以像普通函数那样调用，可以有参数和返回值
函数对象可以有自己的状态
函数对象可以作为参数传递

class MyAdd
{
public:
    int operator()(int a,int b)
    {
        return a+b;
    }   
} ;
//1. 函数对象在使用时，可以像普通函数那样调用，可以有参数和返回值
void test1()
{
    MyAdd add;
    cout<<add(1,2)<<endl;
}

//2. 函数对象可以有自己的状态
class MyPrint
{
public:
    MyPrint():count(0){}
    void operator()(string s)
    {
        count++;
        cout<<"第"<<count<<"次打印："<<s<<endl;
    }
    
    int count;//内部自己的状态，记录调用次数 
};

void test2()
{
    MyPrint mp;
    mp("hello");
    mp("hello");
    mp("hello");
    mp("hello");
}

//3. 函数对象可以作为参数传递
void doPrint(MyPrint &mp,string s)
{
    mp(s);
}
void test3()
{
    MyPrint mp;
    doPrint(mp,"22222");
}

4.2 谓词

4.2.1 谓词的概念

概念：

返回bool的类型的仿函数称为谓词
如果operator()接受1个参数，称为一元谓词
如果operator()接受2个参数，称为二元谓词

4.2.2 一元谓词

//1.一元谓词
class GreterFive {
    public:
        bool operator()(int v) {
            return v > 5;
        }
};
void test1() {
    vector<int> v;
    for (int i = 0; i < 10; i++)
        v.push_back(i);
    //查找大于5的值，这里 new GreterFive()是一个匿名对象
    vector<int>::iterator it = find_if(v.begin(), v.end(), GreterFive());
    if (it == v.end()) {
        cout << "没有找到大于5的值" << endl;
    } else {
        cout<<"找到大于5的值:"<<*it<<endl;
    }
}

4.2.3 二元谓词

//二元谓词
class Mycompare
{
public:
    bool operator()(int v1,int v2)
    {
        return v1>v2;
    }   
};
void test()
{
    vector<int> v;
    v.push_back(10);
    v.push_back(30);
    v.push_back(20);
    v.push_back(50);
    Mycompare m;
    sort(v.begin(),v.end(),m);
    //sort(v.begin(),v.end(),Mycompare());// Mycompare()是匿名对象 
    for(vector<int>::iterator it = v.begin();it!=v.end();it++)
    {
        cout<<*it<<" ";
    }
    cout<<endl;
}

4.3 内建函数对象

4.3.1 概念

概念：

STL内建了一些函数对象
分类：
算术仿函数
关系仿函数
逻辑仿函数
用法：
这些仿函数所产生的对象，用法和一般函数完全相同
使用内建函数对象，需要引入头文件<functional>

4.3.2 算术仿函数

功能描述：

实现四则运算
其中negate是一元运算，其他都是二元运算

仿函数原型

template<class T> plus<T> //加法仿函数
template<class T> minus<T>//减法仿函数
template<class T> multiplies<T>//乘法仿函数
template<class T> divides<T>//除法仿函数
template<class T> modulus<T> //取模仿函数
template<class T> negate<T>//取反仿函数

//1.取反仿函数 
void test1()
{
    negate<int> n;
    std::cout<<n(50)<<endl; 
}
//2.加法仿函数 
void test2()
{
    plus<int> p;
    std::cout<<p(50,50)<<endl; 
} 
int main(int argc, char** argv) {
    test1();
    test2();
    return 0;
}

4.3.3 关系仿函数

仿函数原型：

template<class T >bool equal_to<T> //等于
template<class T >bool not_equal_to<T> //不等于
template<class T >bool greater<T> //大于
template<class T >bool greater_equal<T> //大于等于
template<class T >bool less <T> // 小于
template<class T >bool less_equal<T> //小于等于

#include <iostream>
#include <vector>
#include<algorithm>
#include <functional>
using namespace std; 
void test()
{
    vector<int> v;
    v.push_back(10);
    v.push_back(30);
    v.push_back(40);
    v.push_back(20);

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

4.3.4 逻辑仿函数

函数原型：

template <class T> bool logical_and<T> //逻辑与
template <class T> bool logical_or<T> //逻辑或
template <class T> bool logical_not<T> //逻辑非

5.STL-常用算法

概述：

算法主要由头文件 <algorithm>、<functional>、<numeric>组成

5.1 常用遍历算法

for_each //遍历容器
transform //搬运容器到另一个容器中

5.1.1 for_each

函数原型：

for_each(iterator beg,iterator end,_func);

//普通函数
void myPrint(int v)
{
    cout<<v<<" ";
}
//仿函数
class MyPrint2
{
public:
    void operator()(int v)
    {
        cout<<v<<" ";
    }   
} ;
void test()
{
    vector<int> v;
    for(int i=0;i<5;i++)
        v.push_back(i);
    for_each(v.begin(),v.end(),myPrint);
    cout<<endl;
    for_each(v.begin(),v.end(),MyPrint2());
}

5.1.2 transform

功能：

将一个容器的内容搬运到另一个容器
函数原型：
transform(iterator beg1,iterator end1,iterator beg2,_func)
- beg1 源容器开始迭代器
- end1 源容器结束迭代器
- beg2 目标容器开始迭代器
- _func 函数或者函数对象(仿函数)

class MyTransform
{
public:
    int operator()(int v)
    {
        return v;
    }
};

void test()
{
    vector<int> v;
    for(int i=0;i<5;i++)
    {
        v.push_back(i);
    }
    
    vector<int> vTarget;
    vTarget.resize(v.size());//一定要开辟空间,不能用reserve 
    
    transform(v.begin(),v.end(),vTarget.begin(),MyTransform());
    for(vector<int>::iterator it = v.begin();it!=v.end();it++)
    {
        cout<<*it<<" ";
    } 
    cout<<endl;
    for(vector<int>::iterator it = vTarget.begin();it!=vTarget.end();it++)
    {
        cout<<*it<<" ";
    }           
}

5.2 常用的查找算法

find
find_if
adjacent_find
binary_search
count
count_if

5.3常用的排序算法

sort
random_shuffle 随机打乱元素
merge
reverse

5.4 常用的拷贝和替换算法

copy
replace
replace_if
swap

5.5 常用的算术生成算法

头文件：#include <numeric>

accumulate 计算容器内所有元素的总和
fill 向容器内填充元素

5.6 常用的集合算法

set_intersection 求两个容器的交集
set_union 求两个容器的并集
set_difference 求两个容器的差集

继续当一名咸鱼(￣︶￣)!

C++ 提高编程

0.前言

1.模板

1.1 模板的概念

1.2 函数模板

1.2.1 函数模板的语法

1.2.2 函数模板的注意事项

1.2.3 普通函数和函数模板的区别

1.2.4 普通函数和函数模板的调用规则

1.2.5 模板的局限性

1.3 类模板

1.3.1 类模板语法

1.3.2 类模板与函数模板的区别

1.3.3 类模板中 成员函数的创建时机

1.3.4 类模板对象做函数参数

1.3.5 类模板与继承

1.3.6 类模板成员函数类外实现

1.3.7 类模板分文件编写

1.3.8 类模板和友元

1.3.9 类模板案例

2.STL

2.1 STL的诞生

2.2 SLT的基本概念

2.3 SLT六大组件

2.5 容器算法迭代器

2.5.1 vector存放内置数据类型

2.5.2 vector存放自定义数据类型

2.5.3 vector嵌套容器

3.1 string容器

3.1.1 string基本概念

3.1.2 string构造函数

3.2 vector容器

3.2.1 vector基本概念

3.2.2 vector构造函数

3.3 deque容器

3.4 stack容器-栈

3.5 queue-队列

3.6 list容器-双向循环链表

3.7 set/multiset容器-二叉树

3.8 map/multimap容器

4.STL-函数对象

4.1 函数对象

4.1.1函数对象的概念

4.1.2 函数对象的使用

4.2 谓词

4.2.1 谓词的概念

4.2.2 一元谓词

4.2.3 二元谓词

4.3 内建函数对象

4.3.1 概念

4.3.2 算术仿函数

4.3.3 关系仿函数

4.3.4 逻辑仿函数

5.STL-常用算法

5.1 常用遍历算法

5.1.1 for_each

5.1.2 transform

5.2 常用的查找算法

5.3常用的排序算法

5.4 常用的拷贝和替换算法

5.5 常用的算术生成算法

5.6 常用的集合算法

Stay hungry，Stay foolish！

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

1.3.3 类模板中成员函数的创建时机