C++ 泛型

最新推荐文章于 2024-04-19 14:09:48 发布
最新推荐文章于 2024-04-19 14:09:48 发布
阅读量411 收藏 2
点赞数
分类专栏： C++ C++primer 文章标签： C++ C++primer
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012526003/article/details/53028508
版权

C++ 泛型

  • 头文件：algorithm

find

  • 代码

    #include<iostream>
#include<exception>
#include<fstream>
#include<sstream>
#include<string>
#include<vector>
#include<iterator>
#include<list>
#include<deque>
#include<stack>
#include<queue>
#include<concurrent_priority_queue.h>
#include<algorithm>

using namespace std;


int main()
{
    cout << "start!" << endl;

    int ia[] = {10,20,30};

    int *res = find(ia, ia+3, 10);
    if (res == cend(ia)) //如果没有找到，则res指向end
    {
        cout << "can not find" << endl;
    }
    else
    {
        cout << "find value : " << res-cbegin(ia) << ", " <<  *res << endl;
    }


    cout << "end!" << endl;
    system("pause");
    return EXIT_SUCCESS;
}
  • 说明
    • find的第一个参数是起始位置，第二个参数是要搜索的末位置的后一位，第三个参数是要寻找的变量值
    • 如果找到的话，返回值是指向容器对应位置的地方；没有找到的话，则返回值指向容器的end
    • 如果需要对应位置的值，直接*res，取对应位置的内容即可。

count

  • 说明：按照C++ primer 5th中的10.1的练习写的代码

  • 代码

    #include<iostream>
#include<exception>
#include<fstream>
#include<sstream>
#include<string>
#include<vector>
#include<iterator>
#include<list>
#include<deque>
#include<stack>
#include<queue>
#include<concurrent_priority_queue.h>
#include<algorithm>

using namespace std;


int main()
{
    cout << "start!" << endl;

    vector<int> v;
    int r;

    cout << "Please input vector number" << endl;
    while (cin >> r)
    {
        v.push_back( r );
    }

    cin.clear(); //使输入流重新有效

    while (true)
    {
        cout << "please input number to find : ";
        cin >> r;

        int number = count( v.begin(), v.end(), r );
        cout << "find same number : " << number << endl;
    }



    cout << "end!" << endl;
    system("pause");
    return EXIT_SUCCESS;
}
  • 注意：在ctrl+z终止输入后，再次输入时，需要用cin.clear()来清空缓冲区。

accumulate

  • 在头文件numeric中
  • 说明：前两个参数是迭代器的始末位置，必须是只读的类型，第三个参数是累加的初始值，必须显式创建，否则会不知道其类型。

  • 代码

    #include<iostream>
#include<exception>
#include<fstream>
#include<sstream>
#include<string>
#include<vector>
#include<iterator>
#include<list>
#include<deque>
#include<stack>
#include<queue>
#include<concurrent_priority_queue.h>
#include<algorithm>
#include<numeric>

using namespace std;


int main()
{
    cout << "start!" << endl;

    vector<int> v;
    for (int i = 0; i < 10; i++)
        v.push_back(i);
    int res = accumulate(v.cbegin(), v.cend(), 0);
    cout << res << endl;

    vector<string> vs = {"a", "bdsg", "fdr"};
    string ress = accumulate(vs.cbegin(), vs.cend(), string(""));
    cout << ress << endl;


    cout << "end!" << endl;
    system("pause");
    return EXIT_SUCCESS;
}

fill and fill_n

  • 用于给容器的某些元素赋值
  • fill是指定要填充的始末和要填充的元素
  • fill_n是指定要填充的起始位置和填充个数以及要填充的元素
  • fill_n：个数不能超过当前的容量，否则程序会报错。

  • 代码

    #include<iostream>
#include<exception>
#include<fstream>
#include<sstream>
#include<string>
#include<vector>
#include<iterator>
#include<list>
#include<deque>
#include<stack>
#include<queue>
#include<concurrent_priority_queue.h>
#include<algorithm>
#include<numeric>

