C++泛型库

最新推荐文章于 2024-09-02 23:29:10 发布
最新推荐文章于 2024-09-02 23:29:10 发布
阅读量1k 收藏 20
点赞数 29
文章标签： c++ 开发语言 模板
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/flyingshineangel/article/details/141130557
版权

可调用对象

        一些库包含这样一些接口，调用方可以向该类接口传递一些实体，并要求该实体必须被调用。这种编程方式称为回调，调用方传入的实体称为回调函数。

        C++中，可以被用作回调参数的类型如下：

  • 函数指针类型
  • 仿函数，包括lambda表达式
  • 包含一个可以产生函数指针或函数引用的转化函数的class类型

        以上这些类型统称为函数对象类型，其对应的值称为函数对象。

函数对象的支持

        关于上文提到的三种情况，前两种比较好理解，下面便是相关例子：

#include <iostream>
#include <vector>

template <typename Iter, typename Callable>
void foreach(Iter begin, Iter end, Callable callable) {
    for (auto iter = begin; iter != end; ++iter)
        callable(*iter);
}

void func(int i) {
    std::cout << i << std::endl;
}

struct func_obj {
    void operator()(int i) {
        std::cout << i << std::endl;
    }
};

int main(int argc, char **argv)
{
    std::vector<int> primes = { 2, 3, 5, 7, 11, 13, 17, 19 };
    foreach(primes.begin(), primes.end(), func);
    foreach(primes.begin(), primes.end(), &func);
    foreach(primes.begin(), primes.end(), func_obj());
    foreach(primes.begin(), primes.end(), [](int i)->void {std::cout << i << std::endl;});
    return 0;
}

        前两种情况能够说明平时遇到的一些问题，但有时，遇到的情况会复杂一些：

  • 调用方已有的函数参数与接口要求的回调参数不一致
  • 调用方已有的函数是一个非静态类成员函数，而接口仅允许传入一个函数，不允许传入对象

        上述则是一开始所提到的第三种情况。遇到这种情况，只能对已有的函数进行封装，然后再把封装后的函数或类传给接口，这便是函数转换。下面便是函数转换的一个例子：

#include <iostream>
#include <vector>

template <typename Iter, typename Callable>
void foreach(Iter begin, Iter end, Callable callable) {
    for (auto iter = begin; iter != end; ++iter)
        callable(*iter);
}

void add(int &x, int i) {
    x += i;
}

typedef void (*add_fp)(int &, int);
class add_wrapper
{
public:
    add_wrapper(add_fp fp, int i) : m_fp(fp), m_i(i) {}
    void operator()(int &x) {
        m_fp(x, m_i);
    }
    
private:
    add_fp m_fp;
    int m_i;
};

int main(int argc, char **argv)
{
    std::vector<int> primes = { 2, 3, 5, 7, 11, 13, 17, 19 };
    foreach(primes.begin(), primes.end(), [](int i)->void {std::cout << i << std::endl;});
    foreach(primes.begin(), primes.end(), add_wrapper(add, 100));
    foreach(primes.begin(), primes.end(), [](int i)->void {std::cout << i << std::endl;});
    
    return 0;
}

        看到上面这个例子，很容易联想到std::function，其实上面就是一个乞丐版的std::function实现。当然，直接使用std::function可以更简单地解决问题，如下：

#include <iostream>
#include <vector>

template <typename Iter, typename Callable>
void foreach(Iter begin, Iter end, Callable callable) {
    for (auto iter = begin; iter != end; ++iter)
        callable(*iter);
}

void add(int &x, int i) {
    x += i;
}

class add_class
{
public:
    void add(int &x, int i) {
        x += i;
    }
};

int main(int argc, char **argv)
{
    std::vector<int> primes = { 2, 3, 5, 7, 11, 13, 17, 19 };
    foreach(primes.begin(), primes.end(), [](int i)->void {std::cout << i << std::endl;});
    
    std::function<void(int &)> add1 = std::bind(add, std::placeholders::_1, 100);
    foreach(primes.begin(), primes.end(), add1);
    foreach(primes.begin(), primes.end(), [](int i)->void {std::cout << i << std::endl;});
    
    add_class add_obj;
    std::function<void(int &)> add2 = std::bind(&add_class::add, add_obj, std::placeholders::_1, 100);
    foreach(primes.begin(), primes.end(), add2);
    foreach(primes.begin(), primes.end(), [](int i)->void {std::cout << i << std::endl;});
    
    return 0;
}

        那么问题来了，为什么需要类似std::function的解决方案呢？大体原因如下：

  • 由于种种原因，不方便修改foreach和add源码，例如二者都是第三方库
  • std::function方案比直接用函数对add进行封装扩展性强，用函数对add封装方案如下，但如果要在原来的数值上加200呢？如果要换成乘法呢?为此需要一遍又一遍地写实现封装函数。
