1.c++模板&类型

已于 2025-03-25 22:50:16 修改
阅读量481 收藏 20
点赞数 14
分类专栏： c++ 文章标签： c++
于 2025-03-25 17:35:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_38738238/article/details/146508555
版权

模板定义

模板类型

  1. 类型模板

    template <typename T1,typename T2>

  2. 非类型模板

    template <int MAXSIZE=4>

使用方式

模板可以使用在函数定义中或是类的定义中

函数模板

template <typename T1,typename T2>
inline double max(T1 const& a, T2 const& b)
max<int,double>(1,2.0) //使用

如果对于实际的模板类型要区分处理方式，可以使用模板特化，分为局部特化和全局特化

  1. 局部特化
    局部特化是指定部分模板类型的实际类型
    template <typename T>
inline double max(T const& a, T const& b)
max<int,int>(1,2) //使用
  2. 全局特化
    全局特化是指定全部模板类型的实际类型
    template <>
inline double max(double const& a, double const& b)
max<double,double>(1.0,2.0)  //使用

类模板

template <typename T1,typename T2>
class Clazz
Clazz<long,int> clazz; //使用

如果对于实际的模板类型要区分处理方式，可以使用模板特化，分为局部特化和全局特化

  1. 局部特化
    局部特化是指定部分模板类型的实际类型
    template <typename T1>
class Clazz<T1,T1>
Clazz<long,long> clazz;//使用
  2. 全局特化
    全局特化是指定全部模板类型的实际类型
    template <>
class Clazz<int>
Clazz<int,int> clazz;//使用

类型

类型声明

  1. typedef X;
  2. using x=typename T表达式

类型使用

类型用来定义变量： T x;;

类型修改

类型修改后还是类型

  1. typename std::remove_reference<T>::type

    修改前修改后
    T& 或 T&&T

  2. typename std::decay<T>::type

    修改前修改后
    T& 或 T&&T
    const T 或 volatile TT
    T[N]T*
    T() (函数类型)T(*)(...)

  3. typename std::remove_cv<T>::type

    修改前修改后
    const T 或 volatile TT

类型测试

  1. typeid

    std::typeinfo &type=typeid(变量|typename T)) //使用方法

    type.name();

  2. std::is_lvalue_reference<typename T>::value

    判断类型是否是左值引用

  3. std::is_rvalue_reference<typename T>::value

    判断类型是否是右值引用

  4. std::is_const<typename T>::value

    判断类型是否为常量

  5. std::is_same<typename T1, typename T2>::value

    判断两个类型是否一致

变量类型预测

  1. auto
    auto 变量=表达式;//使用方法
    auto 会去除表达式的const属性
    auto & 不会去除表达式的const属性

  2. decltype
    decltype(变量); //使用方法，decltype(变量1) 返回的是一个 typename，也就是一个类型

参数类型预测

template <typename T1>
void checkType(T1 &&a)
{
        std::string typeids = typeid(T1).name();
        std::cout << "type=" << typeid(a).name()
                    << " is lvalue reference=" << std::is_lvalue_reference<decltype(a)>::value
                    << " is rvalue reference=" << std::is_rvalue_reference<decltype(a)>::value
                    << " is const=" << std::is_const<decltype(a)>::value
                    << std::endl;
        auto a1 = a;
        decltype(a) a2 = a;
        // T1 a2=a;
        typename std::remove_reference<T1>::type a3 = a;
        typename std::decay<T1>::type a4 = a;
        typename std::remove_cv<T1>::type a5 = a;

        std::cout << "auto type=" << typeid(a1).name()
                    << " is lvalue reference=" << std::is_lvalue_reference<decltype(a1)>::value
                    << " is rvalue reference=" << std::is_rvalue_reference<decltype(a1)>::value
                    << " is const=" << std::is_const<decltype(a1)>::value
                    << std::endl;
        std::cout << "decltype type=" << typeid(a2).name()
                    << " is lvalue reference=" << std::is_lvalue_reference<decltype(a2)>::value
                    << " is rvalue reference=" << std::is_rvalue_reference<decltype(a2)>::value
                    << " is const=" << std::is_const<decltype(a2)>::value
                    << std::endl;
        std::cout << "remove_reference type=" << typeid(a3).name()
            	    << " is lvalue reference=" << std::is_lvalue_reference<decltype(a3)>::value
                    << " is rvalue reference=" << std::is_rvalue_reference<decltype(a3)>::value
                    << " is const=" << std::is_const<decltype(a3)>::value
                    << std::endl;
        std::cout << "decay type=" << typeid(a4).name()
                    << " is lvalue reference=" << std::is_lvalue_reference<decltype(a4)>::value
                    << " is rvalue reference=" << std::is_rvalue_reference<decltype(a4)>::value
                    << " is const=" << std::is_const<decltype(a4)>::value
                    << std::endl;
        std::cout << "remove_cv type=" << typeid(a5).name()
                    << " is lvalue reference=" << std::is_lvalue_reference<decltype(a5)>::value
                    << " is rvalue reference=" << std::is_rvalue_reference<decltype(a5)>::value
                    << " is const=" << std::is_const<decltype(a5)>::value
                    << std::endl;
}
  1. 指定模板类型
    long a=1;checkType<long &>(a) //指定T1为long&，根据引用折叠，参数类型是long & &&必须使用左值赋值
