学习《深入应用c++11》1
C++11 让程序更简洁、更优雅
可调用对象
- 是一个函数指针
- 是一个具有operator()成员函数的类对象（仿函数）
- 是一个可被装换为函数指针的类对象
- 是一个类的成员（函数）指针
void func()
{
}
struct Foo
{
void operator()(void)
{
}
};
struct Bar
{
using fr_t = void(*)(void);
static void func(void)
{
}
operator fr_t(void)
{
return func;
}
};
struct A
{
int a_;
void mem_func(void)
{
}
};
int main()
{
void(*func_ptr)(void) = &func; //函数指针
func_ptr();
Foo foo; //仿函数
foo();
Bar bar;
bar(); //可被转换为函数指针的类的对象
void(A::*mem_func_ptr)(void) = &A::mem_func; //类成员函数指针
int A::*mem_obj_ptr = &A::a_; //类成员指针
A aa;
(aa.*mem_func_ptr)();
aa.*mem_obj_ptr = 123;
return 0;
}
std::function
std::function是可调用对象的包装器，可以容纳除了类成员（函数）指针之外的所有可调用对象。通过指定它的模板参数，它可以用统一的方式处理函数、函数对象、函数指针，并允许保存和延迟执行它们。
#include <iostream>
#include <functional>
using namespace std;
void func(void)
{
std::cout << __FUNCTION__ << std::endl;
}
class Foo
{
public:
static int foo_func(int a)
{
std::cout << __FUNCTION__ << std::endl;
return a;
}
};
class Bar
{
public:
void operator()(void)
{
std::cout << __FUNCTION__ << std::endl;
}
};
class A
{
std::function<void()> callback_;
public:
A(const std::function<void()>& f):callback_(f)
{
}
void notify(void)
{
callback_();
}
};
void call_when_even(int x, const std::function<void(int)>& f)
{
if(!(x & 1))
{
f(x);
}
}
void output(int x)
{
std::cout << x << " ";
}
int main()
{
std::function<void(void)> fr1 = func; //普通函数
fr1();
std::function<int(int)> fr2 = Foo::foo_func; //类的静态成员函数
std::cout << fr2(123) << std::endl;
Bar bar; //仿函数
fr1 = bar;
fr1();
A aa(bar);
aa.notify();
for (size_t i = 0; i < 10; i++)
{
call_when_even(i, output);
}
std::cout << std::endl;
return 0;
}
std::bind
std::bind用来将可调用对象与其参数一起进行绑定。绑定后的结果可以使用std::function进行保存，并延迟调用到任何我们需要的时候
- 将可调用对象与其参数一起绑定成一个仿函数
- 将多元（参数个数为n,n>1)可调用对象转成一元或者(n-1)元可调用对象，即只绑定部分参数
class B
{
public:
std::string name_;
void output(int x, int y)
{
std::cout << x << " " << y << std::endl;
}
};
int main()
{
B b;
std::function<void(int,int)> fr = std::bind(&B::output, &b, std::placeholders::_1, std::placeholders::_2);
fr(1,2);
std::function<std::string&(void)> fr_s = std::bind(&B::name_, &b);
fr_s() = "hello";
std::cout << b.name_ << std::endl;
return 0;
}
后置返回类型
template <typename T, typename U>
//decltype(t+u) add(T t, U u) //C++的返回值是前置语法，返回值定义的时候参数还未定义
//decltype(T()+U()) add(T t, U u) //通过构造函数完成推导,如果一个类没有无参构造函数,这个地方就会报错
//decltype( (*(T*)0) + (*(U*)0) ) add(T t, U u) //OK,但不够优雅
auto add(T t, U u) -> decltype(t+u)
{
return (t + u);
}
模板别名
typedef std::map<std::string, int> map_s_i;
map_s_i mymap1{std::make_pair("first",1)};
typedef std::map<std::string, std::string> map_s_s;
map_s_s mymap2{ std::make_pair("second","second") };
//需求 固定以std::string最为map的key,它可以映射到不同的类型（如int、long、string等）
//在c++98|C++03, 比较猥琐写法
template<typename T>
struct mymap
{
typedef std::map<std::string, T> type;
};
mymap<int>::type mymap3;
mymap<double>::type mymap3;
//c++11
template <typename T>
using mymapt = std::map<std::string, T>;
mymapt<int> mymap4;
//这个地方主要用到了using，在c++11中,使用using基本可以替代typedef
using funcType = int(*)(int,int);
template<typename T>
using funcT = int(*)(T,T);
int func_int(int n1,int n2)
{
return n1+n2;
}
funcT<int> func_i = func_int;
func_i(1,2);
函数模板默认参数
c++11前，只能为类模板提供默认模板参数，c++11后可以为函数模板提供默认参数
template<typename T=std::string,int size = 10>
class myarray
{
private:
T arr[size];
public:
void myfunc();
}
class tc
{
public:
tc() { std::cout << "构造函数" << std::endl; }
tc(const tc& t) { std::cout << "拷贝构造" << std::endl; }
int operator()(int v1, int v2)const
{
return v1 + v2;
}
};
template<typename T, typename F = tc>
T test(const T& i, const T& j, F funcpoint = F())
{
return funcpoint(i, j);
}
template <typename T = int, typename U>
auto func(U val)->decltype(val)
{
std::cout << typeid(val).name() << std::endl;
return val;
}
//在调用函数模板时，若显示指定模板的参数，参数的填充顺序是从右到左
func(123);
// T << std::string << U << 123.363
func<std::string>(123.363);
tuple
- tuple 构造的tuple对象所保存的是构造实参的拷贝
- make_tuple: 构造tuple对象所保存的是构造实参的拷贝
- tie: 通过tie构造的tuple对象，保存构造实参的可写引用
- forward_as_tuple:通过forward_as_tuple构造的tuple对象，保存构造实参的原始引用,左值使用左值引用，右值使用右值引用
template<class Tuple, std::size_t N>
struct TuplePrinter
{
static void print(const Tuple& t)
{
TuplePrinter<Tuple, N-1>::print(t);
std::cout << " " << std::get<N-1>(t);
}
};
template<class Tuple>
struct TuplePrinter<Tuple, 1>
{
static void print(const Tuple& t)
{
std::cout << std::get<0>(t);
}
};
template<class... Args>
void print(const std::tuple<Args...>& t)
{
std::cout << "( ";
TuplePrinter<decltype(t), sizeof...(Args)>::print(t);
std::cout << " )\n";
}
void show()
{
std::cout << std::endl;
}
template <class T, class... Args>
void show(const T& t, const Args &... args)
{
std::cout << t << " ";
show(args...);
}
int main()
{
int age = 20;
float height = 170.6;
std::string name = "小马";
std::cout << "----- tuple() -----" << std::endl;
// tuple构造函数
std::tuple<std::string, int, float> tp1(name, age, height);
// 获取元素的值
print(tp1);
// 修改元素的值
std::get<0>(tp1) = "小云";
std::get<1>(tp1) = 40;
std::get<2>(tp1) = 16.8;
// 获取元素的值
print(tp1);
// 获取变量的值; 通过结果发现,tuple构造函数构造的对象保存的是构造实参的拷贝
show("(", name, age, height, ")");
std::cout << "----- make_tuple -----" << std::endl;
// 通过make_tuple构造tuple对象
// auto tp2 = std::make_tuple(name, age, height);
auto tp2 = std::make_tuple("hello", 1, 2.0); //等价于上面的
// 获取元素的值
print(tp2);
// 修改元素的值
std::get<0>(tp2) = "小李";
std::get<1>(tp2) = 35;
std::get<2>(tp2) = 18.0;
// 获取元素的值
print(tp2);
// 获取变量的值; 通过结果发现,make_tuple构造的对象保存的也是构造实参的拷贝
show("(", name, age, height, ")");
std::cout << "----- tie -----" << std::endl;
// 通过tie构造tuple对象
auto tp3 = std::tie(name, age, height);
// auto tp3 = std::tie("hello", 2, 2);
// 获取元素的值
print(tp3);
// 修改元素的值
std::get<0>(tp3) = "小李";
std::get<1>(tp3) = 35;
std::get<2>(tp3) = 18.0;
// 获取元素的值
print(tp3);
// 获取变量的值; 通过结果发现,成功修改了构造实参
show("(", name, age, height, ")");
std::cout << "----- tie parser tuple-----" << std::endl;
// 通过tie解析tuple对象
auto tp4 = std::make_tuple("关羽", 30, 1.85);
tie(name, age, height) = tp4;
show("(", name, age, height, ")");
std::cout << "----- forward_as_tuple lvalue-----" << std::endl;
auto tp5 = forward_as_tuple(name, age, height);
// 获取元素的值
print(tp4);
// 修改元素的值，get得到的是左值引用
std::get<0>(tp5) = "小王";
std::get<1>(tp5) = 35;
std::get<2>(tp5) = 18.0;
// 获取元素的值
print(tp4);
// 获取变量的值; 通过结果发现,成功修改了构造实参
show("(", name, age, height, ")");
std::cout << "----- forward_as_tuple rvalue-----" << std::endl;
auto tp6 = std::forward_as_tuple("小赵", 30, 1.85);
// 获取元素的值
print(tp6);
// 修改元素的值，这是get得到的是一个右值引用，无法修改
// std::get<0>(tp6) = "小王";
// std::get<1>(tp6) = 35;
// std::get<2>(tp6) = 18.0;
return 0;
}
内容来源于：深入应用C++11 代码优化与工程级应用
浙公网安备 33010602011771号