2_9_3 boost库、模板类型参数类型推断、auto类型推断、decltype类型推断

最新推荐文章于 2021-04-21 10:34:15 发布
最新推荐文章于 2021-04-21 10:34:15 发布
阅读量149 收藏
点赞数
分类专栏： C/C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huanghuangjin/article/details/86768389
版权

9_3_boost_类型推断.cpp

#include "hjcommon.hpp"
#include "boost/type_index.hpp"

template<typename T, typename Q>
static void aFunc(T &tvar, const Q &qvar) // 把引用换乘指针，行为是一样的
{
	using boost::typeindex::type_id_with_cvr; // 使用 type_id_with_cvr ，可以得到数据类型或变量的数据类型名称
	std::string TName = ((boost::typeindex::type_index)type_id_with_cvr<T>()).pretty_name();
	std::string QName = ((boost::typeindex::type_index)type_id_with_cvr<Q>()).pretty_name();
	std::string tvarName = ((boost::typeindex::type_index)type_id_with_cvr<decltype(tvar)>()).pretty_name();
	std::string qvarName = ((boost::typeindex::type_index)type_id_with_cvr<decltype(qvar)>()).pretty_name();
	cout << "T=" << TName << ", tvar=" << tvarName << ", Q=" << QName << ", qvar=" << qvarName << endl;
}
template<typename T>
static void bFunc(T &tvar1, const T &tvar2) // 这种情况，当形参既有 T& 又有 const T&， T只会被推断为 int ，所以若实参为 const 类型时，编译器会报错
{
	using boost::typeindex::type_id_with_cvr; // 使用 type_id_with_cvr ，可以得到数据类型或变量的数据类型名称
	std::string TName = ((boost::typeindex::type_index)type_id_with_cvr<T>()).pretty_name();
	std::string tvar1Name = ((boost::typeindex::type_index)type_id_with_cvr<decltype(tvar1)>()).pretty_name();
	std::string tvar2Name = ((boost::typeindex::type_index)type_id_with_cvr<decltype(tvar2)>()).pretty_name();
	cout << "T=" << TName << ", tvar1=" << tvar1Name << ", tvar2=" << tvar2Name << endl;
}
template<typename T>
static void cFunc(T &&tvar) // 万能引用
{
	using boost::typeindex::type_id_with_cvr; // 使用 type_id_with_cvr ，可以得到数据类型或变量的数据类型名称
	std::string TName = ((boost::typeindex::type_index)type_id_with_cvr<T>()).pretty_name();
	std::string tvarName = ((boost::typeindex::type_index)type_id_with_cvr<decltype(tvar)>()).pretty_name();
	cout << "T=" << TName << ", tvar=" << tvarName << endl;
}
template<typename T>
static void dFunc(T tvar) // 传值方式
{
	using boost::typeindex::type_id_with_cvr; // 使用 type_id_with_cvr ，可以得到数据类型或变量的数据类型名称
	std::string TName = ((boost::typeindex::type_index)type_id_with_cvr<T>()).pretty_name();
	std::string tvarName = ((boost::typeindex::type_index)type_id_with_cvr<decltype(tvar)>()).pretty_name();
	cout << "T=" << TName << ", tvar=" << tvarName << endl;
}
template<typename T>
static void eFunc(T &tvar) // 数组
{
	using boost::typeindex::type_id_with_cvr; // 使用 type_id_with_cvr ，可以得到数据类型或变量的数据类型名称
	std::string TName = ((boost::typeindex::type_index)type_id_with_cvr<T>()).pretty_name();
	std::string tvarName = ((boost::typeindex::type_index)type_id_with_cvr<decltype(tvar)>()).pretty_name();
	cout << "T=" << TName << ", tvar=" << tvarName << endl;
}
template<typename T, unsigned len>
static void eeFunc(T (&tvar)[len]) // 数组
{
	using boost::typeindex::type_id_with_cvr; // 使用 type_id_with_cvr ，可以得到数据类型或变量的数据类型名称
	std::string TName = ((boost::typeindex::type_index)type_id_with_cvr<T>()).pretty_name();
	std::string tvarName = ((boost::typeindex::type_index)type_id_with_cvr<decltype(tvar)>()).pretty_name();
	cout << "T=" << TName << ", tvar=" << tvarName << ", len=" << len << endl;
}
static void test() {}
template<typename T>
static void fFunc(T tvar) // 函数名作实参
{
	using boost::typeindex::type_id_with_cvr; // 使用 type_id_with_cvr ，可以得到数据类型或变量的数据类型名称
	std::string TName = ((boost::typeindex::type_index)type_id_with_cvr<T>()).pretty_name();
	std::string tvarName = ((boost::typeindex::type_index)type_id_with_cvr<decltype(tvar)>()).pretty_name();
	cout << "T=" << TName << ", tvar=" << tvarName << endl;
}
template<typename T>
static void gFunc(T &tvar) // 函数名作实参
{
	using boost::typeindex::type_id_with_cvr; // 使用 type_id_with_cvr ，可以得到数据类型或变量的数据类型名称
	std::string TName = ((boost::typeindex::type_index)type_id_with_cvr<T>()).pretty_name();
	std::string tvarName = ((boost::typeindex::type_index)type_id_with_cvr<decltype(tvar)>()).pretty_name();
	cout << "T=" << TName << ", tvar=" << tvarName << endl;
}