checkType<long>(1) //指定T1为long，根据引用折叠，参数类型是long  &&必须使用右值赋值
checkType<long&&>(1) //指定T1为long&&，根据引用折叠，参数类型是long&& &&必须使用右值赋值
  2. 根据实际类型预测模板类型
    long a=1;checkType(a);//不指定T1,传入是左值类型，说明T1 &&为左值引用，根据引用折叠规则，预测T1为long&
checkType(1);//不指定T1,传入是右值类型，说明T1 &&为右值引用，根据引用折叠规则，预测T1为long&&

引用折叠规则在《左值和右值》中介绍

可变参数类型预测

template <typename RetType, typename... ArgsType>
int emitEvent( ArgsType &&...args)
{
	    //1.使用std::forward_as_tuple将参数列表转化成tuple对象，然后使用apply遍历tuple每个参数并用decltype预测变量类型
        std::tuple<std::decay_t<ArgsType>...> t = std::forward_as_tuple(std::forward<ArgsType>(args)...);
        std::apply([](auto&&... args){
                ((std::cout << typeid(decltype(args)).name() << ", "), ...);
        },t);
	
        //2.使用std::tuple将类型列表转化成类型元素的tuple对象，使用tuple_element获取tuple对象指定位置的类型元素
        std::cout <<typeid(typename std::tuple_element<0, std::tuple<ArgsType...> >::type).name()<< ", ";
        std::cout <<typeid(typename std::tuple_element<1, std::tuple<ArgsType...> >::type).name(); 
        return 1;
}

函数类型预测

构造函数类型

因为有时候函数会传入返回类型和参数类型，所以需要使用返回类型和参数类型构造函数类型

 typedef Ret function_type(Args...); //获取普通函数类型
 using stl_function_type = std::function<function_type>;//获取std::function类型
 typedef Ret(*pointer)(Args...);//获取函数指针类型

获取函数参数和函数返回值类型

#ifndef SRC_UTIL_FUNCTION_TRAITS_H_
#define SRC_UTIL_FUNCTION_TRAITS_H_

#include <tuple>
#include <functional>


namespace toolkit {

template<typename T>  //原始模板T
struct function_traits;

//普通函数  [AUTO-TRANSLATED:569a9de3]
//将类型T特化成普通函数类型Ret(Args)
template<typename Ret, typename... Args>
struct function_traits<Ret(Args...)> 
{
public:
    enum { arity = sizeof...(Args) }; //获取参数个数
    typedef Ret function_type(Args...); //获取普通函数类型
    typedef Ret return_type; //获取返回类型
    using stl_function_type = std::function<function_type>;//获取std::function类型
    typedef Ret(*pointer)(Args...);//获取函数指针类型

