C++ Template Metaprogramming——一个小型lambda库的实作

最新推荐文章于 2024-06-26 00:17:49 发布
最新推荐文章于 2024-06-26 00:17:49 发布
阅读量195 收藏
点赞数
分类专栏： C&C++ 文章标签： C C++ C# 算法 Access

Boost里面的lambda库实在是很复杂，因此我对其进行了精简，缩减到300多行代码，只支持+-*/四则运算，虽没有boost中lambda库那么强大，亦可窥其奥妙。下面是lambda库的源码：

 

/*
 * lambda.h
 *
 *  Created on: 2010-12-28
 *      Author: 
 */

#ifndef LAMBDA_H_
#define LAMBDA_H_

#include "boost/tuple/tuple.hpp"
#include "boost/any.hpp"

using namespace boost;

#define CALL_TEMPLATE_ARGS class A, class B, class C, class Env
#define CALL_FORMAL_ARGS A& a, B& b, C& c, Env& env
#define CALL_ACTUAL_ARGS a, b, c, env
#define CALL_ACTUAL_ARGS_NO_ENV a, b, c
#define CALL_REFERENCE_TYPES A, B, C, Env&
#define CALL_PLAIN_TYPES A, B, C, Env

#define LAMBDA_DISABLE_IF_ARRAY1(A1, R1) typename R1::type
#define LAMBDA_DISABLE_IF_ARRAY2(A1, A2, R1, R2) typename R1, R2::type
#define LAMBDA_DISABLE_IF_ARRAY3(A1, A2, A3, R1, R2, R3) typename R1, R2, R3::type

template<class A1, class A2, class A3, class A4>
void do_nothing(A1&, A2&, A3&, A4&) {
}

#define CALL_USE_ARGS \
do_nothing(a, b, c, env)

template<class Base>
class lambda_functor;

template<class Act, class Args>
class lambda_functor_base;

struct null_type {
};

static const null_type constant_null_type = null_type();
#define cnull_type() constant_null_type

enum {
	NONE = 0x00, // Notice we are using bits as flags here.
	FIRST = 0x01,
	SECOND = 0x02,
	THIRD = 0x04,
	EXCEPTION = 0x08,
	RETHROW = 0x10
};

template<bool If, class Then, class Else> struct IF {
	typedef Then RET;
};

template<class Then, class Else> struct IF<false, Then, Else> {
	typedef Else RET;
};

template<class T1, class T2>
struct parameter_traits_ {
	typedef T2 type;
};

template<class T>
struct const_copy_argument {
typedef	typename
	parameter_traits_<
		T,
		typename IF<boost::is_function<T>::value, T&, const T>::RET
	>::type type;
};

// returns a reference to the element of tuple T
template<int N, class T> struct tuple_element_as_reference {
typedef	typename
	boost::tuples::access_traits<
		typename boost::tuples::element<N, T>::type
	>::non_const_type type;
};

template<int N, class Tuple> struct get_element_or_null_type {
typedef	typename
	tuple_element_as_reference<N, Tuple>::type type;
};
template<int N> struct get_element_or_null_type<N, null_type> {
	typedef null_type type;
};

template<int I> struct placeholder;

template<> struct placeholder<FIRST> {

	template<class SigArgs> struct sig {
		typedef	typename get_element_or_null_type<0, SigArgs>::type type;
	};

	template<class RET, CALL_TEMPLATE_ARGS>
	RET call(CALL_FORMAL_ARGS) const {
		BOOST_STATIC_ASSERT(boost::is_reference<RET>::value);
		CALL_USE_ARGS; // does nothing, prevents warnings for unused args
		return a;
	}
};

template<> struct placeholder<SECOND> {

	template<class SigArgs> struct sig {
		typedef	typename get_element_or_null_type<1, SigArgs>::type type;
	};

	template<class RET, CALL_TEMPLATE_ARGS>
	RET call(CALL_FORMAL_ARGS) const {CALL_USE_ARGS; return b;}
};

