---

author: hjjdebug
date: 2025年 05月 21日 星期三 12:51:57 CST
descrip: remove_const的工作原理及c++的类型推导

---

std::remove_const的工作原理及c++的类型推导

1. 简单的程序代码.

$ cat main.cpp
#include <stdio.h>
#include <type_traits>
int main() 
{std::remove_const_t<const int> n = 3;  //与其这样写，为什么不直接写 int n=3 ?printf("n:%d\n",n);std::remove_const<const double>::type x=6.0;printf("x:%f\n",x);return 0;
}

执行结果:
$ ./tt
n:3
x:6.000000

预处理后的代码: 除了去掉注释,跟源码没什么变化.没得到有用信息
int main()
{
std::remove_const_t n = 3;
printf(“n:%d\n”,n);
std::remove_const::type x=6.0;
printf(“x:%f\n”,x);
return 0;
}
反汇编的代码: 可推断n是整形,x是浮点型或double型,知道类型确实是正确的,但太不直观了.
int main()
{
401136: f3 0f 1e fa endbr64
40113a: 55 push %rbp
40113b: 48 89 e5 mov %rsp,%rbp
40113e: 48 83 ec 10 sub $0x10,%rsp
std::remove_const_t n = 3;
401142: c7 45 f4 03 00 00 00 movl $0x3,-0xc(%rbp) //-0x3(%rbp) 是n变量
//与其这样写，为什么不直接写 int n=3 ?
printf(“n:%d\n”,n);
401149: 8b 45 f4 mov -0xc(%rbp),%eax
40114c: 89 c6 mov %eax,%esi # n是第2参数
40114e: 48 8d 3d b3 0e 00 00 lea 0xeb3(%rip),%rdi # 字符串是第一参数
401155: b8 00 00 00 00 mov $0x0,%eax
40115a: e8 e1 fe ff ff callq 401040 printf@plt # 调用printf@plt
std::remove_const::type x=6.0;
40115f: f2 0f 10 05 b1 0e 00 movsd 0xeb1(%rip),%xmm0
401166: 00
401167: f2 0f 11 45 f8 movsd %xmm0,-0x8(%rbp) # -0x8(rbp)是x变量
printf(“x:%f\n”,x);
40116c: 48 8b 45 f8 mov -0x8(%rbp),%rax
401170: 66 48 0f 6e c0 movq %rax,%xmm0 #xmm0 是第2参数(浮点数)
401175: 48 8d 3d 92 0e 00 00 lea 0xe92(%rip),%rdi #字符串rdi是第一参数
40117c: b8 01 00 00 00 mov $0x1,%eax
401181: e8 ba fe ff ff callq 401040 printf@plt
return 0;
401186: b8 00 00 00 00 mov $0x0,%eax
}
看main.o 的符号信息，毛都没有.
$ nm main.o
U GLOBAL_OFFSET_TABLE
0000000000000000 T main
U printf

我们知道,它把std::remove_const_t<const int> 翻译成了 int
其写法std::remove_const_t<const int> n = 3; 完全等价于 int n=3;
这里第一个问题是, 为什么我们不直接写 int n=3; ?
如果直接给整形变量赋值,当然写int n=3, 我用c写代码这么多年, 也从没见谁用std::remove_const_t<const int>来代替int 的写法.

这是我在c++中看到了一个类型推导语句, 在模板类编程中,类型可以是参数, 对传递来的类型，可能要进行变换.
类型推导就是在这样的环境下发生的. 我也是第一次在c++上看到了类型推导,原来类型还可以这么玩!
测试代码是最简单的例子. const int 去掉const 是什么类型？傻子都知道是int 类型。
但关键是,电脑是怎么知道的？ 这里的电脑,实际指的是gcc编译器.

2.std::remove_const_t 到底是怎样工作的？