    template<size_t I>
    struct args
    {
        static_assert(I < arity, "index is out of range, index must less than sizeof Args");
        using type = typename std::tuple_element<I, std::tuple<Args...> >::type; //获取第I个参数的类型
    };
};

//函数指针  [AUTO-TRANSLATED:bc15033e]
//将类型T特化成函数指针类型Ret(*)(Args),同时继承普通函数类型，最后收束到普通函数类型处理
template<typename Ret, typename... Args>
struct function_traits<Ret(*)(Args...)> : function_traits<Ret(Args...)>{};

//std::function
//将类型T特化成std::function类型,同时继承普通函数类型，最后收束到普通函数类型处理
template <typename Ret, typename... Args>
struct function_traits<std::function<Ret(Args...)>> : function_traits<Ret(Args...)>{};

//member function
//将类型T特化成类的成员函数类型，同时继承普通函数类型，最后收束到普通函数类型处理
#define FUNCTION_TRAITS(...) \
    template <typename ReturnType, typename ClassType, typename... Args>\
    struct function_traits<ReturnType(ClassType::*)(Args...) __VA_ARGS__> : function_traits<ReturnType(Args...)>{}; \

FUNCTION_TRAITS()
FUNCTION_TRAITS(const) 
FUNCTION_TRAITS(volatile)
FUNCTION_TRAITS(const volatile)

//函数对象  [AUTO-TRANSLATED:a0091563]
//将类型T特化成函数对象类型,同时继承普通函数类型，最后收束到普通函数类型处理
template<typename Callable>
struct function_traits : function_traits<decltype(&Callable::operator())>{};

} /* namespace toolkit */

#endif /* SRC_UTIL_FUNCTION_TRAITS_H_ */

工具使用方法：

template <typename FUNC>
//func可以传入
/**
1.普通函数类型
2.函数指针类型
3.std::function类型
4.类的成员函数
5.函数对象
*/
void addListener(FUNC &&func)
{
	    //参数个数
        std::cout << "argc " << toolkit::function_traits<typename std::remove_reference<FUNC>::type>::arity << std::endl;
		//参数类型
        std::cout << "arg0 " << " " << typeid(typename toolkit::function_traits<typename std::remove_reference<FUNC>::type>::args<0>::type).name()<< std::endl;
        std::cout << "arg1 " << " " << typeid(typename toolkit::function_traits<typename std::remove_reference<FUNC>::type>::args<1>::type).name()<< std::endl;
		//返回类型
        std::cout << "ret " << typeid(typename toolkit::function_traits<typename std::remove_reference<FUNC>::type>::return_type).name()<< std::endl;
		//函数类型
        std::cout << "std::function " << typeid(typename toolkit::function_traits<typename std::remove_reference<FUNC>::type>::stl_function_type).name()<< std::endl;
        std::cout << "function " << typeid(typename toolkit::function_traits<typename std::remove_reference<FUNC>::type>::function_type).name()<< std::endl;
        std::cout << "function pointer " << typeid(typename toolkit::function_traits<typename std::remove_reference<FUNC>::type>::pointer).name()<< std::endl;
}