using namespace std;


int main()
{
    cout << "start!" << endl;
    vector<string> vs = {"a", "bdsg", "fdr"};

    fill_n( vs.begin(), vs.size(), string("0") );
    fill(vs.begin(), vs.end(), string("23"));

    cout << "end!" << endl;
    system("pause");
    return EXIT_SUCCESS;
}

copy and replace and replace_copy

  • copy:复制
  • replace:替换
  • replace_copy:将源容器中的所有要进行迭代的数据复制到一个新的容器中，是以back_inserter的形式插入（在末尾添加的形式）

  • 代码

    #include<iostream>
#include<exception>
#include<fstream>
#include<sstream>
#include<string>
#include<vector>
#include<iterator>
#include<list>
#include<deque>
#include<stack>
#include<queue>
#include<concurrent_priority_queue.h>
#include<algorithm>
#include<numeric>

using namespace std;


int main()
{
    cout << "start!" << endl;

    vector<int> orig;
    auto it = back_inserter( orig );
    for (int i = 0; i < 10; i++)
    {
        *it = i;
    }
    vector<int> res1( orig.size() );
    copy(orig.begin(), orig.end(), res1.begin());
    replace( orig.begin(), orig.end(), 0, 233 );
    vector<int> res2;
    replace_copy(orig.begin(), orig.end(), back_inserter(res2), 1, 455);

    cout << "end!" << endl;
    system("pause");
    return EXIT_SUCCESS;
}

sort and unique and erase

  • 说明：去除容器中重复的元素
  • unique接受排序后的容器列表

  • 代码

    #include<iostream>
#include<exception>
#include<fstream>
#include<sstream>
#include<string>
#include<vector>
#include<iterator>
#include<list>
#include<deque>
#include<stack>
#include<queue>
#include<concurrent_priority_queue.h>
#include<algorithm>
#include<numeric>

using namespace std;


int main()
{
    cout << "start!" << endl;

    string str = "a b c d s f g s e d a s b";
    stringstream sstream(str);
    vector<string> vs;
    while (sstream >> str)
    {
        vs.push_back( str );
    }

    //按照 < 的运算符进行排列，最小的排在最前面
    sort( vs.begin(), vs.end() );

    //unique接受有序容器，返回值指向不重复区域之后一个位置的迭代器
    auto end_unique = unique( vs.begin(), vs.end() );

    vs.erase( end_unique, vs.end() );


    cout << "end!" << endl;
    system("pause");
    return EXIT_SUCCESS;
}

lambda

  • 说明：除了可以接受自己的函数参数列表，还可以捕获所在函数的局部变量，并使用在程序中

  • 代码

    #include<iostream>
#include<exception>
#include<fstream>
#include<sstream>
#include<string>
#include<vector>
#include<iterator>
#include<list>
#include<deque>
#include<stack>
#include<queue>
#include<concurrent_priority_queue.h>
#include<algorithm>
#include<numeric>

using namespace std;


int main()
{
    cout << "start!" << endl;

    auto func_add_1 = [](int a, int b) {return a + b; };

    cout << func_add_1(3,3) << endl;

    int num1 = 3;

    auto func_add_2 = [num1](int num){ return num + num1; };

    cout << func_add_2(5) << endl;


    cout << "end!" << endl;
    system("pause");
    return EXIT_SUCCESS;
}
  • func_add_1:传入的参数
  • func_add_2:捕获列表

bind and count_if

  • count_if:记录容器中满足条件的个数，条件可以用lambda表达式给出
  • bind:用于修改函数的一些属性，如传参的顺序，可以通过修改占位符来修改传参的顺序

  • 代码

    #include<iostream>
#include<exception>
#include<fstream>
#include<sstream>
#include<string>
#include<vector>
#include<iterator>
#include<list>
#include<deque>
#include<stack>
#include<queue>
#include<concurrent_priority_queue.h>
#include<algorithm>
#include<numeric>
#include<functional>  //bind