欧式几何学从5个公设出发,推出几百个定理.
c++也只是遵从几条编译规则, 它怎么会认识std::remove_const_t<const int> 这个修饰词？
而且把它等价翻译成 int.
可惜的是,我们预处理了源代码，反编译了执行代码，查看了obj文件符号,只知道它变成了int, 但不知道它
是根据什么规则来变化的.
想搞清这个问题, 方法就是去掉库代码<type_traits> 自己写std::remove_const_t 代码.
下面我直接给出测试代码, 这是我阅读<type_traits> 及查找网络得到的. 然后解释它的工作原理.
代码也还算简单:

2.1 测试代码

$ cat main.cpp
#include <stdio.h>
namespace std 
{template <class T>struct remove_const {typedef T type;};template <class T>struct remove_const<const T> {typedef T type;};template <typename T>using remove_const_t = typename std::remove_const<T>::type; //需要加上typename
}int main() 
{std::remove_const_t<const int> n = 3;  printf("n:%d\n",n);std::remove_const<const double>::type x=6.0;printf("x:%f\n",x);return 0;
}

代码不用<type_trait>, 自己写也能编译通过，运行结果相同.
只是预处理,查符号仍然找不到任何踪迹，但看反汇编代码已经都处理好了.
那么我们就先分析模板代码吧.
std 是个命名空间.
remove_const_t 实际上是一个类型 “std::remove_const<T>::type” 的小名
using 的用法与typedef 的用法类似, 是c++11 新扩充的关键词.
这里用using A = typename B 为B类型指明小名A

remove_const<T> 是一个类模板,它定义为:
template <class T>
struct remove_const{ typedef T type;} //type 就是 T 的小名,名称转换

它还有一个const 的特化版本, 定义为:
template <class T>
struct remove_const<const T> {typedef T type;}
特化版本会优先匹配带const 修饰的类型, 它定义的type 把const 给去掉了.
去掉const 就是匹配了这个类模板，重定义了T 为type

ok! 模板代码大体搞懂了，那就看看怎么调用吧.
std::remove_const_t<const int>这是个using 定义的小名, 等价于 std::remove_const<const int>::type
std::remove_const<const int>是一个类,它里边定义的type就是传来的参数类型(模板类定义的),
即 typedef int type
这个type 从外边看，其全名是std::remove_const<const int>::type, 所以模板类中定义了
typedef int std::remove_const<const int>::type
那现在书写了 std::remove_const<const int>::type n=3, 当然就等于 int n=3了.
原来前边的一大堆乱七八糟的字符串,用typedef被定义成 int 的小名了. 这就是这个长字符串的本质意义.

同样的,std::remove_const<const double>::type 这个长字符串
在模板类中是这样定义的 typedef double std::remove_const<const double>::type
现在你倒过来用: std::remove_const<const double>::type x=6.0; 就等价于 double x=6.0

从前面那个长字符串,被重定义为输入参数类型, 看起来像类型推导过程,
给一个类型得到另一个类型,也可以称类型萃取.

分析通了, 但是总觉得不塌实, 因为这都是gcc 干的, 干的还挺多.
能不能让我们跟踪一下，调试一下,看看执行的过程?

2.2 类型推导的调试手段.

2.2.1 给类模板添加成员函数,让它打印信息,然后实例化一个类,通过打印信息判断到底走了哪个实例化代码.

测试例子就不给了,节省篇幅,仅提供一个思路.

2.2.2 用typeid(type).name() 来打印类型名称.

关于typeid的用法，请参考例如:https://blog.csdn.net/hejinjing_tom_com/article/details/148063802?spm=1001.2014.3001.5501

2.2.3 用is_same_v 来判断

std::is_same_v是C++17引入的一个模板变量, 用于在编译时检查两个类型是否相同.
它是std::is_same的简化版本，直接返回一个布尔值（true或false）,表示两个类型是否相同
std::is_same_v<T, U>会检查类型T和U是否相同。如果T和U是相同的类型，则返回true；否则返回false
使用举例:

$ cat main.cpp
#include <stdio.h>
#include <type_traits>
using namespace std;
int main() 
{bool res=is_same_v<int,int>; //把bool 数值直接放这printf("int,int compare result:%d\n",res);res=is_same_v<int,const int>;printf("int,const int compare result:%d\n",res);res=is_same_v<int,float>;printf("int,float compare result:%d\n",res);return 0;
}