int main_2_9_3(int argc, char *argv[])
{
	// boost库：开源，比较悠久
	// boost库下载：https://www.boost.org 解压目录：/usr/local/cpp/boost_1_69_0
		// cd /usr/local/cpp/boost_1_69_0
		// sudo ./bootstrap.sh --prefix=/usr/local/cpp/boost
		// sudo ./b2 install   // 编译需要很久.
			// 最后会在 /usr/local/cpp/boost/ 下生成 include 与 lib 目录
				// 将 /usr/local/cpp/boost/include 添加进eclipse环境变量, 记得还要在 CMakeList.txt 中include该路径,否则编译时会找不到， 链接不需要指定so库?
					// eclipse的环境变量有点问题。。 我直接将 /usr/local/cpp/boost/include/boost 头文件目录复制到了 /usr/local/include 下了。
	int a = 0; long aa = 0;
	const int b = a; const long bb = aa;
	const int &c = 1; const long &cc = 1;
	int &&d = 1; long &&dd = 1;
	const int &&e = 1; const long &&ee = 1;
	cout << "------------------引用与指针---------------------" << endl;
	aFunc(a, aa); // T=int, tvar=int&, Q=long, qvar=long const&
	aFunc(b, bb); // T=int const, tvar=int const&, Q=long, qvar=long const&
	aFunc(c, cc); // T=int const, tvar=int const&, Q=long, qvar=long const&
	aFunc(d, dd); // T=int, tvar=int&, Q=long, qvar=long const&
	aFunc(e, ee); // T=int const, tvar=int const&, Q=long, qvar=long const&

	cout << "-------------------T& 且 const T&--------------------" << endl;
	bFunc(a, a); // 可以
//	bFunc(b, b);  // 这种情况，当形参既有 T& 又有 const T&， T只会被推断为 int ，所以若给实参 T& 传 const 类型时，编译器会报错
//	bFunc(c, c); // 不可以
	bFunc(d, d); // 可以
//	bFunc(e, e); // 不可以

	cout << "------------------万能引用---------------------" << endl;
	cFunc(a); // T=int&, tvar=int&
	cFunc(b); // T=int const&, tvar=int const&
	cFunc(c); // T=int const&, tvar=int const&
	cFunc(d); // T=int&, tvar=int&
	cFunc(e); // T=int const&, tvar=int const&			// 虽然 d与e 是右值，但是当使用 d与e 时，却是被当作左值来使用的。
	cFunc(7); // T=int, tvar=int&&

	cout << "------------------传值方式 T t ---------------------" << endl;
	dFunc(a); // T=int, tvar=int
	dFunc(b); // T=int, tvar=int			// const 属性没有传递进去，也就是函数模板中，参数可以修改
	dFunc(c); // T=int, tvar=int
	dFunc(d); // T=int, tvar=int
	dFunc(e); // T=int, tvar=int
	char f[] = "some";
	const char *g = f;
	const char *const h = g;
	const char i[] = "hi";
	dFunc(f); // T=char *, tvar=char *
	dFunc(g); // T=char const*, tvar=char const*		// 当实参为常指针时，const属性能传递进去一部分
	dFunc(h); // T=char const*, tvar=char const*
	dFunc(i); // T=char const*, tvar=char const*

	cout << "------------------数组---------------------" << endl;
	eFunc(i); // T=char const [3], tvar=char const (&) [3]
	eeFunc(i); // T=char const, tvar=char const (&) [3], len=3      // 数组引用

	cout << "------------------函数名作实参---------------------" << endl;
	fFunc(test); // T=void (*)(), tvar=void (*)()    // 函数指针
	gFunc(test); // T=void (), tvar=void (&)()		 // 函数类型引用

	return 0;
}

9_5_auto.cpp

#include "hjcommon.hpp"
#include "boost/type_index.hpp"

template<typename T>
static void aFunc(T &tvar)
{
	using boost::typeindex::type_id_with_cvr; // 使用 type_id_with_cvr ，可以得到数据类型或变量的数据类型名称
	std::string TName = ((boost::typeindex::type_index)type_id_with_cvr<T>()).pretty_name();
	std::string tvarName = ((boost::typeindex::type_index)type_id_with_cvr<decltype(tvar)>()).pretty_name();
	cout << "T=" << TName << ", tvar=" << tvarName << endl;
}

