IT博客-魔のkyo的工作室-随笔分类-STL

可变模版参数(variadic templates)

魔のkyo — Sat, 09 Nov 2019 05:23:00 GMT

C++11引入了一个很强大的模板功能，即可变模板参数(variadic templates)，

它允许定义出可变参数个数，同时可变参数类型的模板，看一个简单的例子

 1 #include <iostream>
 2 #include <cstdio>
 3 using namespace std;
 4 
 5 template <typename Args> // 通过typename声明的Args称为模板参数包，注意是写在typename后面的
 6 void func(const Args& args) // 这里的const Args&称为函数参数类型包，而声明出的args称为函数参数包
 7 {
 8     printf(args); // 这里的args称为对函数参数包的展开
 9 }
10 
11 int main(void)
12 {
13     func("%s %d", "Hello world", 123);
14 }
15 

输出为

Hello world 123

上面的展示很简单明确，现在我们基本知道可变模板参数是个什么东西了。那么它有什么用呢，下面我们来做一些稍微复杂一点的事，如果我们不用printf这样的接受可变长参数列表的函数作为输出，而使用cout该怎么修改上面的代码呢？下面我们稍作修改，通过递归调用把参数一个一个拆出来。

 1 #include <iostream>
 2 #include <cstdio>
 3 using namespace std;
 4 
 5 // 递归终止
 6 void func()
 7 {
 8 
 9 }
10 
11 template <typename T, typename Args>
12 void func(const T& obj, const Args& args)
13 {
14     cout << obj << " ";
15     func(args); // 递归调用
16 }
17 
18 int main(void)
19 {
20     func("Hello world", 123); //因为改成通过cin，前面的格式化字符串删掉了
21 }

通过增加在模板参数包前面增加一个参数T接受一个参数，再把后面的所有参数递归调用，就实现了一个一个拆出来，最后的调用中args...是可以为0个参数的，这时候调用到了上面的重载函数func()什么都不做。我们可能会想，能不能不写一个空的func()直接在模板函数里面判断args携带的参数个数来终止递归呢，答案是：可以的，但没那么简单。取得可变模板参数的个数可以使用sizeof...()或tuple_size<>::value，下面实现一下

 1 #include <iostream>
 2 #include <cstdio>
 3 using namespace std;
 4 
 5 template <typename T, typename Args>
 6 void func(const T& obj, const Args& args)
 7 {
 8     cout << obj << " ";
 9     if (sizeof(Args) > 0) {
10         func(args); // 递归调用
11     }
12 }
13 
14 int main(void)
15 {
16     func("Hello world", 123); //因为改成通过cin，前面的格式化字符串删掉了
17 }
18 

上面的代码试图通过判断sizeof...(Args)是否大于0决定是否继续递归，但是上面的代码会编译错误，因为if的判断是在运行期才做的，对func(args...)的调用在编译时就要有匹配的函数存在，而当args一个参数都没有时，编译器找不到匹配的函数进行调用（func至少接受一个参数T）。

所以问题的关键点是if分支是运行期的分支，如果我们做一个编译期的分支不就可以解决了么。

 1 #include <iostream>
 2 #include <cstdio>
 3 using namespace std;
 4 
 5 template <typename T, typename Args>
 6 void func(const T& obj, const Args& args);
 7 
 8 // 声明一个带有一个bool参数的模板struct
 9 template<bool Flag>
10 struct If_Func;
11 
12 // 下面对bool参数分别进行true/false两种特化实现，以此实现编译期的分支
13 template<>
14 struct If_Func<true>
15 {
16     template<typename Args>
17     static void call (const Args& args) {
18         func(args);
19     }
20 };
21 
22 template<>
23 struct If_Func<false>
24 {
25     template<typename Args>
26     static void call(const Args& args) {
27         
28     }
29 };
30 
31 template <typename T, typename Args>
32 void func(const T& obj, const Args& args)
33 {
34     cout << obj << " ";
35     constexpr bool flag = sizeof(Args) > 0;
36     If_Func<flag>::call(args);
37 }
38 
39 int main(void)
40 {
41     func("Hello world", 123); //因为改成通过cin，前面的格式化字符串删掉了
42 }