执行结果:
$ ./tt
int,int compare result:1
int,const int compare result:0
int,float compare result:0

但我却对is_same_v<T,U>的实现过程更感兴趣, 它是怎样工作的呢？
网络上讲 std::is_same_v<T, U>的工作原理基于模板编程, 没下文了, 要继续探讨模板编程才好啊.
还是从<type_traits> 上扣代码吧. 其实很简单!!
为了防止符号走型，把它放到代码块中说明.

//这是ubuntu20  gcc 9.4 下<type_traits>的实现
// 主模板template<typename _Tp, typename _Up>struct is_same: public false_type { };// 特化版本template<typename _Tp>struct is_same<_Tp, _Tp>: public true_type { };// is_same_v 是简化书写版
template <typename _Tp, typename _Up>inline constexpr bool is_same_v = is_same<_Tp, _Up>::value;//true_type, false_type 定义typedef integral_constant<bool, true> true_type;typedef integral_constant<bool, false> false_type;//integral_constant 定义 //整形常数类模板template<typename _Tp, _Tp __v>struct integral_constant{ //true_type的value就是true,false_type的value就是fase,整数类型的value就是你存进来的值static constexpr _Tp value = __v;  //定义了value 变量，保留了参数值给valuetypedef _Tp value_type;typedef integral_constant<_Tp, __v> type;constexpr operator value_type() const noexcept { return value; }constexpr value_type operator()() const noexcept { return value; }};

不能调试用眼睛读的代码也就这么多了，再多了就没法理解了.
gcc 9.4 的实现方法基于整形常数模板. 稍微复杂些
测试代码我们采用一种简化写法吧,就不继承谁了,直接给结果.
跟gcc的效果一致，更容易理解

2.2.4 is_same<T,U> 模板实现代码及测试

源代码:

$ cat main.cpp
#include <stdio.h>
//#include <type_traits>
namespace std 
{/// remove_const 代码 /template <class T>struct remove_const {typedef T type;};template <class T>struct remove_const<const T> {typedef T type;};template <typename T>using remove_const_t = typename std::remove_const<T>::type; //注意加上typename is_same 代码 //// 主模板, 类型不同走这里template<typename T, typename U>struct is_same {static constexpr bool value = false;};// 特化版本, 类型相同走这里template<typename T>struct is_same<T, T> {static constexpr bool value = true;};// C++17简化版, 返回一个类常量(bool值)template<typename T, typename U>inline constexpr bool is_same_v = is_same<T, U>::value;
}int main() 
{std::remove_const_t<const int> n = 3;  bool res=std::is_same_v<std::remove_const_t<const int>, int>;printf("res:%d,n:%d\n",res,n);std::remove_const<const double>::type x=6.0;printf("x:%f\n",x);return 0;
}

反编译
bool res=std::is_same_v<std::remove_const_t, int>;
401149: c6 45 f3 01 movb $0x1,-0xd(%rbp)
直接把1(true)付给了变量 res;

是否相同的判别是通过编译器创建不同的模板类来确定的,而创建哪个模板类是编译器根据模板参数确定的.
而模板类型参数是我们直接传递的, 有可能是基本类型，有可能是推导类型, 推导类型最后还得变成基本类型,
这样最终还是通过编译器汇编时期的判断确定是相同类型或不同类型.
不过知道了这个工作原理,我们可以大胆的用is_same_v 来判别两个类型是否相同了.

3. 小结:

std::remove_const_t typedef为 std::remove_const::type
而模板类中又typedef int std::remove_const::type, 所以说
std::remove_const::type 等价于int， 是int的小名,由typedef 定义的.
实际推导的过程是用模板类匹配类型参数, 把类型参数重新typedef一下.

is_same_v(T,U)的判断更加简单, 也是根据模板类型匹配, T,U为同一类型,返回true, 否则返回false
值得一提的是c++更加注重gcc 的编译过程了.