static auto abc() { return 0; } // c++14，auto可作为函数返回值类型

class A
{
public:
	static const auto m_num = 0; // auto可作为静态成员变量，且必须是const，可以而且必须在类内初始化。。
};

int main_2_9_5()
{
	// auto : auto有类型，auto的变量也有类型，类似于模板类型参数 T
	auto a = 1; // 可以，int
	const auto b = 1;  // 可以，const int
	const auto &c = a; // 可以，const int&
	const auto &d = 1; // 可以，const int&
	auto &&e = 1; // 可以，int&&
//	const auto &&f = a; // 不可以，const右值引用，不能用左值赋
	const auto &&g = 1; // 可以，cosnt int&&

	auto &h = c; // cosnt int& ，auto会丢弃引用属性(引用折叠了)，但不会丢弃const属性
	auto hh = b; // int，同模板参数传值方式一样

	auto i { 30 }; // int
	auto j = { 30 }; // std::initializer_list<int> c++11新数据类型，类模板，表示特定值的数组
	std::string tName = ((boost::typeindex::type_index)boost::typeindex::type_id_with_cvr<decltype(j)>()).pretty_name();
	cout << "tName=" << tName << endl;
	// auto 不能作为函数形参、不能作为非静态成员变量

	return 0;
}

9_6_decltype.cpp

#include "hjcommon.hpp"
#include "boost/type_index.hpp"

class A
{
public:
	int i;
};

static int func()
{
	cout << "func." << endl;
	return 0;
}