//...
int add_100(int &x) {
    x += 100;
}
//...
foreach(primes.begin(), primes.end(), add_100);
//...
  • 比直接使用函数指针更加安全 

 处理成员函数以及额外的参数

        除了前面提到std::function，C++17引入的std::invoke也能起到函数转换的作用，如下：

#include <iostream>
#include <vector>
#include <utility>
#include <functional>

template <typename Iter, typename Callable, typename ...Types>
void foreach(Iter begin, Iter end, Callable callable, Types &...args) {
    for (auto iter = begin; iter != end; ++iter)
        std::invoke(callable, args..., *iter);
}

class callable {
public:
    void print(int i) { std::cout << i << std::endl; }
};

void myprint(int i) { std::cout << i << std::endl; }

class myprint_cls {
public:
    void operator()(int i) { std::cout << i << std::endl; }
};

int main(int argc, char **argv)
{
    std::vector<int> primes = { 2, 3, 5, 7, 11, 13, 17, 19 };
    callable c;
    foreach(primes.begin(), primes.end(), &callable::print, c);
    callable *pc = &c;
    foreach(primes.begin(), primes.end(), &callable::print, pc);
    foreach(primes.begin(), primes.end(), [&](int i)->void { std::cout << i << std::endl; });
    foreach(primes.begin(), primes.end(), myprint);
    foreach(primes.begin(), primes.end(), myprint_cls());
    
    return 0;
}

        在处理回调函数方面，尽管std::invoke有函数转换的作用，统一了全局函数，成员函数，仿函数，以及lambda表达式的调用方式。但与std::function相比，参数位置的处理却没那么灵活。

其他一些实现泛型库的工具

std::addressof

        如果一个类重载了&操作符，就无法通过&获取其对象实例的地址，如下：

#include <memory>
#include <iostream>

class test {
public:
    test *operator&() { return nullptr; }
};

int main(int argc, char **argv) {

    test *ptr = new test();
    std::cout << ptr << std::endl;
    std::cout << &(*ptr) << std::endl;
    
    return 0;
}

         使用std::addressof取代&操作符，就可以解决该问题，如下：

std::cout << std::addressof(*ptr) << std::endl;

        std::declval

        

        函数模板 std::declval()可以被用作某一类型的对象的引用的占位符。该函数模板没有定义， 因此不能被调用(也不会创建对象)。因此它只能被用作不会被计算的操作数(比如 decltype 和 sizeof)。也因此，在不创建对象的情况下，依然可以假设有相应类型的可用对象。        

        比如在如下例子中，会基于模板参数 T1 和 T2 推断出返回类型 RT:

#include <utility>
template<typename T1, typename T2,
typename RT = std::decay_t<decltype(true ? std::declval<T1>() : std::declval<T2>())>>

RT max (T1 a, T2 b) {
    return b < a ? a : b;
}

        为了避免在调用运算符?:的时候不得不去调用 T1 和 T2 的(默认)构造函数，这里使用了

std::declval，这样可以在不创建对象的情况下“使用”它们。不过该方式只能在不会做真正 的计算时(比如 decltype)使用。

 

完美转发临时变量

#include <string>
#include <iostream>

class tracer {
public:
    tracer(void) { std::cout << "tracer::tracer(void)" << std::endl; }
    tracer(const tracer &) { std::cout << "tracer::tracer(const tracer &)" << std::endl; }
    tracer(tracer &&) { std::cout << "tracer::tracer(tracer &&)" << std::endl; }
    tracer &operator=(const tracer &) {
        std::cout << "tracer::operator=(const tracer &)" << std::endl;
        return *this;
    }
    tracer &operator=(tracer &&) {
        std::cout << "tracer::operator=(tracer &&)" << std::endl;
        return *this;
    }
};