template<> struct placeholder<THIRD> {

	template<class SigArgs> struct sig {
		typedef	typename get_element_or_null_type<2, SigArgs>::type type;
	};

	template<class RET, CALL_TEMPLATE_ARGS>
	RET call(CALL_FORMAL_ARGS) const {CALL_USE_ARGS; return c;}
};

template<> struct placeholder<EXCEPTION> {

	template<class SigArgs> struct sig {
		typedef	typename get_element_or_null_type<3, SigArgs>::type type;
	};

	template<class RET, CALL_TEMPLATE_ARGS>
	RET call(CALL_FORMAL_ARGS) const {CALL_USE_ARGS; return env;}
};

// select functions -------------------------------
template<class Any, CALL_TEMPLATE_ARGS>
inline Any& select(Any& any, CALL_FORMAL_ARGS) {CALL_USE_ARGS; return any;}

template<class Arg, CALL_TEMPLATE_ARGS>
inline typename Arg::template sig<tuple<CALL_REFERENCE_TYPES> >::type
select ( const lambda_functor<Arg>& op, CALL_FORMAL_ARGS ) {
	return op.template call<
	typename Arg::template sig<tuple<CALL_REFERENCE_TYPES> >::type
>	(CALL_ACTUAL_ARGS);
}
template<class Arg, CALL_TEMPLATE_ARGS>
inline typename Arg::template sig<tuple<CALL_REFERENCE_TYPES> >::type
select ( lambda_functor<Arg>& op, CALL_FORMAL_ARGS) {
	return op.template call<
	typename Arg::template sig<tuple<CALL_REFERENCE_TYPES> >::type
>	(CALL_ACTUAL_ARGS);
}

class plus_action {};
class minus_action {};
class multiply_action {};
class divide_action {};

#define LAMBDA_BINARY_ACTION(SYMBOL, ACTION_CLASS)  					 \
template<class Args>                                                      \
class lambda_functor_base<ACTION_CLASS, Args> {                           \
public:                                                                   \
  Args args;                                                              \
public:                                                                   \
  explicit lambda_functor_base(const Args& a) : args(a) {}                \
                                                                          \
  template<class RET, CALL_TEMPLATE_ARGS>                                 \
  RET call(CALL_FORMAL_ARGS) const {                                      \
    return select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS)  \
           SYMBOL                                                         \
           select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS); \
  }                                                                       \
  template<class SigArgs> struct sig {                                    \
    typedef typename                                                      \
		boost::tuples::element<0,SigArgs>::type type;         			  \
  };                                                                      \
};

LAMBDA_BINARY_ACTION(+,plus_action)
LAMBDA_BINARY_ACTION(-,minus_action)
LAMBDA_BINARY_ACTION(*,multiply_action)
LAMBDA_BINARY_ACTION(/,divide_action)


template<class T>
class lambda_functor: public T {
public:
	typedef T inherited;

	lambda_functor() {}

	lambda_functor(const lambda_functor& l) : inherited(l) {}

	lambda_functor(const T& t) :
		inherited(t) {
	}


	  template<class A>
	  typename inherited::template sig<tuple<A> >::type
	  operator()(A& a) const {
	    return inherited::template call<
	      typename inherited::template sig<tuple<A> >::type
	    >(a, cnull_type(), cnull_type(), cnull_type());
	  }

	  template<class A>
	  LAMBDA_DISABLE_IF_ARRAY1(A, inherited::template sig<tuple<A> >)
	  operator()(A const& a) const {
	    return inherited::template call<
	      typename inherited::template sig<tuple<A> >::type
	    >(a, cnull_type(), cnull_type(), cnull_type());
	  }

	template<class A, class B>
	typename inherited::template sig<tuple<A, B> >::type
	operator()(A& a, B& b) const {
		return inherited::template call<
			typename inherited::template sig<tuple<A, B> >::type
		>(a, b, cnull_type(), cnull_type());
	}

