CPP 核心编程8-模板

最新推荐文章于 2024-04-30 00:03:35 发布
最新推荐文章于 2024-04-30 00:03:35 发布
阅读量363 收藏 1
点赞数 1
分类专栏： c++ 文章标签： c++ 开发语言 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wade1010/article/details/128192027
版权

CPP 核心编程8-模板

C++另一种编程思想称为 泛型编程 ，主要利用的技术就是模板

C++提供两种模板机制:函数模板和类模板

函数模板作用：

建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来代表。

语法：

template<typename T>
函数声明或定义

解释：

template --- 声明创建模板

typename --- 表面其后面的符号是一种数据类型，可以用class代替

T --- 通用的数据类型，名称可以替换，通常为大写字母

#include "iostream"

using namespace std;
void mySwap(int &a, int &b)
{
    int temp = a;
    a = b;
    b = temp;
}
void mySwap(double &a, double &b)
{
    double temp = a;
    a = b;
    b = temp;
}
//利用模板提供通用的交换函数
template <typename T>
void myTSwap(T &a, T &b)
{
    T temp = a;
    a = b;
    b = temp;
}
void test()
{
    int a = 10;
    int b = 20;
    mySwap(a, b);
    cout << a << endl;
    cout << b << endl;
    double c = 10.2;
    double d = 20.3;
    mySwap(c, d);
    cout << c << endl;
    cout << d << endl;
}
void test2()
{
    char a = 'a';
    char b = 'b';
    // 1 自动类型推导
    myTSwap(a, b);
    cout << a << " " << b << endl;
    // 2 显示指定类型
    int c = 100;
    int d = 200;
    myTSwap<int>(c, d);
    cout << c << " " << d << endl;
}

int main()
{
    test();
    test2();
    return 0;
}

总结：

  • 函数模板利用关键字 template
  • 使用函数模板有两种方式：自动类型推导、显示指定类型
  • 模板的目的是为了提高复用性，将类型参数化

1.2.2 函数模板注意事项

注意事项：

  • 自动类型推导，必须推导出一致的数据类型T,才可以使用
  • 模板必须要确定出T的数据类型，才可以使用
#include "iostream"

using namespace std;
template <typename T>
void mySwap(T &a, T &b)
{
    T temp = a;
    a = b;
    b = temp;
}
// 1、自动类型推导，必须推导出一致的数据类型T,才可以使用
void test()
{
    int a = 10;
    int b = 20;
    char c = 'c';
    mySwap(a, b); //正确,可以推导出一致的T
    // mySwap(a, c); //错误,推导不出一致的T
}

// 2、模板必须要确定出T的数据类型，才可以使用
template <class T>
void func()
{
    cout << "func call" << endl;
}

void test1()
{
    // func();//错误 模板不能独立使用,必须确定出T的类型
    func<int>();    //利用显示置顶烈性的方式,给T一个类型,才可以使用改=该模板
    func<double>(); //也可以
}
int main()
{
    test();
    test1();
    return 0;
}

总结：

  • 使用模板时必须确定出通用数据类型T，并且能够推导出一致的类型

1.2.3 函数模板案例

案例描述：

  • 利用函数模板封装一个排序的函数，可以对不同数据类型数组进行排序
  • 排序规则从大到小，排序算法为选择排序
  • 分别利用char数组和int数组进行测试
#include "iostream"

using namespace std;
template <class T>
void mySort(T arr[], int len)
{
    for (int i = 0; i < len; i++)
    {
        int maxIndex = i;
        for (int j = i + 1; j < len; j++)
        {
            if (arr[maxIndex] < arr[j])
            {
                maxIndex = j;
            }
        }
        if (maxIndex != i)
        {
            T temp = arr[maxIndex];
            arr[maxIndex] = arr[i];
            arr[i] = temp;
        }
    }
}
template <class T>
void printArray(T arr[], int len)
{
    for (int i = 0; i < len; i++)
    {
        cout << arr[i] << " ";
    }
    cout << endl;
}
void test1()
{
    int arr[] = {32, 3243, 45, 564, 657, 23, 2};
    int len = sizeof(arr) / sizeof(arr[0]);
    mySort(arr, len);
    printArray(arr, len);
}
void test2()
{
    char arr[] = "qwefrhsb";
    int len = sizeof(arr) / sizeof(arr[0]);
    mySort(arr, len);
    printArray(arr, len);
}
int main()
{
    test1();
    test2();
    return 0;
}