addListener([](int x, long y) -> int{ return 1; });
c++模板重载用自定义特定类型定义模板（三）
cfl997
11-19 8148
这里有C++STL——全面总结详细教程（附案例解析）（持续更新中） 利用具体化的模板，可以解决自定义类型的通用化 用普通和Person类模板进行对比。 #include&lt;iostream&gt; #include&lt;string&gt; using namespace std; //定义类 class Person { public: Person(string name,...
C++类模板
希望我的博客，能帮上你解决学习中工作中所遇到的问题
11-09 1344
类模板 1.3.1 类模板语法 类模板作用： 建立一个通用类，类中的成员 数据类型可以不具体制定，用一个虚拟的类型来代表。 语法： template&lt;typename T&gt; 类 解释： template — 声明创建模板 typename — 表面其后面的符号是一种数据类型，可以用class代替 T — 通用的数据类型，名称可以替换，通常为大写字母 示例： #include &lt;string&gt; //类模板 template&lt;class NameType, c
C++模板学习(二）
Zu_Zhi的博客
03-21 332
模板的注意事项： 自动类型推导，必须推导出一致的数据类型T,才可以使用 模板必须要确定出T的数据类型，才可以使用 template&lt;typename T&gt; void myswap(T&amp; a, T&amp; b) { T temp = a; a = b; b = temp; } void test() { int a = 10; int b = 20; char c = 'a'; myswap(a, c); cout &lt;&lt; "a= " &lt;&lt; a &
C++模板
好好学习，天天向上
04-29 1574
C++模板
C++模板----限制模板只能某些已知类型进行实例化
FAS ------ 一颗好奇心，一页好代码！
06-30 9147
可能有时候我们需要限定我们所编写的模板的应用范围，我们可以通过下面的方式实现.实现一个模板只能定义应于特定的几种类型
C++ - 泛性编程类模板的特定实现
weixin_49303682的博客
08-17 548
1.多参数类模板 类模板可以定义任意多个不同的类型参数： 函数模板也可以支持多个不同类型参数。 使用类模板必须一一指定类型，函数模板可以不用。 2.类模板可以被特化 指定类模板的特定实现。 部分类型参数必须显示指定。 根据类型参数分开实现类模板。 特殊化为只接受一个类型(T1和T2类型相同)。在指定实际类型时，如果T1和T2类型相同，编译器会优先使用右边的模板。编译器会根据实际情况分析使用左边或者右边。编译器认为这两个模板是同一个，在使用的时候会根据参数进行选择使用。 部.
c++&amp;模板函数&amp;&amp;可变参数模板&amp;消息中间件
11-03
在C++中，模板函数是一种泛型编程技术，允许程序员编写可以处理多种数据类型的通用函数。模板定义了函数或类的通用蓝图，而不是具体实现。当模板被实例化时，编译器会为每种不同的类型生成特定的代码。这样，我们就...
24. C++模板 2 (非类型模板参数，模板的特化与模板的分离编译)
yzc的博客
12-15 1334
C++模板的特化，分离编译与非类型模板参数详解
C++类模板&amp;&amp;容器&amp;&amp;重载
06-10
类模板是C++中的一个关键特性，它允许我们创建泛型类，也就是可以处理不同类型数据的类。类模板定义了类的一般结构，但不包含具体的类型。当你实例化模板时，你可以提供具体的类型参数，这样编译器就会生成一个特定...
C++11 &amp; C++14 &amp; C++17.rar
02-25
1. **自动类型推断（Auto关键字）**：C++11引入了`auto`关键字，它允许编译器根据初始化表达式自动推断变量的类型，简化了代码并减少了错误。 2. **右值引用（Rvalue References）**：右值引用是C++11的一个核心...
【C++】详解模板类型推导
Friday
10-15 945
从这样的角度来看，C++的模板类型推导毫无疑问取得了巨大的成功：成百上千的程序员都在向函数模板传递实参，并拿到了完全满意的结果，而其中鲜有人能够将类型推导的过程阐述出来。依照按值传递形参的类型推导规则，此时ptr的const性会被忽略，param被推导成const char*,即一个指向可以改变的，指向一个const字符串的指针（或者说顶层const在值传递的过程中被消除），在推导过程中，ptr指向对象的常量性会被保留，但自身的常量性被忽略。在这种情况下，T的类型会被推导成实际的数组类型！
c++中的模板
weixin_67624792的博客
12-06 453
告诉编译器开始创建模板：可以替代成class: 通用数据类型。
C++模板（模板的类型、模板的特化、可变参数模板）
laimaxgg
12-12 828
c语言有可变参数函数（如printf()），c++11将可变参数扩展到了模板上，称为可变参数模板。可变参数模板会在编译阶段解析并展开可变参数的类型，其最终的样貌仍是一般的函数。可变模板参数在使用时...的位置比较多变，需要注意。;//……但需要注意的是，sizeof在使用在可变参数模板上时，不可用于运行时方式。即不可在for循环中使用来作为判断循环的条件。//注意...的位置int main()return 0;模板本质上是把实例化的类型的工作交给编译器，这个过程是在编译的时候完成的。
【C++】函数模板（template）
mjiansun的专栏
11-29 2802
目录 函数模板的定义 函数模板的使用 函数模板就是可以自动更改数据类型。 函数模板的定义 定义一个模板，能够适应多种类型。 语法规则： template &amp;lt;typename T&amp;gt; T findmax (T arr[], int len) { T val = arr[0]; ... } （1）算法相同； （2）元素类型不同，用T代替。 函数模板的...
C++ --- 模板
最新发布
2401_85214846的博客
05-10 1500
本文讲述的是C++模板，涉及模板分类，模板实例化，模板的使用。
C++中模板类型(下)
超级霸霸强的博客
11-14 1209
C++中模板类型(下) 类模板的继承 类模板成员函数类内实现 在类模板的继承中，我们必须像如下程序一样，在子类中给予父类模板数据类型，使得当定义子类对象时，从父类继承过来的拿一部分可以给予确定的内存空间。 #include&lt;iostream&gt; #include&lt;string&gt; usingnamespacestd; template&lt;classT1&gt; classPerson { public: T1age;...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值