	template<class A, class B>
	LAMBDA_DISABLE_IF_ARRAY2(A, B, inherited::template sig<tuple<A, B> >)
	operator()(A const& a, B& b) const {
		return inherited::template call<
			typename inherited::template sig<tuple<A, B> >::type
		>(a, b, cnull_type(), cnull_type());
	}

	template<class A, class B>
	LAMBDA_DISABLE_IF_ARRAY2(A, B, inherited::template sig<tuple<A, B> >)
	operator()(A& a, B const& b) const {
		return inherited::template call<
			typename inherited::template sig<tuple<A, B> >::type
		>(a, b, cnull_type(), cnull_type());
	}

	template<class A, class B>
	LAMBDA_DISABLE_IF_ARRAY2(A, B, inherited::template sig<tuple<A, B> >)
	operator()(A const& a, B const& b) const {
		return inherited::template call<
			typename inherited::template sig<tuple<A, B> >::type
		>(a, b, cnull_type(), cnull_type());
	}

	template<class A, class B, class C>
	typename inherited::template sig<tuple<A, B, C> >::type
	operator()(A& a, B& b, C& c) const
	{
		return inherited::template call<
			typename inherited::template sig<tuple<A, B, C> >::type
		>(a, b, c, cnull_type());
	}

	template<class A, class B, class C>
	LAMBDA_DISABLE_IF_ARRAY3(A, B, C, inherited::template sig<tuple<A , B , C> >)
	operator()(A const& a, B const& b, C const& c) const
	{
		return inherited::template call<
			typename inherited::template sig<tuple<A , B , C> >::type
		>(a, b, c, cnull_type());
	}
};

#define LAMBDA_BE1(OPER_NAME, ACTION, CONSTA, CONSTB, CONVERSION)      \
template<class Arg, class B>                                                 \
inline const                                                                 \
lambda_functor<                                                              \
  lambda_functor_base<                                                       \
    ACTION,                                                                  \
    tuple<lambda_functor<Arg>, typename const_copy_argument <CONSTB>::type>  \
  >                                                                          \
>                                                                            \
OPER_NAME (const lambda_functor<Arg>& a, CONSTB& b) {                      \
  return                                                                     \
    lambda_functor_base<                                                     \
      ACTION,                                                                \
      tuple<lambda_functor<Arg>, typename const_copy_argument <CONSTB>::type>\
    >                                                                        \
   (tuple<lambda_functor<Arg>, typename const_copy_argument <CONSTB>::type>(a, b)); \
}

#define LAMBDA_BE2(OPER_NAME, ACTION, CONSTA, CONSTB, CONVERSION)      \
template<class A, class Arg>                                                 \
inline const                                                                 \
lambda_functor<                                                              \
  lambda_functor_base<                                                       \
    ACTION,                                                                  \
    tuple<typename CONVERSION <CONSTA>::type, lambda_functor<Arg> >        \
  >                                                                          \
>                                                                            \
OPER_NAME (CONSTA& a, const lambda_functor<Arg>& b) {                      \
  return                                                                     \
    lambda_functor_base<                                                     \
      ACTION,                                                                \
      tuple<typename CONVERSION <CONSTA>::type, lambda_functor<Arg> >      \
    >                                                                        \
  (tuple<typename CONVERSION <CONSTA>::type, lambda_functor<Arg> >(a, b)); \
}

#define LAMBDA_BE3(OPER_NAME, ACTION, CONSTA, CONSTB, CONVERSION)    \
template<class ArgA, class ArgB>                                           \
inline const                                                               \
lambda_functor<                                                            \
  lambda_functor_base<                                                     \
    ACTION,                                                                \
    tuple<lambda_functor<ArgA>, lambda_functor<ArgB> >                     \
  >                                                                        \