总结：模板可以提高代码复用，需要熟练掌握

1.2.4 普通函数与函数模板的区别

普通函数与函数模板区别：

  • 普通函数调用时可以发生自动类型转换（隐式类型转换）
  • 函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换
  • 如果利用显示指定类型的方式，可以发生隐式类型转换
#include "iostream"

using namespace std;
//普通函数
int myAdd01(int a, int b)
{
    return a + b;
}
//函数模板
template <typename T>
T myAdd02(T a, T b)
{
    return a + b;
}
//使用函数模板时,如果用自动类型推导,不会发生自动类型转换,即隐式类型转换
void test1()
{
    int a = 10;
    int b = 20;
    char c = 'c';
    cout << myAdd01(a, c) << endl; //正确,将char类型的隐式转换为int类型
    // cout << myAdd02(a, c) << endl; //错误,使用自动类型推导时,不会发生隐式类型转换
    cout << myAdd02<int>(a, c) << endl; //正确，如果用显示指定类型，可以发生隐式类型转换
}
int main()
{
    test1();
    return 0;
}

总结：建议使用显示指定类型的方式，调用函数模板，因为可以自己确定通用类型T

1.2.5 普通函数与函数模板的调用规则

调用规则如下：

  1. 如果函数模板和普通函数都可以实现，优先调用普通函数
  2. 可以通过空模板参数列表来强制调用函数模板
  3. 函数模板也可以发生重载
  4. 如果函数模板可以产生更好的匹配,优先调用函数模板
#include "iostream"

using namespace std;
//普通函数于模板函数调用规则
void myPrint(int a, int b)
{
    cout << "1调用的普通函数" << endl;
}
template <typename T>
void myPrint(T a, T b)
{
    cout << "2调用的模板函数" << endl;
}
template <typename T>
void myPrint(T a, T b, T c)
{
    cout << "3调用的模板函数" << endl;
}
void test1()
{
    // 1、如果函数模板和普通函数都可以实现，优先调用普通函数
    //  注意 如果告诉编译器  普通函数是有的，但只是声明没有实现，或者不在当前文件内实现，就会报错找不到
    int a = 10;
    int b = 20;
    myPrint(a, b); //调用普通函数
    // 2 可以通过空模板参数列表来强制调用模板函数
    myPrint<>(a, b);
    // 3、函数模板也可以发生重载
    int c = 30;
    myPrint(a, b, c); //调用重载的函数模板
    // 4 如果函数模板可以产生更好的匹配,有限调用函数模板
    char ch1 = 'a';
    char ch2 = 'b';
    myPrint(ch1, ch2); //调用函数模板 因为调用普通的,要发生隐式转换,所以编译器就优先调用函数模板
}
int main()
{
    test1();
    return 0;
}

1.2.6 模板的局限性

局限性：

  • 模板的通用性并不是万能的

例如：

template<class T>
void f(T a, T b)
{ 
    a = b;
    }

在上述代码中提供的赋值操作，如果传入的a和b是一个数组，就无法实现了

再例如：

template<class T>
void f(T a, T b)
{ 
    if(a > b) { ... }
    }

在上述代码中，如果T的数据类型传入的是像Person这样的自定义数据类型，也无法正常运行

因此C++为了解决这种问题，提供模板的重载，可以为这些特定的类型提供具体化的模板

#include "iostream"

using namespace std;
class Person
{
public:
    Person(string name, int age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }
    string m_Name;
    int m_Age;
};
//普通函数模板
template <class T>
bool myCompare(T &a, T &b)
{
    return a == b;
}
//具体化,显示具体化的原型和以template<>开头,并通过名称来指出类型
//具体优化于常规模板
template <>
bool myCompare(Person &p1, Person &p2)
{
    return p1.m_Age == p2.m_Age && p1.m_Name == p2.m_Name;
}

void test1()
{
    int a = 10;
    int b = 20;
    //内置数据类型可以直接使用通用的函数模板
    bool ret = myCompare(a, b);
    if (ret)
    {
        cout << "a==b" << endl;
    }
    else
    {
        cout << "a!=b" << endl;
    }
}

void test2()
{
    Person p1("Tom", 10);
    Person p2("Tom", 10);
    bool ret = myCompare(p1, p2);
    if (ret)
    {
        cout << "p1==p2" << endl;
    }
    else
    {
        cout << "p1!=p2" << endl;
    }
}
int main()
{
    test1();
    test2();
    return 0;
}

