|
std::function 基本实现
std::function 是在 C++11 中新增的一个用于统一包装可调用对象的模板类型. 所谓统一包装, 就是无论被包装的内容的实际类型, 只要符合相应的函数调用签名, 都可以装入一个 std::function 对象中使用. 比如
Code Snippet 0-0
#include <iostream>
#include <functional>
// 全局函数
int fn_ptr(int x, int y)
{
return x + y;
}
// 包含 2 个 int 成员的函数对象类型
struct TwoInts {
TwoInts(int m_, int n_)
: m(m_)
, n(n_)
{}
int operator()(int x, int y)
{
return x + y + m + n;
}
int m;
int n;
};
int main()
{
// 使用 std::function 类型包装全局函数指针
std::function<int(int, int)> f(fn_ptr);
std::cout << f(1, 2) << std::endl; // 输出 3
// 使用 std::function 类型包装函数对象
std::function<int(int, int)> g(TwoInts(10, 20));
std::cout << g(1, 2) << std::endl; // 输出 33
return 0;
}
上面的使用例子中, 两个 std::function 对象定义都在栈上. 按照 C++ 的常识, 两个对象一定有相同的尺寸, 即对它们求 sizeof 得出的值一定相等. 但用于构造这两个 function 对象的材料却有着不同的尺寸, 也就是说 function 可以 "捕获" 任何尺寸的可调用对象, 这正是其奇妙之处. 下面就来简单分析 std::function 的实现方法. 虽然 std::function 是在 C++11 中引入的, 但作为一个基本实现的分析, 本文将排除所有 C++11 的特性以避免不必要的解释. 当然, 这样会产生一个硬伤: 由于可变参数模板特性也是 C++11 中引入的特性, 本文的实现中将不支持任意多个模板类型参数, 而是使用返回值类型加上 2 个参数的类型共计 3 个类型作为模板的类型参数列表. 亦即, 在 C++11 中, 下面的用法是可能的 std::function<double()> f; // 只有返回值类型 <double> 的特化
std::function<int(std::string)> g; // 有返回值类型和 1 个参数类型 <int, std::string> 的特化
std::function<void(int, float)> h; // 有返回值类型和 2 个参数类型 <void, int, float> 的特化
// 可以扩展为任意多个参数类型的特化, 这是 C++11 的新特性
Code Snippet 0-1
// 默认特化没有实现
template <typename T>
class function;
// 实现有返回值类型和 2 个参数类型的偏特化
template <typename Ret, typename Arg0, typename Arg1>
class function<Ret(Arg0, Arg1)> {
// ...
};
语法上, 类似上面的 function<int(int, int)>, class function<Ret(Arg0, Arg1)> 等类似函数签名的模板特化形式并不常见, 虽然它是 C++11 之前就一直存在的语法. 抛开语法层面的部分, function 实现中最重要的就是如何在内部维护不同类型不同尺寸的可调用对象.
Posted at Nov 25 2017 - 04:55:23
Permanent Link:
/p/525
Load full text
|
Post tags:
STL
C++11
C++
|
|
C++ Lambda 简易上手
本文所有代码示例通过 g++ 4.6 编译. 之前有吐槽过 C++ STL 算法中的 for_each 函数华而不实, 主要原因是受限于 C++ 的函数编写语法, 即传统上 C++ 要求函数须独立编写, 而不能嵌套在其它函数内. 不过, 欢迎来到二十一世纪的第一个 0x10 年, 现在有了 lambda. 与其它语言一样, C++ 的 lambda 就是个匿名函数, 它的语法结构如 [ 上下文变量绑定方式 ] ( 形式参数列表 ) 可省略的返回值类型声明
{
函数体
}
匿名函数可以定义在任何地方, 作为一个 表达式出现; 如果在匿名函数的函数体中使用了表达式所在上下文中定义的量, 则需要指定绑定方式. 如 // 定义变量 sqr 为一个匿名函数
// 这个匿名函数的上下文变量绑定方式为空, 因为它无须引入任何上下文变量
// 这个匿名函数接受一个 int 作为参数
// 返回值类型声明省略, 由编译器推倒出返回 int
auto sqr = [](int x)
{
return x * x;
};
int x = 10;
// 这个匿名函数的上下文变量绑定方式为 & 即引用方式, 它引用了上文中定义的 x
// 这个匿名函数接受一个 int 作为参数
// 返回值类型声明为 bool
auto equalsToX = [&](int y) -> bool
{
return x == y;
};
// 这个匿名函数的上下文变量绑定方式为 = 即复制方式, 它引用了上文中定义的 x
// 这个匿名函数接受一个 int 作为参数
// 返回值类型声明省略
auto lessThanX = [=](int y)
{
return y < x;
};
可见多亏了 C++ 的强制类型声明和变量定义检查, 才把一个简单的匿名函数搞得这么复杂, 解决了不少其它语言中不存在的问题. 作为 C++ 程序员的一个特异能力便是能够在写代码时就预见到这段程序运行时内存与对象的流动. 看了上面匿名函数的各种奇葩绑定上下文的方法, 很明显它们不仅是一个函数那么简单, 如果必要匿名函数会占用一些内存空间, 可以做这样一个实验来试试. struct Point {
Point()
: x(0)
, y(0)
{}
double x;
double y;
};
int main()
{
Point p;
auto f = [&]()
{
std::cout << p.x << "," << p.y << std::endl;
};
auto g = [=]()
{
std::cout << p.x << "," << p.y << std::endl;
};
std::cout << sizeof(f) << " - " << sizeof(Point*) << std::endl;
std::cout << sizeof(g) << " - " << sizeof(Point) << std::endl;
auto sqr = [](int x)
{
return x * x;
};
std::cout << sizeof(sqr) << std::endl;
return 0;
}
Posted at Mar 03 2013 - 04:58:20
Permanent Link:
/p/505
Load full text
|
Post tags:
Labmda
C++
C++11
Nested Function
|
|
C++ 2011 中调用对象的 Rvalue Reference 成员函数重载
之前提到的 rvalue reference 还有一点没有结算, 其实本来早就想写完它, 但是尝试了很久, 最后 到 stackoverflow 上问来问去才最终解决, 那就是当某个对象是 rvalue 时, 怎么调用 rvalue 的成员函数重载. 之前在有关 rvalue 函数重载的讨论中说到参数是 rvalue 的情况, 很自然地, 如果认为 (简单起见, 非 virtual 的) 对象成员函数等价于普通函数加上一个 this 参数, 那么如何分辨 this 参数是 left value 还是 rvalue 呢? 受到对象成员函数可以 仅根据 const 修饰与否来重载这个现状的启发, 对于对象本身是 rvalue 的重载当然很可能是为成员函数加上某种修饰, 类似下面这个样子 struct Type {
void func(); // for normal left reference
void func() const; // for const left reference
void func() rvalue-qualified-id; // for rvalue reference
};
想法当然好, 而且确实有这么一回事, 只是标准敢正常一点么? 下面上真实代码, 这段代码目前似乎只能在 clang++ (我试验的版本是 2.9) 上编译通过 #include <cstdio>
struct Type {
Type() {}
void func() &
{
puts("a");
}
void func() const&
{
puts("b");
}
void func() &&
{
puts("c");
}
};
int main()
{
Type a;
a.func();
Type const b;
b.func();
Type().func();
return 0;
}
输出是 a
b
c
前两个函数重载看起来很怪异? 原因是, 如果成员函数重载中只要有一个函数是给 rvalue 用的 (也就是函数后面有 && 修饰), 那么其它重载也必须标注上一个 & 号. 读的时候去掉前两个重载的 & 就很容易看明白了. 而最后一个重载正是给 rvalue 用的. 这样变态地使用符号, 看来标准委员会看来是毫不介意 C++ 逐渐演化成既不表意又不象形的新世纪面向对象强化版 Brainfuck. 真的在代码中写这种东西的死 coder 是伤不起的!
Posted at May 01 2011 - 09:15:20
Permanent Link:
/p/303
Load full text
|
Post tags:
C++
Function Overload
Right Reference
C++11
Left Value
|
|
C++ 2011 中的 Left Value 与 Rvalue Reference
#include "某 C++ 概念之序篇"答: std::stringstream() 产生的临时变量无法匹配类型 std::stringstream&. 但是 std::stringstream() 可以匹配类型 std::stringstream const&, 也就是说, 如果函数 std::stringstream& operator<<(std::stringstream& os, double d) 的签名和实现作修改成下面这个样子就行了 std::stringstream const& operator<<(std::stringstream const& os, double d)
{
const_cast<std::stringstream&>(os).operator<<(d);
return os;
}
之前扯过 C++ 已经没有语法意义上的左值了, 不过这里似乎有一点点很微妙的, 跟左值很类似的东西, 那就是, C++ 引用. 任何一本 C++ 入门书籍里面都会花一些篇幅来讨论引用, 其基本意义, 无非是 某个东西的别名, 因此, 这 某个东西对于引用而言显然是至关重要的. 最基本的一点是, 如果被引用的东西是临时变量 (顺便一提, 如果是字面常量这种比较尴尬的情况, 视同临时变量) 怎么办? 比如之前代码样例 A 中的情况? 这就牵扯到 C++ 中正统的 left value. 因为 left 已经不再有任何 "左" 相关的意义的, 所以我不太想在本文中把这货称之为 "左值" (实际上英文在这些方面更加灵活, 比如 Copyleft 这词跟 left 也没太大关系, 用来吐槽则非常不错). 一个东西如果是 left value, 那么它就可以被赋值给 left value 引用, 所谓 left value 引用嘛, 就是就是类似 std::stringstream& 的引用类型, 而暗含 const 的类型的引用则不算 typedef int const int_const;
int_const& this_is_not_a_left_value_reference;
那究竟什么是 left value 呢? 一个语句之后仍然存在的变量, 表达式, 或者这样类似的 "具有 值属性的什么东西" 就是 left value. 而 std::cout << (std::stringstream() << d).str().length() << std::endl;这句之后, 显然临时构造的 std::stringstream() 就被析构了, 因此这家伙不算是 left value, 自然也就无法被 std::stringstream& 所引用. 那常数为什么不算 left value 呢? 当然, 可以认为常数居阴阳之外, 别谈语句之后, 吐核退出, 就算是宇宙毁灭, 什么 π 啊 e 啊还活得好好的; 不过, 从计算机的角度来理解, 常数是 CPU 指令的立即数, 所以别谈语句之后, 只要这条指令结束, 它就没了. 然而, C++ 一个很邪恶的规定是, 即使一个东西不是 left value, 它仍然可以绑定 const 引用, 比如以下语句都是合法的 std::pair<int, int> const& pair = std::make_pair(0, 1);
std::stringstream const& strm = std::stringstream();
std::string const& x = "Raki suta";
int const& i = 0;
这样直白地写出来是有点让人觉得不舒服, 不过作为函数调用的参数则好得多, 比如之前的代码片段 B 那样
Posted at Mar 28 2011 - 13:07:31
Permanent Link:
/p/232
Load full text
|
Post tags:
Move Semantic
Operator Overload
C++
Right Reference
Copy Constructor
Left Value
C++11
|
|
某 C++ 概念之序篇
C++ 虔诚的信徒们, 请阅读下面的代码, 回答码后的问题 /* 完整样例 A */
#include <iostream>
#include <sstream>
std::stringstream& operator<<(std::stringstream& os, double d)
{
os.operator<<(d);
return os;
}
int main()
{
double d;
std::cin >> d;
std::cout << (std::stringstream() << d).str().length() << std::endl;
return 0;
}
问: 为什么上述代码无法通过编译? /* 代码片段 B */
#include <map>
#include <string>
#include <stdexcept>
struct key_error
: public std::logic_error
{
explicit key_error(std::string const& what)
: std::logic_error(what)
{}
};
std::string const& lookup(std::map<std::string, std::string> const& map
, std::string const& key)
throw(key_error)
{
std::map<std::string, std::string>::const_iterator i = map.find(key);
if (map.end() == i) {
throw key_error("key ``" + key + "'' not found in map");
}
return i->second;
}
问: 上述代码中的 lookup 函数有什么隐患? 答案已揭晓, 点此查看, 谢谢关注.
Posted at Mar 26 2011 - 09:37:59
Permanent Link:
/p/222
Load full text
|
Post tags:
C++11
Copy Constructor
Move Semantic
C++
Operator Overload
Left Value
Right Reference
|
|
std::unique_ptr<cookbook>
std::unique_ptr 是 C++11 标准的 STL 中, 用来取代 std::auto_ptr 的指针容器 (如果在代码中使用了 std::auto_ptr, 使用 gcc 4.5 之后的版本加上 -std=c++0x -Wall 参数编译时, gcc 会报出警告 std::auto_ptr 已经过时). 同 std::auto_ptr 一样, std::unique_ptr 的基本功效也能当作简单的自动对象管理指针来使用, 如 #include <memory> /* for std::unique_ptr */
#include <iostream>
struct echo {
echo()
{
std::cout << "ctor" << std::endl;
}
~echo()
{
std::cout << "dtor" << std::endl;
}
echo(echo const&) = delete;
};
void test()
{
std::unique_ptr<echo> echo_ptr(new echo);
}
int main()
{
test();
std::cout << "." << std::endl;
return 0;
}
输出应该如 ctor
dtor
.
类型 echo 在构造和析构时的输出信息可以帮助掌握对象的生命周期. 如上述程序中, echo 对象在 test 函数结束时析构. std::unique_ptr 的复制构造函数被 delete 处理了, 所以类似下面的代码会出错 std::unique_ptr<int> a(new int(0));
std::unique_ptr<int> b(a); // ERROR
// deleted function
// ‘std::unique_ptr<...>::unique_ptr(std::unique_ptr<...> const&)'
如果确实需要复制一份整数的值, 需要可以做如下操作 std::unique_ptr<int> b(new int(*a));
而如果是想要将 a 所持有的指针转移到 b 中, 需要显式调用 std::move 将来移交指针控制权 std::unique_ptr<int> a(new int(0));
std::unique_ptr<int> b(std::move(a));
此时 a 中的指针会变为 NULL. 明确的转移语义由 std::move 函数表达, 与 std::auto_ptr 暧昧的构造函数不同, std::move 明确指出 std::unique_ptr 对象是通过转移构造进行参数传递的. 当函数需要使用 std::unique_ptr 作为参数或返回值时, 可以是如下几种形式
Posted at Mar 13 2011 - 08:34:22
Permanent Link:
/p/181
Load full text
|
Post tags:
C++
C++11
unique_ptr
Move Semantic
Tutorial
|
|
C++ 转移构造
这篇文章中的例子均可在 GCC 4.5.1 版本和 Clang 2.8 版本编译, 在某些较老或优化不尽相同的编译器上, 下面的例程可能并不能获得与文中所述一致的结果. 不过, 这篇文章的重点并非讲述 C++ 中关于复制构造函数的优化, 而是为了说明 C++0x 标准中出现的 Move Semantic 所试图解决的问题之一, 所以对关于复制构造函数的例子有大致理解即可. 重点是, 如果希望完整地编译文中最后一部分中出现的任何 0x 标准相关的代码, 强烈推荐 GCC 4.5.x 版本编译器. 废话少说, 先来一段代码: #include <iostream>
struct cp_ctor_doubling {
cp_ctor_doubling(int ii)
: i(ii)
{}
cp_ctor_doubling(cp_ctor_doubling const& rhs)
: i(rhs.i * 2)
{}
int const i;
};
cp_ctor_doubling create(int i)
{
return cp_ctor_doubling(i);
}
int main()
{
cp_ctor_doubling c(create(10));
std::cout << c.i << std::endl;
return 0;
}
问: 输出多少? A. 10 B. 20 C. 40 D. 以上答案都不正确. 嗯, 也许有得到 B 和 C 的, 得到 D 的同学也许该试着为自己的编译器报个 bug 了, 如果得到 A, 那么恭喜, 您的编译器已经具备对于复制构造函数最基本的优化能力了. C 语言忠实信徒揶揄 C++ 编译器会背着程序员做的 "额外的事情" 时, 历来会想到 C++ 的类复制构造函数. 然而, 现实不仅仅是这样, 编译器还会做出更多额外的事情, 比如把不必要的复制构造函数调用优化掉, 或者更准确地说, 把一些临时对象给优化掉, 于是复制构造函数根本不会被调用到. 如果对上述例子中的编译优化有任何疑虑, 可以尝试下面这段代码 #include <iostream>
struct cp_ctor_not_impl {
cp_ctor_not_impl(int ii)
: i(ii)
{}
cp_ctor_not_impl(cp_ctor_not_impl const&);
int const i;
};
cp_ctor_not_impl create(int i)
{
return cp_ctor_not_impl(i);
}
int main()
{
cp_ctor_not_impl c(create(10));
std::cout << c.i << std::endl;
return 0;
}
Posted at Jul 17 2010 - 16:27:35
Permanent Link:
/p/94
Load full text
|
Post tags:
C++
C++11
Move Semantic
Copy Constructor
|