>                                                                          \
OPER_NAME (const lambda_functor<ArgA>& a, const lambda_functor<ArgB>& b) { \
  return                                                                   \
    lambda_functor_base<                                                   \
      ACTION,                                                              \
      tuple<lambda_functor<ArgA>, lambda_functor<ArgB> >                   \
    >                                                                      \
  (tuple<lambda_functor<ArgA>, lambda_functor<ArgB> >(a, b));              \
}

#define LAMBDA_BE(OPER_NAME, ACTION, CONSTA, CONSTB, CONST_CONVERSION) 	   \
LAMBDA_BE1(OPER_NAME, ACTION, CONSTA, CONSTB, CONST_CONVERSION)      \
LAMBDA_BE2(OPER_NAME, ACTION, CONSTA, CONSTB, CONST_CONVERSION)      \
LAMBDA_BE3(OPER_NAME, ACTION, CONSTA, CONSTB, CONST_CONVERSION)

LAMBDA_BE(operator+, plus_action,const A,const B,const_copy_argument)
LAMBDA_BE(operator-, minus_action,const A,const B,const_copy_argument)
LAMBDA_BE(operator*, multiply_action,const A,const B,const_copy_argument)
LAMBDA_BE(operator/, divide_action,const A,const B,const_copy_argument)

typedef const lambda_functor<placeholder<FIRST> > placeholder1_type;
typedef const lambda_functor<placeholder<SECOND> > placeholder2_type;
typedef const lambda_functor<placeholder<THIRD> > placeholder3_type;

placeholder1_type free1 = placeholder1_type();
placeholder2_type free2 = placeholder2_type();
placeholder3_type free3 = placeholder3_type();

placeholder1_type& _1 = free1;
placeholder2_type& _2 = free2;
placeholder3_type& _3 = free3;

#endif /* LAMBDA_H_ */

 

 

在深入理解代码之前，我们先来看一下lambda的使用：

 

//============================================================================
// Name        : lambdatest.cpp
// Author      : 
// Version     :
// Copyright   : 
// Description : Test my lambda, Ansi-style
//============================================================================

#include "lambda.h"
#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
using namespace std;

template <class T>
inline void PRINT_ELEMENTS (const T& coll, const char* optcstr="")
{
  typename T::const_iterator pos;
  std::cout << optcstr;
  for (pos=coll.begin(); pos!=coll.end(); ++pos) {
	  std::cout << *pos << ' ';
  }
  std::cout << std::endl;
}


int main() {
	vector<int> intArr;
	intArr.push_back(1);
	intArr.push_back(2);
	intArr.push_back(3);
	intArr.push_back(4);
	intArr.push_back(5);
	//lambda作用于标准库算法
	transform(intArr.begin(),intArr.end(),intArr.begin(),_1*2);
	PRINT_ELEMENTS(intArr);
	//lambda作用于普通运算
	cout<<(_1+_2)(1,2)<<endl;
	return 0;
}

在STL的算法中，我们一般需要自行定义一些仿函数来使用一些算法，而使用lambda库，我们只要使用类似“_1*2”的形式即可使用STL的算法。不妨想象一下，如果我们的lambda库定义了多种多样的运算符，那么我们完全可以省去写仿函数的时间，而直接使用lambda表达式。

好，既然我们都同意lambda库是很有用的，那么现在就来来看看这个小型lambda的实作细则吧o(∩_∩)o ！

直观上看，我们的lambda表达式（如上面的_1*2，_1+_2等）是由占位符和表达式组成的，因此我们可以大胆的推测占位符是一些模版类，而占位符支持+，*之类的运算符是因为这些模版类已经重载了这些运算符。

没错，事实就是这样的。

到源码里去（到祖国的大西部去，口号都是一样的）！

我们看到_1，_2，_3是lambda_functor模板类的三个实例。 而lambda_functor则通过宏定义重载了+-*/四个运算符：

 