总结：

  • 利用具体化的模板，可以解决自定义类型的通用化
  • 学习模板并不是为了写模板，而是在STL能够运用系统提供的模板

1.3 类模板

1.3.1 类模板语法

类模板作用：

  • 建立一个通用类，类中的成员 数据类型可以不具体制定，用一个虚拟的类型来代表。

语法：

template<typename T>
类

解释：

template --- 声明创建模板

typename --- 表面其后面的符号是一种数据类型，可以用class代替

T --- 通用的数据类型，名称可以替换，通常为大写字母

#include "iostream"

using namespace std;
template <class NameType, class AgeType>
class Person
{
public:
    Person(NameType name, AgeType age)
    {
        m_Name = name;
        m_Age = age;
    }
    void showPerson()
    {
        cout << "name: " << this->m_Name << " age: " << this->m_Age << endl;
    }
    NameType m_Name;
    AgeType m_Age;
};
void test1()
{
    //置顶NameType 为string类型 AgeType 为 int 类型
    Person<string, int> p1("孙悟空", 1000);
    p1.showPerson();
}

void test2()
{
}
int main()
{
    test1();
    test2();
    return 0;
}

总结：类模板和函数模板语法相似，在声明模板template后面加类，此类称为类模板

1.3.2 类模板与函数模板区别

类模板与函数模板区别主要有两点：

  1. 类模板没有自动类型推导的使用方式
  2. 类模板在模板参数列表中可以有默认参数
#include "iostream"

using namespace std;
//类模板
template <class NameType, class AgeType = int>
class Person
{
public:
    Person(NameType name, AgeType age)
    {
        this->name = name;
        this->age = age;
    }
    void showPerson()
    {
        cout << " age: " << this->age << " name: " << this->name << endl;
    }
    NameType name;
    AgeType age;
};
// 1 类模板没有自动类型推导的使用方式
void test1()
{
    // Person p("孙悟空", 1000);错误 类模板使用时候 不可以用自动类型推导
    Person<string, int> p("孙悟空", 1000);
    p.showPerson();
}
// 2 类模板在模板参数列表中可以有默认参数
void test2()
{
    Person<string> p("猪八戒", 999); //类模板中的模板参数列表 可以指定默认参数
    p.showPerson();
}
int main()
{
    test1();
    test2();
    return 0;
}

总结：

  • 类模板使用只能用显示指定类型方式
  • 类模板中的模板参数列表可以有默认参数

1.3.3 类模板中成员函数创建时机

类模板中成员函数和普通类中成员函数创建时机是有区别的：

  • 普通类中的成员函数一开始就可以创建
  • 类模板中的成员函数在调用时才创建
#include "iostream"

using namespace std;
class Person1
{
public:
    void showPerson1()
    {
        cout << "Person1 show" << endl;
    }
};
class Person2
{
public:
    void showPerson2()
    {
        cout << "Person2 show" << endl;
    }
};
template <class T>
class MyClass
{
public:
    T obj;
    //类模板中的成员函数,并不是一开始就创建的,而是在模板调用时再生成
    void fun1()
    {
        obj.showPerson1();
    }
    void fun2()
    {
        obj.showPerson2();
    }
};
void test1()
{
    MyClass<Person1> m;
    m.fun1();
    // m.fun2(); //编译会出错，说明函数调用才会去创建成员函数
}
int main()
{
    test1();

    return 0;
}

总结：类模板中的成员函数并不是一开始就创建的，在调用时才去创建

1.3.4 类模板对象做函数参数

学习目标：

  • 类模板实例化出的对象，向函数传参的方式

一共有三种传入方式：

  1. 指定传入的类型 --- 直接显示对象的数据类型
  2. 参数模板化 --- 将对象中的参数变为模板进行传递
  3. 整个类模板化 --- 将这个对象类型 模板化进行传递
#include "iostream"

using namespace std;
//类模板
template <class NameType, class AgeType = int>
class Person
{
public:
    Person(NameType name, AgeType age)
    {
        this->m_Age = age;
        this->m_Name = name;
    }
    void showPerson()
    {
        cout << "age" << this->m_Age << " name:" << this->m_Name << endl;
    }