using namespace std;

bool Smaller(const int &a, const int &b)
{
    return a <= b;
}

int main()
{
    cout << "start!" << endl;

    string str = "a by-value capture cannot be modified in a non-mutable lambda";
    stringstream sstream(str);
    vector<string> vs;
    while (sstream >> str)
    {
        vs.push_back(str );
    }

    int cnt = count_if(vs.begin(), vs.end(), [](string str) -> bool{return str.length() >= 8; });
    cout << cnt << endl;

    vector<int> vi = { 1, 4, 6, 8, 2, 5, 3 };
    sort(vi.begin(), vi.end(), bind<int>(Smaller, std::placeholders::_2, std::placeholders::_1));
    for_each(vi.begin(), vi.end(), [](int n){cout << n << endl; });


    cout << "end!" << endl;
    system("pause");
    return EXIT_SUCCESS;
}

inserter and front_inserter

  • inserter:插入元素后，迭代器的位置指向刚刚插入元素的位置
  • front_inserter:元素总是插入到第一个迭代器元素之前

  • 代码

    #include<iostream>
#include<exception>
#include<fstream>
#include<sstream>
#include<string>
#include<vector>
#include<iterator>
#include<list>
#include<deque>
#include<stack>
#include<queue>
#include<concurrent_priority_queue.h>
#include<algorithm>
#include<numeric>
#include<functional>  //bind

using namespace std;

int main()
{
    cout << "start!" << endl;

    list<int> lst = {1,2,3,4};
    list<int> lst2, lst3;

    copy(lst.cbegin(), lst.cend(), front_inserter(lst2));
    copy(lst.cbegin(), lst.cend(), inserter(lst3, lst3.begin()));

    for_each(lst2.begin(), lst2.end(), [](int num){cout << num << endl; });
    for_each(lst3.begin(), lst3.end(), [](int num){cout << num << endl; });


    cout << "end!" << endl;
    system("pause");
    return EXIT_SUCCESS;
}

istream_iterator

  • 流迭代器

  • 说明：可以从流迭代器初始化容器

    #include<iostream>
#include<exception>
#include<fstream>
#include<sstream>
#include<string>
#include<vector>
#include<iterator>
#include<list>
#include<deque>
#include<stack>
#include<queue>
#include<concurrent_priority_queue.h>
#include<algorithm>
#include<numeric>
#include<functional>  //bind

using namespace std;

int main()
{
    cout << "start!" << endl;

    istream_iterator<int> in_iter(cin), eof;
    vector<int> vi(in_iter, eof);

    for_each(vi.begin(), vi.end(), [](int num){cout << num << endl; });

    cout << "end!" << endl;
    system("pause");
    return EXIT_SUCCESS;
}

输出容器中所有数据的两种方法

  • for_each

    for_each(vi.begin(), vi.end(), [](int num){cout << num << endl; });

  • copy

    ostream_iterator<int> out_iter(cout, "\r\n" );