LAMBDA_BE(operator+, plus_action,const A,const B,const_copy_argument)
LAMBDA_BE(operator-, minus_action,const A,const B,const_copy_argument)
LAMBDA_BE(operator*, multiply_action,const A,const B,const_copy_argument)
LAMBDA_BE(operator/, divide_action,const A,const B,const_copy_argument)

 

  这么easy啊（看到这里，也许你会觉得不过而而），没你想象的那么简单的，这只是一根语法主线而已，事情还要繁杂的多。

 

型别计算与推演：（这才是重点，important！！！）

一切还是从头来，拿_1+_2举例，我们对于lambda_functor的+运算宏展开之后的定义如下：

 

 

template<class ArgA, class ArgB>                                          
inline const                                                              
lambda_functor<                                                           
  lambda_functor_base<                                                     
    plus_action,                                                               
    tuple<lambda_functor<ArgA>, lambda_functor<ArgB> >                     
  >                                                                        
>                                                                          
operator+ (const lambda_functor<ArgA>& a, const lambda_functor<ArgB>& b) {
  return                                                                  
    lambda_functor_base<                                                  
      plus_action,                                                             
      tuple<lambda_functor<ArgA>, lambda_functor<ArgB> >                 
    >                                                                     
  (tuple<lambda_functor<ArgA>, lambda_functor<ArgB> >(a, b));             
}
 

 

两个参数_1、_2即使参数a和b，加法运算的结果仍然是返回一个lambda_functor对象，我们姑且把这个lambda_functor叫做_0。那么_0(1,2)就是要调用lambda_functor重载的()

运算符了。好，让我们继续前进，我们这里要调用的lambda_functor的方法如下：

 

	template<class A, class B>
	LAMBDA_DISABLE_IF_ARRAY2(A, B, inherited::template sig<tuple<A, B> >)
	operator()(A const& a, B const& b) const {
		return inherited::template call<
			typename inherited::template sig<tuple<A, B> >::type
		>(a, b, cnull_type(), cnull_type());
	}

 lambda_functor的()重载函数继续调用了，其inherited的call函数，这个inherited就我们前面看到的

 

 

lambda_functor_base<                                                     
    plus_action,                                                               
    tuple<lambda_functor<ArgA>, lambda_functor<ArgB> > 
>
 

 

让我们继续展开lambda_functor_base的定义，（是不是快晕了，别着急，马上胜利了^_^）

 

 

template<class Args>                                                      
class lambda_functor_base<plus_action, Args> {                           
public:                                                                   
  Args args;                                                              
public:                                                                  
  explicit lambda_functor_base(const Args& a) : args(a) {}                
                                                                          
  template<class RET, class A, class B, class C, class Env>                                
  RET call(A& a, B& b, C& c, Env& env) const {                                     
    return select(boost::tuples::get<0>(args), a, b, c, env)  
           +
           select(boost::tuples::get<1>(args), a, b, c, env); 
  }                                                                      
  template<class SigArgs> struct sig {                                   
    typedef typename                                                      
		boost::tuples::element<0,SigArgs>::type type;         			
  };                                                                     
};
 

 

看来还要着落在slect函数身上啊：

 

template<class Arg, CALL_TEMPLATE_ARGS>
inline typename Arg::template sig<tuple<CALL_REFERENCE_TYPES> >::type
select ( const lambda_functor<Arg>& op, CALL_FORMAL_ARGS ) {
	return op.template call<
	typename Arg::template sig<tuple<CALL_REFERENCE_TYPES> >::type
>	(CALL_ACTUAL_ARGS);
}
 

 

这里是的op参数是什么呢？ 就是我们上面的_1，这里继续调用了_1的call函数，而_1的的类型定义是这样的：

 

typedef const lambda_functor<placeholder<FIRST> > placeholder1_type;

 

 因此会调用placeholder<FIRST>的call方法：

 