    NameType m_Name;
    AgeType m_Age;
};
// 1 指定传入的类型
void printPerson1(Person<string, int> &p)
{
    p.showPerson();
}
void test1()
{
    Person<string, int> p("孙悟空", 1000);
    printPerson1(p);
}
// 2 参数模板化
template <typename T1, typename T2>
void printPerson2(Person<T1, T2> &p)
{
    p.showPerson();
    cout << "T1的类型为： " << typeid(T1).name() << endl;
    cout << "T2的类型为： " << typeid(T2).name() << endl;
}
void test2()
{
    Person<string, int> p("孙悟空", 1000);
    printPerson2(p);
}

// 3 整个类模板化
template <class T>
void printPerson3(T &p)
{
    p.showPerson();
    cout << "T的类型为： " << typeid(T).name() << endl;
}

void test3()
{
    Person<string, int> p("a", 100);
    printPerson3(p);
}
int main()
{
    test1();
    test2();
    test3();

    return 0;
}

总结：

  • 通过类模板创建的对象，可以有三种方式向函数中进行传参
  • 使用比较广泛是第一种：指定传入的类型

1.3.5 类模板与继承

当类模板碰到继承时，需要注意一下几点：

  • 当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T的类型
  • 如果不指定，编译器无法给子类分配内存
  • 如果想灵活指定出父类中T的类型，子类也需变为类模板
#include "iostream"

using namespace std;
template <class T>
class Base
{
    T m;
};
// class Son:public Base //错误 c++编译器需要给子类分配内存,必须知道父类中T的类型才可以向下继承
class Son : public Base<int>
{
};
void test()
{
    Son s;
}
//类模板继承类模板,可以用T2指定父类中的T类型
template <class T1, class T2>
class Son2 : public Base<T2>
{
public:
    Son2()
    {
        cout << typeid(T1).name() << endl;
        cout << typeid(T2).name() << endl;
    }
};
void test2()
{
    Son2<int, char> s;
}
int main()
{
    test();
    test2();
    return 0;
}
i
c

总结：如果父类是类模板，子类需要指定出父类中T的数据类型

1.3.6 类模板成员函数类外实现

学习目标：能够掌握类模板中的成员函数类外实现

#include "iostream"
using namespace std;
//类模板中成员函数类外实现
template <class T1, class T2>
class Person
{
public:
    //成员函数类内声明
    Person(T1 name, T2 age);
    void showPerson();
    T1 m_Name;
    T2 m_Age;
};
//构造函数 类外实现
template <class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age)
{
    m_Name = name;
    m_Age = age;
}

//成员函数 类外实现
template <class T1, class T2>
void Person<T1, T2>::showPerson()
{
    cout << "show person" << endl;
}

void test()
{
    Person<string, int> p("孙武", 100);
    p.showPerson();
}
int main()
{
    test();
    return 0;
}

总结：类模板中成员函数类外实现时，需要加上模板参数列表

1.3.7 类模板分文件编写

学习目标：

  • 掌握类模板成员函数分文件编写产生的问题以及解决方式

问题：

  • 类模板中成员函数创建时机是在调用阶段，导致分文件编写时链接不到

解决：

  • 解决方式1：直接包含.cpp源文件
  • 解决方式2：将声明和实现写到同一个文件中，并更改后缀名为.hpp，hpp是约定的名称，并不是强制

person.hpp

#pragma once
#include "iostream"
using namespace std;

template <class T1, class T2>
class Person
{
public:
    Person(T1 name, T2 age);
    void showPerson();

    int m_Age;
    string m_Name;
};

//构造函数 类外实现
template <class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age)
{
    this->m_Age = age;
    this->m_Name = name;
}

//成员函数 类外实现
template <class T1, class T2>
void Person<T1, T2>::showPerson()
{
    cout << "name:" << this->m_Name << " age " << this->m_Age << endl;
}

mian.cpp



#include "person.hpp"

void test()
{
    Person<string, int> p("bob", 100);
    p.showPerson();
}
int main()
{
    test();
    return 0;
}

总结：主流的解决方式是第二种，将类模板成员函数写到一起，并将后缀名改为.hpp

1.3.8 类模板与友元

学习目标：

  • 掌握类模板配合友元函数的类内和类外实现

全局函数类内实现 - 直接在类内声明友元即可

全局函数类外实现 - 需要提前让编译器知道全局函数的存在

#include "iostream"
using namespace std;