int main_2_9_6()
{
	// decltype() c++11，返回操作数的数据类型，同auto一样，编译期间推断。 decltype能保留引用符 & ，decltype类型推导几乎是原封不动的推导出操作数的数据类型
	// decltype 操作数是变量   decltype() 可以声明变量。。
	const int a = 0;
	const int &b = a;
	decltype(a) c = a; // c = const int
	decltype(b) d = a; // d = const int &
	decltype(A::i) e; // int
	A aa;
	decltype(aa.i) f; // int
	auto &&g = a; // int &
	decltype(g) &&h = a; // int & ，引用折叠了

	// decltype 操作数是被表达式
	decltype(2) i = 0; // int
	int j = 0;
	int *pj = &j;
	decltype(*pj) k = i; // int &
	decltype(j) l = j; // int
	decltype( (j) ) m = j; // int & 。。
	int mm = 0;
	decltype(std::move(mm)) dm = 1; // int&& ，按道理 std::move(mm) 也不会真执行。

	// decltype 操作数是函数
	decltype(func()) n = 0; // int ，并不会调用func()函数。 同理 A() 也不会生成 A() 临时对象
	decltype(func) *o = func; // int (void)
	o();

	// decltype 抽取操作数变量类型
	vector<int> vec;
	decltype(vec)::size_type size = vec.size();

	// decltype 用于后置返回函数

	// decltype(auto) c++14 ，可用于前置返回函数，推导 auto 的数据类型
	const int &p = 0;
	decltype(auto) r = p; // const int &

	std::string tName = ((boost::typeindex::type_index)boost::typeindex::type_id_with_cvr<decltype(dm)>()).pretty_name();
	cout << "tName=" << tName << endl;

	return 0;
}
Drunkenman_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
boost::hana::decltype_用法的测试程序
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-09 277
boost::hana::decltype_用法的测试程序实现功能C++实现代码 实现功能 boost::hana::decltype_用法的测试程序 C++实现代码 #include <boost/hana/assert.hpp> #include <boost/hana/equal.hpp> #include <boost/hana/type.hpp> namespace hana = boost::hana; struct X { }; BOOST_HANA_CON
C++ boost库教程（二）：boost数值转换
琅嬛福地
05-04 2655
在STL中有一些列的字符转换函数，例如atoi(), itoa()等，在boost里面只需用一个函数lexical_cast进行转换，lexical_cast是模板方法，使用时需要传入类型。 使用方法： （1）包含头文件 #include <boost/lexical_cast.hpp> （2）命名空间 u...
学习boost模板编程：判断两个类型是否相同
dragonzht的专栏
01-12 3348
boost/type_traits/is_same.hpp中的is_same模板，用于判断两个类型是否完全相同。 首先，试一下下面函数的作用 template bool is_same_tester(T*, T*) { return true; } bool is_same_tester(...) { return false; } int a; char b; bool c = is
boost 中的模板多参数根据N来提取第N个参数的类型 （tuple的实现中用到） tuple的自己的简单实现，仅带get方法
梦想狂奔的专栏
04-01 575
template class cons { typedef T0 head_type; typedef cons tail_type }; template class element { typedef element::type type; }; template class element { typedef HT type; };  
研究学习-C++11/14高级编程+Boost库 ------- 自动类型推导(auto、decltype、decltype(auto))
SmallBottle-CGWLMX的博客
09-27 372
C++11/14新增了两个关键字：auto和decltype。它们可以推导出表达式的类型信息，是非常重要的特性，既可以极大地简化代码，更赋予了程序要原来只属于编译器的无上权力。 1，auto auto可将其用在赋值表达式里声明变量，并在编译器自动推导出表达式的类型。 auto a = 32; 用法如上很简单，有几个注意的地方： 只能用于赋值语句里的类型推导，不能直接声明变量； 总是...
C++11返回类型后置语法的使用示例
08-29
该语法通过auto和decltype结合使用，来实现函数返回值类型的推导。 在C++11之前，使用decltype来推导函数返回值类型存在一定的限制。例如，在下面的例子中，无法直接在函数定义上通过decltype拿到返回值类型： ```...
C++ decltype类型说明符
09-02
C++中的`decltype`是一个强大的类型推断工具，它在C++11标准中被引入，主要服务于泛型编程，解决了模板参数可能导致的复杂类型推断问题。`decltype`操作符允许程序员从表达式中获取其数据类型，但并不实际计算表达式...
cpp代码-无类型参数模板
07-14
C++11引入了类型推断（也称为“自动类型”或“decltype”），使得无类型参数模板更加灵活。当模板参数在函数体内部没有显式使用时，编译器会根据传入的实际参数自动推断类型。例如： ```cpp template void ...
riba2534#MyLearnNotes#decltype类型推导及追踪返回值类型1
07-25
C++11:decltype类型推导及追踪返回值类型使用decltype进行自动类型推导先看一段cppreference上面的解释：decltype 指定符可以
c++11中decltype的妙用
.
11-29 4988
下面是《深入理解c++11》中的部分截图 以下是自己的实现，实用几个宏，实现对多用类成员变量的setter和getter #define GetProperty(Var,VarName) inline auto Get##VarName() const ->decltype(Var) { return Var;} #define SetProperty(Var,Va
C++14尝鲜：decltype 和 decltype(auto)
zwvista的专栏
01-16 1万+
decltype 和 decltype(auto)
decltype和declval的用法
c1s2d3n4cs的博客
03-31 814
1. decltype是c++11以后出现的一个新的关键字，是用来萃取表达式或者变量或者函数返回值的类型的。 具体用法可以参考官网：https://en.cppreference.com/w/cpp/language/decltype 2. declval是c++11中的一个模板函数，原型如下： 具体用法可以参考官网：https://zh.cppreference.com/w/cpp/utility/declval template<classT> typenamestd::add_..
C++——decltype
coco的博客
10-24 877
decltype 类型说明符给定一个指定表达式的类型。 与 auto 关键字一起 decltype 类型说明符，主要，编写模板库的开发人员很有用。 使用 auto ，并声明返回类型的模板函数的 decltype 取决于其模板参数的类型。 或者，使用 auto 和 decltype 声明包装调用另一个模板函数，然后返回该包装函数的返回类型。 demo：与auto联用 decltype预测出返回的...
C++ 03 使用boost::common_type实现C++11的decltype通用类型
zhuge19870104的博客
04-21 255
CMakeLists.txt文件如下 cmake_minimum_required(VERSION 2.6) project(lazy) add_definitions(-std=c++14) include_directories("/usr/local/include") link_directories("/usr/local/lib") file( GLOB APP_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp) foreach( sourcefile ${
decltype
coutamg的博客
04-20 3235
decltype 类似于sizeof操作符，decltype也不需对其操作数求值。粗略来说，decltype(e)返回类型前，进行了如下推导： 1.若表达式e指向一个局部变量、命名空间作用域变量、静态成员变量或函数参数，那么返回类型即为该变量（或参数）的“声明类型”； 2.若e是一个左值（lvalue，即“可寻址值”），则decltype(e)将返回T&，其中T为e的类型；
关注C++细节——C++11新标准之decltype的使用注意
热门推荐
凌风
05-31 1万+
c++11新特性——decltype decltype是C++11添加的一个新的关键字，目的是选择并返回操作数的数据类型，重要的是，在此过程中编译器分析表达式并得到它的类型，却不实际计算表达式的值。 对于内置类型的对象，使用decltype很直观，但当参数为复合类型的时候就应该注意一些使用细节问题。
说明由decltype指定类型和由auto指定类型有何区别。
最新发布
03-26
decltype 根据表达式的类型推断出变量的类型，而 auto 根据变量的初始值的类型推断出变量的类型。 例如： ```cpp int a = 10; auto b = a; // b 的类型为 int decltype(a) c = a; // c 的类型为 int ``` 在上面的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值