template <typename T>
T get(T x) {
    std::cout << "get" << std::endl;
    return x;
}

template <typename T>
void set(T x) {
    std::cout << "set" << std::endl;
}

template <typename T>
void foo(T x) {
    std::cout << "foo" << std::endl;
    //set(get(x));
    T &&tmp = get(x);
    //...
    set(tmp);
}

int main(int argc, char **argv) {
    tracer tr;
    foo(tr);
    return 0;
}

        对于上述代码，foo函数如果直接使用set(get(x));，get的返回值以右值引用传给set。但为了进行其他处理，使用tmp变量对get返回值进行保存，尽管tmp是一个右值引用，但调用set(tmp);时，tmp被已左值引用的方式传递。解决方案如下：

//...
template <typename T>
void foo(T x) {
    std::cout << "foo" << std::endl;
    T &&tmp = get(x);
    //...
    //set(std::move(tmp));
    set(std::forward<decltype(tmp)>(tmp));
}

//...

        当然此处也可以使用std::move（std::move与std::forward区别有待研究）。 

作为模板参数的引用

         如果函数模板的形参传递的不是引用，即使传递一个引用变量作为实参，其模板类型也不会被推断为引用，如下：

#include <iostream>
#include <string>

template <typename T>
void is_ref(T x) {
    std::cout << std::is_reference<T>::value << std::endl;
}

int main(int argc, char **argv) {
    std::string str0 = "hello";
    std::string &str1 = str0;
    is_ref(str0); //0
    is_ref(str1); //0
    is_ref<std::string &>(str0); //1
    is_ref<std::string &>(str1); //1
    
    return 0;
}

        尽管显示指定T的实例化类型为引用，但这不是模板设计的最初目的，因此，这种方案可能引发编译错误，如下：

template <typename T, T Z = T{}>
class ref_mem {
public:
    ref_mem(void) : m_zero(Z) {}
private:
    T m_zero;
};

int null = 0;
int main(int argc, char **argv) {
    ref_mem<int> rm1, rm2;
    rm1 = rm2;
    
    ref_mem<int &> rm3; //non-const lvalue reference to type 'int' cannot bind to an initializer list temporary
                        //in instantiation of default argument for 'ref_mem<int &>' required here
    ref_mem<int &, 0> rm4; //value of type 'int' is not implicitly convertible to 'int &'
    rm3 = rm4;

    ref_mem<int &, null> rm5, rm6;
    rm5 = rm6; //object of type 'ref_mem<int &, null>' cannot be assigned because its copy assignment operator is implicitly deleted
                // copy assignment operator of 'ref_mem<int &, null>' is implicitly deleted because field 'm_zero' is of reference type 'int &'
    
    return 0;
}

        引用类型用于非模板类型参数同样会变的复杂和危险，如下：

#include <vector>
#include <iostream>

template <typename T, int &SZ>
class arr {
public:
    arr(void) : m_elem(SZ) {}
    
    void print(void) {
        for (int i = 0; i < SZ; ++i)
            std::cout << m_elem[i] << ' ';
    }
private:
    std::vector<T> m_elem;
};

int size = 10;
int main(int argc, char **argv) {
    arry<int &, size> y; //编译错误太多，眼花缭乱
    arr<int, size> x; 
    x.print();
    size += 100;
    x.print(); //内存越界，行为未定义
    
    return 0;
}

延迟计算

        在实现模板的时候，有时可能需要考虑不完全类型的情形。什么是不完全类型？下面是一段相关的解释：

‌‌不完全类型‌是指那些在函数之外、类型的大小不能被确定的类型。这种类型可能无法实例化，也不能访问其成员，但可以使用派生的指针类型。不完全类型包括未指定长度的数组、未完全定义的‌结构体或‌联合体，以及void类型。‌

        上述几种非完全类型，数结构体的情况最为复杂，下面是一个结构体相关的不完全类型例子：

#include <stdio.h>

struct Node;

struct List {
    Node head;
};

struct Node {
	int id;
	Node next;
};

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

        关于上面的例子：List定义使用Node时，Node仅仅进行了声明，未进行定义；Node定义中使用Node时，Node未完成定义。这两种情况中Node都属于属于不完全类型，因此，无法实例化，编译报错：

incomplete.cpp:6:10: error: field has incomplete type 'Node'
    Node head;
         ^