上面引入了一个If_Func，这个东西从语法层面来说就是类模板和模板特化，不是新东西，但是这种用法一般被称为模板元编程，C++1x里有一个头文件<type_traits>里面提供了很多模板可以帮助我们进行各种判断，比如判断一个类型是否指针，是否POD，一个类是否是另一个类的子类，等等，可以辅助我们进行模板元编程，有兴趣的自行搜索了解。

下面我们讲另一个东西，元组(tuple)，它可以看成是对std::pair的n个元素扩充

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

int main(void)
{
    tuple<int, double, string> t = make_tuple(1, 3.14, "Hello world");
    cout << typeid(t).name() << endl;
    cout << std::tuple_size<decltype(t)>::value << endl; // 输出tuple的元素个数
    cout << std::get<0>(t) << endl; // 输出tuple的第0个元素
    cout << std::get<1>(t) << endl; // 输出tuple的第1个元素
    cout << std::get<2>(t) << endl; // 输出tuple的第2个元素
}

这里不展开讲tuple的用法，我们注意，tuple的模板参数其实类型和数量都是可变的，事实上它就是利用了可变模板参数来实现的。怎么实现呢，大概是这样

template<typename Args>
class my_tuple;

template<>
class my_tuple<>
{

};

template<typename T, typename Args>
class my_tuple<T, Args> : public my_tuple<Args>
{
public:

protected:
    T _obj;
};

通过递归继承的方式，每次把一个参数拆出来作为成员变量，其余的参数丢给基类，直到参数为空。

标准库并没有实现tuple的输出，现在产生一个问题，我们自己能否实现一个tuple的输出函数呢。

要实现的就是如果我们使用

cout << make_tuple(123, 3.14, "Hello") << endl;

可以像python里面

print( (123, 3.14, "Hello") )

输出元组一样，打印出类似 (123, 3.14, 'Hello')

我们要实现的函数原型是这样

template 

ostream& operator << (ostream& out, const tuple t);

直接给出代码，里面再次用到了所谓的模板元编程技巧。

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

template <size_t N>
struct PrintHelper;

template <>
struct PrintHelper<1>
{
    template<typename Args>
    static void recursive_print(ostream& out, const tuple<Args> t)
    {
        out << "(" << std::get<0>(t) << ", ";
    }
};

template <size_t N>
struct PrintHelper
{
    template<typename Args>
    static void recursive_print(ostream& out, const tuple<Args> t)
    {
        PrintHelper<N - 1>::recursive_print(out, t);
        out << std::get<N - 1>(t) << ", ";
    }

    template<typename Args>
    static void print(ostream& out, const tuple<Args> t)
    {
        PrintHelper<N - 1>::recursive_print(out, t);
        out << std::get<N - 1>(t) << ")";
    }
};


template <typename Args>
ostream& operator << (ostream& out, const tuple<Args> t)
{
    PrintHelper<tuple_size<decltype(t)>::value >::print(out, t);
    // PrintHelper::print(out, t); // 和上面等价
    return out;
}

int main(void)
{
    cout << std::make_tuple(123, 3.14, "Hello") << endl;
}

事实上这里会输出

(123, 3.14, Hello)

Hello的两端并没有引号，如果想加上引号，可以再次利用模板元编程技巧通过编译时的分支把string类型的输出方法特化，此处不再给出具体代码，留给读者自行探索。

魔のkyo 2019-11-09 13:23 发表评论

Boost和C++1x最值得学习的库概览

魔のkyo — Fri, 08 Nov 2019 10:05:00 GMT

Boost库分两种

header-only的 和 header + lib的