copy( vi.begin(), vi.end(), out_iter );
littletomatodonkey
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++泛型编程
蹦跶跶
06-04 5741
C++泛型编程与STL总结1. 泛型编程1.1 模板1.2 函数模板1.2.1 语法1.2.2 使用函数模板方式1.2.3 普通函数和函数模板的区别1.2.4 普通函数与函数模板的调用规则1.2.5 模板的局限性1.3 类模板2. STL技术 1. 泛型编程 泛型编程最初诞生于C++中。目的是为了实现C++的STL（标准模板库）。其语言支持机制就是模板（Templates）。模板的精神其实很简单：参数化类型。换句话说，把一个原本特定于某个类型的算法或类当中的类型信息抽掉，抽出来做成模板参数T。（参考自Bai
C++中的泛型详细讲解
weixin_45805339的博客
11-30 5794
它是一种泛化的编程方式，其实现原理为程序员编写一个函数/类的代码示例，让编译器去填补出不同的函数实现。允许您延迟编写类或方法中的编程元素的数据类型的规范，直到实际在程序中使用它的时候。换句话说，泛型允许您编写一个可以与任何数据类型一起工作的类或方法。函数模板的声明和定义要放在一个头文件中。在部分使用场景，会使用.hpp来表示这个头文件是包含了函数定义的（即.h和.cpp的集合体）。需要注意，这并不是一个硬性要求，你也可以直接使用.h，并将声明和定义放入其中。因为单独的.h。
C++泛型详解
程序猿老樊的博客
03-10 3034
如果要在函数模板内部使用这样的类型，必须显示告诉编译器这个名字是一个类型，否则编译器无法得知它是一个类型还是一个值。模板形参可以是表示类型的类型形参（type parameter），也可以是表示常量表达式的非类型形参（nontype parameter）。编译器将确定用什么类型代替每个类型形参，用什么值代替每个非类型形参，然后产生并编译（称为实例化）该版本的函数。在定义的类模板中，使用模板形参作为类型或值的占位符，在使用类时再提供具体的类型或值。函数模板是一个独立于类型的函数，可以产生函数的特定类型版本。
C++提高篇：泛型编程和STL技术详解，探讨C++更深层的使用
最新发布
数据知道的博客
04-19 5079
学习目标：vector中存放自定义数据类型，并打印输出//自定义数据类型public:mAge = age;//存放对象//创建数据it!= v.end();it++) {//放对象指针//创建数据it!= v.end();test02();return 0;
C++入门泛型编程介绍
m0_53421868的博客
12-06 8760
目录函数模板函数模板格式函数模板的实例化补充：类模板类模板的定义格式类模板的实例化 泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础 函数模板 函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。 函数模板格式 template<typename T1, typename T2,......,typename Tn> 返回值类型 函数名(参数列表){} 用不同类型的参数使用函数模板时，称为函数模板的实例.
C++类属（泛型）——模板详解
m0_56745306的博客
07-22 1440
第八章——类属（泛型）——模板 1.概述 在程序设计中经常会用到这样的一些程序实体：这些程序实体的实现和所完成的基本功能相同，不同的地方仅在于它们所涉及的数据类型不同。对于这些函数或类，如果能分别只用一个函数和一个类来描述它们，将会大大简化程序设计的工作，并能实现代码复用。 在程序设计中，一个程序实体能对多种类型的数据进行操作或描述的特性成为类属性（generics）。能具有类属性的程序实体通常有类属函数和类属类。类属函数是指一个函数能对不同类型的数据（参数）完成相同的操作。类属类是指一个类的成员类型可变，
C++泛型算法的一些总结
09-05
C++泛型算法是编程语言中的一类重要工具，它们提供了高效、通用的处理数据序列的方法，不依赖于特定的数据结构或元素类型。这些算法独立于容器，仅依赖于元素的比较操作，使得代码更加灵活且易于重用。在本文中，...
C++ 泛型编程详解
01-21
这一篇介绍一下 C++ 编程中与面向对象并列的另一大分支——泛型编程，这一篇主要介绍函数模板、类模板和成员模板三大部分 如有侵权，请联系删除，如有错误，欢迎大家指正，谢谢 泛型编程 模板是泛型编程的一种重要...
《c++泛型stl原理和应用》全部例题源码
12-08
《C++泛型STL原理和应用》是一本深入探讨C++ Standard Template Library（STL）的书籍，其中包含了大量的例题源码，旨在帮助读者理解STL的机制和运用。STL是C++标准库的重要组成部分，它提供了一组高效、泛型的容器...
【10】C++之泛型算法
Utotao的博客
04-25 472
对于顺序容器的其他操作：查找元素、替换或者删除一个特定值、重排元素顺序等。标准库并未给每个容器都定义成员函数来实现这些操作，而是定义了一组泛型算法（generic algorithm）：称它们为“算法”，是因为它们实现了一些经典算法的公共接口。如排序和搜索；称它们是“泛型的”，是因为它们可以用不同类型的元素和多种容器类型（不仅包括标准库类型，如vector或list，还包括内置的数组类型）。 标...
【C++】泛型编程
weixin_45423515的博客
08-31 5438
为了让函数或者类有更好的复用性，C++引入了摸板的技术。让不同的数据类型，能使用到相同的函数或者类中去，这种编程的思想也叫做泛型编程。
C++//泛型算法
weixin_43918519的博客
03-29 1209
1. 初识泛型算法 泛型：可以作用于不同类型的元素和多种容器类型 算法：实现了一些经典算法诸如排序和搜索的接口。 泛型算法运行于迭代器之上，不会执行容器的操作。由此得出假定：泛型算法永远不会改变底层容器的大小。 输入范围：标准库算法都对一个范围内的元素进行操作，该范围称为输入范围。如果算法接受输入范围作为参数，通常用前两个参数表示范围，即第一个元素和尾后元素的迭代器。 大多数算法存储在algorithm头文件内，numeric中定义了一组数值泛型算法。 1.1 只读算法 只会读取输入范围中的元素，而不会改变
C++之泛型编程
PPdouluo的博客
11-28 459
是一个类型参数，它表示一个占位符，可以代表任何类型。当使用模板函数或类时，可以将具体的类型替换为。注意：template <typename T> 的含义是C++中的一个模板声明，其中。分别定义泛型编程里的函数模板、类模板以及常用的STL库迭代器。是一个关键字，用于指示编译器将后面的类型名称视为类型参数。，以实现代码的通用性和复用性。
C++数据结构--泛型编程
m0_73443478的博客
02-07 355
C++数据结构--泛型编程
C++11中的一些泛型编程思想——函数指针、function、lambda
jojozym的博客
05-08 1067
泛型编程思想函数指针functionlambdatry 为编写更通用的代码，将数据类型与方法、类分离，这就是泛型编程思想。 C++ 的三大面向对象特性：封装、继承、多态。它们分别保证了安全性、可复用性以及特性。 偷懒是人类生产力的重要动力之一。 从类的继承、template、函数指针，再到function、lambda，均是为了践行泛型编程思想，让偷懒更成功。 下面给出几个常用又直观的例子，学习函...
C++ Primer 第11章 泛型算法 学习总结
Michael是个半路程序员
10-10 920
标准容器定义的操作比较少，我们需要其他的一些函数来操作容器，比如查找，排序，这些算法不依赖容器类型。
C++中的函数模板
热门推荐
年少轻狂，幸福时光
08-23 6万+
之前我们知道的交换两个变量的方法有宏定义、函数，这两种方式都能实现两个变量的交换，但是各有各的优缺点 宏定义： - 优点：代码复用，适合所有的类型 - 缺点：缺少类型检查，宏在预处理阶段就被替换掉，编译器并不知道宏的存在 函数： - 优点：真正的函数调用，编译器对类型进行检查 - 缺点：类型不同需要重复定义函数，代码无法复用 上边两种方式...
c++11标准——泛型算法
ManHand的博客
05-21 377
正在看C++ primer 5，学习的同时，记录下学习体会。 (v表示容器) 实现在v中统计符合第三个参数条件的数量。有三种方法： bool cmpstr(const string &s) {    return s.size() >=5; } 1： 接受一个一元谓词。 auto count = count_if(v.begin(),v.end(),cmpstr
 c++泛型
06-01
C++中的泛型指的是可以在不指定具体类型的情况下编写代码。C++中实现泛型的主要方式是使用模板（Template）。模板可以让我们编写一份通用的代码，可以适用于不同类型的数据。在使用模板时，我们可以定义一个通用的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

littletomatodonkey

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值