incomplete.cpp:3:8: note: forward declaration of 'Node'
struct Node;
       ^
incomplete.cpp:11:7: error: field has incomplete type 'Node'
        Node next;
             ^
incomplete.cpp:9:8: note: definition of 'Node' is not complete until the closing '}'
struct Node {

        可以使用Node指针取代Node来解决问题。接下来，看下非完全类型在模板中的影响。 

#include <string>
#include <iostream>
#include <type_traits>

template <typename T>
class Ptr final {
public:
    Ptr() : m_ptr(new T()) {}
    
    T && foo(void) {
        return *m_ptr;
    }
private:
    T *m_ptr;
};

struct Node {
    std::string name;
    Ptr<Node> next;
};

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

        在上面的例子中，尽管在Node定义next，Node属于不完全类型，上面的源码仍然可以通过编译，因为Ptr中使用的是指针（直接使用Node无法通过编译）。现在，对Ptr::foo做下修改，要求如果类型支持移动语义，返回移动对象，否则返回引用对象，新的源码如下：

...    
    typename std::conditional<std::is_move_constructible<T>::value, T &&, T &> foo(void) {
        return *m_ptr;
    }
...

       然而源码无法通过编译，报错如下：

/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/usr/include/c++/v1/__type_traits/is_move_constructible.h:24:38: error: incomplete type 'Node' used in type trait expression
    : public integral_constant<bool, __is_constructible(_Tp, __add_rvalue_reference_t<_Tp>)>
                                     ^
DeferEvaluation.cpp:12:36: note: in instantiation of template class 'std::is_move_constructible<Node>' requested here
    typename std::conditional<std::is_move_constructible<T>::value, T &&, T &> foo(void) {
                                   ^
DeferEvaluation.cpp:22:15: note: in instantiation of template class 'Ptr<Node>' requested here
    Ptr<Node> next;
              ^
DeferEvaluation.cpp:20:8: note: definition of 'Node' is not complete until the closing '}'
struct Node {
       ^

        之所以报错，是因为std::is_move_constructible 要求其参数必须是完全类型。而在使用 Ptr<Node>定义next时，Node属于非完全类型。解决方法是引入一个新的模板参数D，把T作为D的默认参数，新的源码如下：

...
template <typename D = T>
typename std::conditional<std::is_move_constructible<D>::value, D &&, D &> foo(void) {
    return *m_ptr;
}
...

        这样，成员函数foo在实例化后仍然是一个函数模板，不再依赖模板实参Node。再次调用成员函数foo时，foo再次被实例化。但此时即便使用Node作为模板实参也可以正常编译，因为这个实例化过程在Node定义的外部，Node属于完全类型。

        

         

王健
关注
  • 29
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++泛型编程
蹦跶跶
06-04 6379
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++泛型编程算法
m0_71311771的博客
10-07 289
泛型编程最初诞生于C++中。目的是为了实现C++的STL（标准模板库）。换句话说，把一个原本特定于某个类型的算法或类当中的类型信息抽掉，抽出来做成模板参数T。
c++ 泛型
q306507291的博客
07-04 3006
目录 1. 什么是泛型 2. 为什么需要泛型 3.泛型如何用 参考泛型是什么，C++泛型编程又是什么？ 参考多篇文章整合而成 1. 什么是泛型 泛型是什么，C++泛型编程又是什么？ 泛型，实质上就是不使用具体数据类型（例如 int、double、float 等），而是使用一种通用类型来进行程序设计的方法，该方法可以大规模的减少程序代码的编写量，让程序员可以集中精力用于业务逻辑的实现。 维基-Generic programming Generic programming .
C++ 泛型编程
zy1872071381的博客
08-26 691
C++泛型编程
c++泛型库罕见编写注意事项
superzmy的专栏
10-19 160
由于operator,逗号运算符 重载存在，泛型库对于 if ( A(), 123) 这样的逗号连接表达式应在中间插入(void)，如 A(), (void), 213。 由于operator& 取址运算符 重载存在，泛型库应使用std::addressof取地址 ...
c++泛型算法
dzy521的博客
04-28 1147
一、概述 标准库并未给每个容器都定义成员函数来实现一些操作，而是定义了一组泛型算法，他们实现了一些经典算法的接口 术语： beg和end 元素范围的迭代器 beg2和end2 beg2表示第二个序列开始位置迭代器，end2表示第二个序列末尾迭代器(如果有的话)。如没有end2则假定系列2至少与beg和end表示的范围一样大。beg和beg2类型不必匹配，但必须保证两个序列中的元素可以执行特性操作或调用给定的可调用对象 des 表示目的序列的迭代器。对于给定输入
C++ 泛型编程详解
01-21
这一篇介绍一下 C++ 编程中与面向对象并列的另一大分支——泛型编程，这一篇主要介绍函数模板、类模板和成员模板三大部分 如有侵权，请联系删除，如有错误，欢迎大家指正，谢谢 泛型编程 模板是泛型编程的一种重要...
《c++泛型stl原理和应用》全部例题源码
12-08
《C++泛型STL原理和应用》是一本深入探讨C++ Standard Template Library（STL）的书籍，其中包含了大量的例题源码，旨在帮助读者理解STL的机制和运用。STL是C++标准库的重要组成部分，它提供了一组高效、泛型的容器...
C语言操作符详解1（含进制转换，原反补码）
hdxbufcbjuhg的博客
09-02 1334
左移操作符对一个十进制整数的影响是有规律的，无论正负数，都可以对原数值起到乘以2的移位次方的作用，比如将10左移了1位，那么就对原数值乘以了2的一次方，变成了20，依次类推，如果是-10左移了1位，那么就会变成-20对一个无符号数进行右移操作，会对它进行除以2的移位次方，比如将10右移一位，就对它除以了2的一次方，最后变成了5，那如果这个数不是偶数怎么办呢？比如123向右移一位，它除以2就是61.5，最后结果会返回这个数两边较小的整数，61.5的两边分别是61和62，最终得到小的那个数61，所以综上，
【C++】深入理解C++模板：从基础到进阶
2403_86785171的博客
09-01 662
模板是C++中用于泛型编程的工具。它允许你编写可以处理任意类型的函数和类，而不必重复编写相似的代码。函数模板和类模板。
【C++】智能指针——auto_ptr，unique_ptr，shared_ptr
2301_79796701的博客
09-01 1271
1.智能指针对象中引用计数是多个智能指针对象共享的，两个线程中智能指针的引用计数同时 ++或--，这个操作不是原子的，引用计数原来是1，++了两次，可能还是2.这样引用计数就错 乱了。旧的智能指针的会转移给新的智能指针，而旧的智能指针的会被置空。解决方案：在引用计数的场景下，把节点中的_prev和_next改成weak_ptr就可以了，weak_ptr不会增加引用计数，代码示意。该问题是有类似于链表节点的结构引起的，当外部的智能指针都释放了，就拿不内部的智能指针，那么节点就不会释放。使用方法参考官方文档。
Linux C 内核编程 /proc 编程例子
最新发布
yong1585855343的博客
09-02 411
Linux 内核编程 /proc 例子代码
c++11新特性-智能指针
SuperYang_的博客
09-01 1139
智能指针RAII(Resource Acquisition Is Initialization)，是一种利用对象的生命周期来管理资源的技术。如果我们采用传统的new/delete来申请和释放资源，如果忘记调用delete，或者在调用delete之前程序抛出异常，都会导致内存泄漏问题，如代码1.1，Func函数中的new p2和Div都可能抛异常，导致后面的delete没有执行从而引发内存泄漏，采用智能指针对资源进行管理，能够杜绝这类问题。代码1.1：因异常引发的内存泄漏throw "除0错误";
【C++ Primer Plus习题】9.1
qq_74047911的博客
09-02 309
【C++ Primer Plus习题】9.1
C++友类匿名对象，运算符重载
m0_75109289的博客
09-02 252
【代码】C++友类匿名对象，运算符重载。
《从C/C++到Java入门指南》- 26.record 类+多态
09-02 338
由于record类比较简单，将他和多态放在一节中。
C++ | Leetcode C++题解之第390题消除游戏
Ddddddd_158的博客
09-02 194
C++ | Leetcode C++题解之第390题消除游戏
快速构建一个ui界面程序--pyqt入门
ChiKuo_Z的博客
09-01 1121
一个使用pyqt快速搭建简易UI的保姆级入门教程
C++战列舰小游戏Lv. 1.2版本(半成品)
YYDS314的博客
08-31 1921
C++代码
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值