大多数都是header-only的，直接包含头文件就可以用。header + lib由一组头文件和一个库文件构成，可以自己用下载下来的代码编译出库文件或者直接在网上下载对应版本编译好的库。

需要连接lib的有以下库：

    Boost.Chrono	已经标准化 std::chrono C++11

    Boost.Context	C++的协程支持（Coroutine）

    Boost.Filesystem	已经标准化 std::filesystem C++17 处理文件和路径的

    Boost.GraphParallel	是Boost.Graph库的扩展，为了支持并行和分布式计算，包含一些图算法

    Boost.IOStreams	IO流，我觉得最大的特点是可以通过filter进行zlib, gzip 和 bzip2的压缩和解压

    Boost.Locale	本地化库，最主要是解决字符编码转换的问题，还有些日期货币格式转换

    Boost.Log		日志库

    Boost.MPI		用于分布式计算中的消息传递

    Boost.ProgramOptions	读取 命令行参数 或 配置文件

    Boost.Python	和pyhon的交互框架

    Boost.Regex	已经标准化std::regex C++11

    Boost.Serialization	序列化

    Boost.Signals	信号槽模式的一个实现

    Boost.Thread	已经标准化std::thread C++11

    Boost.Timer		计时器，可以用std::chrono::high_resolution_clock自己实现，所以没必要

    Boost.Wave		C++预处理器，似乎是为了方便编写一些对C++代码进行预处理的代码

以上被标记为红色的我觉得比较有用，可以学习一下，此外包括header-only的一些库，很多都已经被标准化，这些被标准化的往往是比较有用的，我找了了一下大概有下面这些：

 std::bind / std::function / std::ref / std::cref

 std::is_pod / std::is_base_of / std::enable_if / std::result_of / auto / decltype

数组封装 std::array 和vector比固定大小，和原生[]数组比不会退化为指针，有迭代器

任意类型 std::any

可选类型 std::optional / std::nullopt

正则表达式 std::regex

编译时分数 std::ratio

指针增强 std::shared_ptr  / std::weak_ptr / std::unique_ptr

n元组 std::tuple / std::make_tuple / std::get

多线程和锁 std::thread / std::mutex / std::lock_guard / std::unique_lock / std::atomic

时钟 std::chrono::high_resolution_clock / std::chrono::system_clock / std::chrono::steady

HASH表 std::unordered_map / std::unordered_set / std::hash

静态断言 static_assert

我把相关联的东西合并在了一行，这些可以说是C++1x新标准最值得学习的内容。

魔のkyo 2019-11-08 18:05 发表评论

使用c++的traits技术实现的任意类型元素的表达式求值

魔のkyo — Fri, 19 Sep 2008 17:51:00 GMT

摘要: 这里以整形和浮点型表达式为例。 Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/-->#include #include #include ... 阅读全文

魔のkyo 2008-09-20 01:51 发表评论

STL:bitset的使用

魔のkyo — Sat, 07 Jul 2007 14:24:00 GMT

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

int main()
{
    const bitset<32> mask(0xFFFFFF00);
    cout << "mask = " << mask << endl;

    bitset<32> x;

    cout << "Enter a 32-bit bitset in binary: " << flush;
    if (cin >> x) {
        cout << "x =        " << x << endl;
        cout << "As ulong:  " << x.to_ulong() << endl;
        cout << "And with mask: " << (x & mask) << endl;
        cout << "Or with mask:  " << (x | mask) << endl;
    }
}

魔のkyo 2007-07-07 22:24 发表评论

使用自己的函数对象定义sort,priority_queue,map,set中的序

魔のkyo — Thu, 05 Jul 2007 11:14:00 GMT

#include <iostream>
#include <functional>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <set>
#include <vector>
#include <string>
using namespace std;

struct Node{
    int data;
    Node(){}
    Node(int n){data=n;}
};