// 1 全局函数配合友元 类内实现
template <class T1, class T2>
class Person
{
    friend void showPerson(const Person<T1, T2> &p)
    {
        cout << "age " << p.mage << " name" << p.mname << endl;
    }

public:
    Person(T1 name, T2 age)
    {
        this->mage = age;
        this->mname = name;
    }

private:
    int mage;
    string mname;
};
void test()
{
    Person<string, int> p("bob", 22);
    showPerson(p);
}
int main()
{
    test();
    return 0;
}
#include "iostream"
using namespace std;

template <class T1, class T2>
class Person;

//如果声明了函数模板，可以将实现写到后面，否则需要将实现体写到类的前面让编译器提前看到
// template <class T1, class T2>
// void showPerson2(const Person<T1, T2> &p);

//这里放到Person类的前面,就不需要上面注释的 声明函数模板
template <class T1, class T2>
void showPerson2(const Person<T1, T2> &p)
{
    cout << "age " << p.mage << " name" << p.mname << endl;
}

template <class T1, class T2>
class Person
{
    // 1 全局函数配合友元 类内实现
    friend void showPerson(const Person<T1, T2> &p)
    {
        cout << "age " << p.mage << " name" << p.mname << endl;
    }
    //全局函数配合友元  类外实现
    // friend void showPerson2(const Person<T1, T2> &p); 这是普通全局函数的友元 得加<>
    friend void showPerson2<>(const Person<T1, T2> &p);

public:
    Person(T1 name, T2 age)
    {
        this->mage = age;
        this->mname = name;
    }

private:
    int mage;
    string mname;
};

void test1()
{
    Person<string, int> p("bob", 22);
    showPerson(p);
}
void test2()
{
    Person<string, int> p("wade", 33);
    showPerson2(p);
}

//放到Person类的后面,就需要提前在类前面声明函数模板,让编译器知道
// template <class T1, class T2>
// void showPerson2(const Person<T1, T2> &p)
// {
//     cout << "age " << p.mage << " name" << p.mname << endl;
// }

int main()
{
    test1();
    test2();
    return 0;
}

总结：建议全局函数做类内实现，用法简单，而且编译器可以直接识别