template<> struct placeholder<FIRST> {

	template<class SigArgs> struct sig {
		typedef	typename get_element_or_null_type<0, SigArgs>::type type;
	};

	template<class RET, CALL_TEMPLATE_ARGS>
	RET call(CALL_FORMAL_ARGS) const {
		BOOST_STATIC_ASSERT(boost::is_reference<RET>::value);
		CALL_USE_ARGS; // does nothing, prevents warnings for unused args
		return a;
	}
};
 

 

ok，placeholder<FIRST>为我们选取了第一个参数a，也就是（1,2）中的1。

也就是说_0(1,2)最后将转化成1+2。好了，参数的推演我们已经很清楚了。

再来看先返回值的推演，我为了使得这个lambda库的规模尽可能小，对返回值的推演做了简化，返回值主要是通过sig这个内嵌结构推演出来的。我们看下sig的定义：

template<class SigArgs> struct sig {                                    
    typedef typename                                                      
		boost::tuples::element<0,SigArgs>::type type;         			  
  };
 

在这里我们只是简单的返回了第一个参数的类型。

 

ok，说完了。关于boost的lambda库，我将在后续的文章中陆续详细写明。

 

 

 

 

iteye_16714
关注
专栏目录
【C/C++ 性能优化】了解cpu 从而进行C++ 高效编程
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
02-12 3445
在当代软件开发领域，CPU（Central Processing Unit，中央处理器）的性能优化一直是一个核心议题。尤其是对于C++开发者而言，无论是在Linux平台还是其他操作系统中，都需要深刻理解CPU的工作原理以及如何充分利用CPU资源，以确保软件运行的高效性和稳定性。正如计算机科学家Donald Knuth在《计算机程序设计的艺术》中所说：“过早的优化是万恶之源”，然而，这并不意味着我们应该忽视性能优化——相反，我们需要在正确的时间以正确的方式进行优化。
lambda类型作为模板Concept
For The Lich King
02-11 1239
C++模板需要一个Concept类型作为模板参数传入时，如何用lambda代替代码#include <iostream> #include <cstdlib> #include <memory> #include <string> #include <functional>using namespace std;class go { public: go() {} ~go()
C++ 的lambda 与template结合使用
leexurui的专栏
06-29 5978
int main(){ int result = [](int x) { return x * x; }(10); cout << result << endl; } 打印100 如果要反复用这个简短的表达式，可以存到一个变量func中 int main(){ auto func = [](int x) { return x * x; }; std::cout << func(10
C++11新特性（lambda，可变参数模板，包装器，bind）
m0_61350245的博客
10-13 368
这样看其实也能够很好理解lambda表达式，我们不是嫌弃仿函数自己手动封装类太麻烦了嘛，lambda表达式就是让编译器自动帮我们封装，我们只要把函数的具体实现传过去就可以了，不过lambda表达式的功能比仿函数还是要强大很多的，我们后面慢慢说先看看上面程序的运行结果lambda表达式会自动帮我们推导返回值的类型，所以我们没有在lambda表达式中加上返回值的类型，如果你非想要指定具体的返回值类型，使用表达式中 ->returntype参数。
Lambda库
我的E家
03-02 977
编写很多小的函数对象的缺点： 1，  大量的小类分散在代码中，这样很难进行维护 2，理解函数对象被调用处的代码会很难 Boost.Lambda ： 1】可以创建直接定义和调用的函数对象，或者把它保存起来晚一些再调用； 2】增加了控制结构（使用嵌套的循环结构，把算法表达式写入循环中）、表达式到函数对象的自动转换，还支持在 lambda 表达式中的异常处理 Lambda库优点：
C++特性-lambda表达式
weixin_34764432的博客
04-16 898
lambda表达式基础概念 lambda表达式是c++11新增的一种匿名函数定义的方式，主要的形式是： [capture](para)specifies->returntype{body} capture capture是捕获的外部变量列表，使用逗号分隔，外部变量可以通过传值或者引用。lambda表达式的body和这些外部变量组成闭包，外部变量则成为了这个闭包的成员变量。 比如下面这个lambda表达式经过编译器展开之后就会变成如下形式： int sum = 0; std::vector<in
C++ Template Metaprogramming
01-06
本资源——"C++ Template Metaprogramming"——提供了一个深入探讨这一领域的英文版指南。 模板是C++语言中的一个关键特性，它允许我们定义函数和类的通用模板，然后在不同类型的参数上实例化它们。模板元编程则是...
C++ TEMPLATE
10-03
C++ 模板是编程语言中的一个重要特性，它允许程序员创建泛型代码，即能够处理多种数据类型的代码。模板在 C++ 中分为两种主要类型：函数模板和类模板。 1. **函数模板**： 函数模板是为编写能够处理不同类型参数的...
The connection between C template metaprogramming and functional programming
04-30
本文将深入探讨C++模板元编程（Template Metaprogramming, TMP）与函数式编程（Functional Programming, FP）之间的联系。通过分析博士论文《C++模板元编程与函数式编程的联系》中的内容，我们可以更清晰地理解这两...
C++标准库第二版
08-30
C++11是C++语言的一个重大更新，引入了许多新特性以提升效率和可读性。这些包括： 1. 右值引用（Rvalue References）：用于实现移动语义（Move Semantics），提高对象拷贝和构造的效率。 2. 模板元编程（Template ...
【C++学习】C++11——lambda表达式 | 可变参数模板 | 包装器
weixin_63726869的博客
05-21 1457
介绍了lambda表达式的用法，原理，可变参数模板，以及function包装器和bind绑定函数。
Lambda - 类库
YuanLicc的博客
06-11 380
本文总结、摘录自书籍《Java 8 函数式编程》 系列文章 GitHub地址 类库 基本类型 在 Java 中，有一些相伴的类型，比如 int 和 Integer—— 前者是基本类型，后者是装箱类型。基本类型内建在语言和运行环境中，是基本的程序构建模块；而装箱类型属于普通的 Java 类，只不过是对基本类型的一种封装。 Java 的泛型是基于对泛型参数类型的擦除。这就解释了为什么在 J...
python-lambda，一个无敌的 Python 库！
涛哥聊Python
04-26 713
更多Python学习内容：ipengtao.com大家好，今天为大家分享一个无敌的 Python 库 - python-lambda。Github地址：https://github.com/nficano/python-lambdaAWS Lambda是一种无服务器计算服务，可以让开发者在云端运行代码而无需管理服务器。而python-lambda库则是一款简化AWS Lambda开发的工具，提供了...
C++11 lambda+包装器+可变参数模板
cxy_zjt的博客
11-17 941
lambda表达式 (1).什么是lambda (2).lambda基本规则 (3).lambda实现原理 包装器 可变参数模板
【C++11(二)】lambda表达式和可变参数模板
最新发布
2302_76421042的博客
06-26 1480
C++11的新特性可变参数模板能够让您创建可以接受可变参数的函数模板和类模板参数包是不支持下标解析的。
【代码】C++ template+function+lambda综合示例
gaoyang1213的博客
07-17 131
【代码】C++ template+function+lambda综合示例
[杂记]C++中的lambda函数、可变参数模板
wjpwjpwjp0831的博客
09-19 969
这两个内容没有什么联系, 只是放到一起做一下笔记.
[C++]11版本新特性3：可变参数模板+lambda
cat_with_cat的博客
04-29 888
[C++]11版本新特性3：可变参数模板+lambda
【C++11】lambda表达式
weixin_63449996的博客
06-06 1062
C++11之lambda表达式。
C++11标准库自学教程与参考手册：第二版英文版精华解读
7. **模板元编程**（Template Metaprogramming）：这是C++的一个强大特性，允许在编译时进行计算，提高程序性能。 8. **输入/输出流**：iostream库用于处理输入和输出，包括cout、cin和fstream等，使程序能够与用户...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值