struct myCmp : binary_function<Node,Node,bool>{
    bool operator () (const Node& a,const Node& b)
    {
        return a.data < b.data;
    }
};
/*
根据实践即便不从 binary_function 派生也是可以使用的
class myCmp{
public:
    bool operator () (const Node& a,const Node& b)
    {
        return a.data < b.data;
    }
};
*/
int main()
{
    priority_queue<Node,vector<Node>,myCmp> PQ;
    set<Node,myCmp> S;
    Node arr[6]={1,-1,2,-2,3,-3};
    sort(arr,arr+6,myCmp());
}

魔のkyo 2007-07-05 19:14 发表评论

STL学习笔记－－sort,less

魔のkyo — Wed, 24 May 2006 08:12:00 GMT

sort算法的原型如下，使用sort需要包含algorithm头文件
template RandomAccessIterator>
void sort(RandomAccessIterator first, RandomAccessIterator last);

template StrictWeakOrdering>
void sort(RandomAccessIterator first, RandomAccessIterator last,
StrictWeakOrdering comp);

将sort算法作用于一个存放自定义对象的容器时，如果使用第一种调用方式，那么comp默认使用less函数对象(function object)进行比较，less函数对象需要自定义的对象（即：容器中的对象）有"operator <"运算。
同样，greater函数对象需要使用对象的"operator >"运算。
（less_equal，greater_equalye依此类推）

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

class C{
    int data;
public:
    C(int n=0){data=n;}
    friend bool operator < (const C &a, const C &b);
    friend ostream& operator << (ostream& stream , const C &ob);

};

inline bool operator < (const C &a, const C &b)
{
    return (a.data < b.data);
}

ostream& operator << (ostream& stream , const C &ob)
{
    stream<<ob.data;
    return stream;
}

int main ()
{
    int i;
    vector<C> a(10);
    for(i=0;i<10;i++){
        a[i]=i;
    }
    sort(a.begin(),a.end(),less<C>() );
    for(i=0;i<10;i++){
        cout<<a[i]<<endl;
    }
    system("pause");
}

魔のkyo 2006-05-24 16:12 发表评论

号称唯美主义的杰作

魔のkyo — Sat, 06 May 2006 10:43:00 GMT

先记下来，慢慢研究

#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>

using namespace std;

int main(void)
{
    typedef vector<int>    int_vector;
    typedef istream_iterator<int>    istream_itr;
    typedef ostream_iterator<int>    ostream_itr;
    typedef back_insert_iterator< int_vector > back_ins_itr;
    // STL中的vector容器
    int_vector num;
    // 从标准输入设备读入整数，
    // 直到输入的是非整型数据为止
    copy(istream_itr(cin), istream_itr(), back_ins_itr(num));
    // STL中的排序算法
    sort(num.begin(), num.end());
    // 将排序结果输出到标准输出设备
    copy(num.begin(), num.end(), ostream_itr(cout, " "));

    cout<<endl;
    return 0;
}

魔のkyo 2006-05-06 18:43 发表评论

学习使用标准模板库(STL)

魔のkyo — Thu, 04 May 2006 05:42:00 GMT

#include < iostream >
#include < vector > // 动态数组
// #include   // 双向线性表
// #include   // 堆栈
#include < algorithm >
using namespace std;
int main()
{
    vector < char > v;
    cout << " size: " << v.size() << endl;

     // 初始化v
     char c;
     for (c = ' A ' ;c <= ' Z ' ;c ++ )
        v.push_back(c);
    cout << " size: " << v.size() << endl;

    vector < char > ::iterator p,q;

     // 输出(通过迭代器访问)
    p = v.begin();q = v.end();
     while (p < q)
        cout <<* p ++<< " " ;
    cout << endl;

     // 将v全部反序
    reverse(v.begin(),v.end()); // 需要头文件

     // 再次输出(通过下标访问)
     for ( int i = 0 ;i < v.size();i ++ )
        cout << v[i] << " " ;
    cout << endl;

     return 0 ;
}

标准模板库是个好东西,不用我们再去"发明车轮"了

魔のkyo 2006-05-04 13:42 发表评论