3333333_
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
cpp代码-模板样式罢了
07-16
"cpp代码-模板样式罢了"这个标题暗示我们将探讨C++中的模板这一核心特性。模板是C++中一个非常重要的概念，它允许我们编写泛型代码，即能够处理多种数据类型的代码。下面我们将深入探讨C++模板的各个方面。 首先，...
cpp代码-SPFA模板
07-14
在`cpp`编程语言中实现SPFA模板，我们需要理解以下几个关键点： 1. **数据结构**：SPFA算法主要依赖于队列数据结构来存储待更新的顶点。通常使用优先队列（如二叉堆）或简单数组模拟的队列。 2. **边的表示**：...
10、cpp模板编程
zd845101500的博客
08-15 352
函数模板 模板函数定义的一般形式如下所示： template <typename type> ret-type func-name(parameter list) { // 函数的主体 } 示例： template <typename T> T Max (T a, T b) { return a < b ? b:a; } 类模板 ...
cpp中的函数模板
Lyajpunov的博客
09-20 1221
之前我们讲了函数重载，对一个不同参数类型的函数作出了不同的行为，但是其实有一个更加高效的方式，那就是函数模板，也叫泛型编程。或者模板元编程。下面是一个交换两个元素的例子我们只需要在调用时指定类型就可以我们也可以指定两种类型，下面的程序没有什么实际意义，就是为了展示一下
CPP编程语言-模板
最新发布
qq_45595546的博客
04-30 1108
函数模板是指：可以用多种不同数据类型的参数进行调用，代表了一个函数家族。模板分为两大类：函数模板和类模板。
Cpp-模板初阶
ahojcn 的博客
03-19 514
title: 模板初阶 date: 2019-03-18 20:37:56 tags: Cpp categories: Cpp toc: true 泛型编程 告诉编译器一个模子，让编译器根据不同的类型利用该模子来生成代码。 泛型编程:编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。 函数模板 函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型...
万门cpp课程作业：模板元编程实现fibinacci
dlvector的博客
01-09 146
第一个自己写的代码： #include<iostream> using namespace std; template<double n> struct fbonacci { enum {RET=fbonacci<n-1>::RET+fbonacci<n-2>::RET}; }; template<> struct fbonacc...
C++ 模板元编程简介
Dablelv 的博客专栏。
09-17 2172
1.概述 模板元编程（Template Metaprogramming，TMP）是编写生成或操纵程序的程序，也是一种复杂且功能强大的编程范式（Programming Paradigm）。C++模板给C++提供了元编程的能力，但大部分用户对 C++ 模板的使用并不是很频繁，大致限于泛型编程，在一些系统级的代码，尤其是对通用性、性能要求极高的基础库（如 STL、Boost）几乎不可避免在大量地使用 C...
CPP-.zip_cpp编程 范例
09-19
本资料库“CPP-.zip”聚焦于C++编程的实践，提供了200个不同的程序示例，旨在帮助学习者深入理解和掌握C++语言的关键概念和技巧。 1. **基础语法**：C++的基础包括变量、数据类型、运算符、流程控制（如if语句、...
eclipse-cpp-2023-09-R-win32-x86-64.zip
09-19
Eclipse C++ IDE是一款广泛使用的开源集成开发环境（IDE），专为C++编程语言设计，旨在提供高效、便捷的开发体验。本篇文章将深入探讨“eclipse-cpp-2023-09-R-win32-x86_64.zip”这一版本，它针对Windows系统进行了...
初识Cpp之 九、模板和STL
Shen Mu Xin's Blog
09-04 860
​ Cpp中另一种编程思想称为泛型编程，主要利用的技术是模板，Cpp提供两种模板机制函数模板和类模板。模板就是建立通用的模具，大大提高程序的复用性。​ 函数模板是通用的函数描述，函数模板使用泛型来定义函数，其中的泛型可用具体的类型（如double和int）替换。通过将类型作为参数传递给模板，可使编译器生成该类型的函数。这种方式也被称为通用编程。创建函数模板需要使用关键字==和关键字==。​ 函数模板的作用是，建立一个通用函数，其函数返回值类型和形参类型可以不具体指定，用一个虚拟的类型来表示。模板的创建语法：
Cpp|| 模板进阶
Template Code
04-01 598
模板特化
Cpp模版Template-笔记
XXXXX的专栏
03-12 1185
Cpp的模版Template本文参考这里模板是泛型编程的基础。函数模版 Function Templatetemplate <class(或typename) T> // T是类型占位符，在下面紧接的函数定义中可以使用 ret-type func_name(parameter list) { // body }类模版 Class Templatetemplate <class T> //
2、CPP 基础语法学习
vincent3678的博客
05-24 1807
很多语法点从汇编角度分析就很明了了 加油一、基础语法 A1、cin、cout2、函数重载（Overload）3、默认参数4、extern "C"C 和 C++混合开发二、基础语法 B5、内联函数 （inline function）窥探内敛函数的本质：内联函数与宏表达式6、 const7、引用（Reference）引用的本质三、汇编语言1、学习汇编指令的 2 大知识点：2、内联汇编3、汇编指令mov 指令call 指令lea指令（指针）ret、add、sub、inc、dec、xorjmp常见代码的汇编4、.
C++中的模板
Vast_Sea的专栏
11-07 948
From: http://www.cnblogs.com/BeyondAnyTime/archive/2012/08/13/2636963.html template int CompareNums(T1 num1, T2 num2) {     if(num1     {         return 1;     }     else if(num2 > num1)
cpp 模板函数，类模板（1）
蓝羽飞鸟的博客
07-06 1103
对应《c++ primer 第五版》的第16章前半部分，这里是一个简单的总结。
C/C++编程：模板的基本语法
OceanStar的博客
04-20 848
Template Class基本语法 Template Function基本语法 整型也可以是Template参数 模板形式和功能是统一的
C++模板编程
qqliang1314的专栏
04-16 269
模板编程是一种高级的 C++ 编程技术，它允许我们在编写代码时使用泛型（Generic）类型或函数，从而实现代码的复用和通用性。需要注意的是，模板编程在使用时需要谨慎，因为模板的错误使用可能导致编译错误和运行时错误。在模板编程中，还可以使用类型萃取（Type Traits）、模板特化（Template Specialization）、模板元编程（Template Metaprogramming）等高级技术，从而实现更加复杂和灵活的泛型编程。C++ 模板编程的主要概念包括模板函数和模板类。
黑马C++笔记——模板(CPP)
感觉画质不如...原神的博客
12-01 691
C++模板的常见操作

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值