C++模板(template)详解教程（很多代码示例）

已于 2024-06-04 10:54:44 修改
阅读量2.9k 收藏 36
点赞数 25
文章标签： c++ 算法 开发语言 template method
于 2024-06-04 10:54:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a6484594/article/details/139435758
版权

目录

1. 定义模板

1.1. 函数模板

实例化函数模板

模板类型参数

非类型模板参数

inline 和 constexpr的函数模版

编写类型无关的代码

模版编译

1.2. 类模版

定义类模版

实例化类模版

类模版的成员函数

类模版构造函数

在类模版外使用类模版名

在类模版中的友元

类模版的static成员

1.3. 模版参数

模版声明

使用typename来区分成员和类型

默认模板实参

模板默认实参与类模板

1.4. 成员模板

非模板类的成员模板

类模板的成员模板

实例化与成员模板

1.5. 继承关系

父类是一般类，子类是模板类

父类是模板类，子类是普通类

父类和子类都是模板类

注意事项

  面向对象编程（OOP）和泛型编程都能处理在编写程序时不知类型的情况，不同之处在于：OOP能处理类型在程序运行之前都未知的情况：而在泛型编程中，在编译时就能获知类型了

1. 定义模板

1.1. 函数模板

背景：比如我们需要来比较不同数据类型的两个值，并指出第一个值与第二个值的大小关系，如果此时只定义只比较一种参数类型的函数，略显麻烦。

此时引出了函数模板,此时就不用为每个类型定义一个新的函数了。

比如：

template<typename T>
int compare(const T& v1, const T& v2)
{
	if (v1 < v2)return -1;
	if (v2 < v1)return 1;
	return 0;
}

模版定义：以关键字template开始，后跟一个模板参数列表，这是一个逗号分隔的一个或多个模板参数的列表，用小于号（<）和大于号(>)包围起来。

实例化函数模板

当我们调用一个函数模版时，编译器通常根据函数传入的实参来推断模板实参

例如，

cout << compare(1, 0) << endl;//T为int

实参为int型，编译器会将模板实参推断为int，并将它绑定到模板参数T

  • 编译器用推断出的模板参数来为我们实例化，这些编译器生成的版本通常被称为模板的实例
模板类型参数

在模板参数列表中，使用关键字typename或class后面跟着一个标识符来定义模板类型参数。例如：

template<typename T>
void print(T value) {
    std::cout << value << std::endl;
}

在上面的例子中，T是一个模板类型参数，它表示一个不特定的数据类型。在函数体内，我们可以像使用任何其他类型一样使用T。

  • 返回类型和参数类型相同的模板示例：
template<typename T>
T identity(T value) {
    return value;
}

在上面的例子identity 是一个模板函数，它接受一个参数 value，类型为 T，并返回相同类型的值。无论传入什么类型的参数，该函数都会返回相同类型的值。

使用该模板函数的示例代码如下：

int main() {
    int intValue = identity(42);  // 返回 int 类型的值 42
    double doubleValue = identity(3.14);  // 返回 double 类型的值 3.14
    std::string stringValue = identity("Hello");  // 返回 std::string 类型的值 "Hello"

    return 0;
}

在上述示例中，identity 函数根据传入的参数类型进行实例化，并返回相同类型的值。

模板类型参数前必须使用关键字 class 或 typename，这是为了指示编译器该参数是一个类型参数。

选择使用哪个关键字主要是个人偏好，但在C++标准中，更常见的做法是使用关键字 typename 来表示类型参数

非类型模板参数

非类型模板参数（Non-type Template Parameters）：非类型模板参数允许我们在模板中使用常量值作为参数。它们用于在模板定义中指定一个常量值，而不是一个数据类型。非类型模板参数可以是整数、枚举、指针或引用类型。在模板参数列表中，我们使用一个特定的类型来定义非类型模板参数。例如：

template<int N>
int multiplyByN(int value) {
    return value * N;
}

在上面的例子中，N是一个非类型模板参数，它表示一个整数常量值。在函数体内，我们可以将N用作常量值来执行相应的计算。

  • 非类型模版参数使用示例：

模版定义了两个非类型的参数。第一个模板参数表示第一个数组的长度，第二个模版参数表示第二个数组的长度：

template<unsigned N,unsigned M>
int compare(const char(&p1)[N], const char(&p2)[M])
//由于数组不能拷贝，所以定义为数组的引用
{
	return strcmp(p1, p2);
}
​

当我们这样调用时：

compare("hi","mom");

编译器会使用字面常量的大小来代替N和M，从而实例化模版：

int compare(const char (&p1)[3],const char (&p2)[4])
  • 一个非类型参数可以是一个整型，或者是一个指向对象或函数类型的指针或（左值）引用
  • 绑定到非类型整型参数的实参必须是一个常量表达式
  • 在模版定义内，模版非类型参数是一个常量值。在需要常量表达式的地方，可以使用非类型参数。例如指定数组大小
inline 和 constexpr的函数模版

函数模版可以声明为inline或constexpr的，如同非模版函数一样。inline或constexpr说明符放在模版参数列表之后，返回类型之前：

//正确：inline说明符跟在模版参数列表之后
template <typename T> inline T min(const T&,const T&);
//错误：inline 说明符的位置不正确
inline template<typename T> T min(const T&,const T&);
编写类型无关的代码
  1. 将参数设定为const的引用可以避免不必要的拷贝操作

这个原则确保了函数可以用于不能拷贝的类型，因为将参数设定为const的引用可以避免不必要的拷贝操作。这使得函数可以处理不允许拷贝的类类型，并且如果函数用于处理大对象，这种设计策略还能使函数运行得更快。

  1. 函数体中的条件判断仅使用<比较运算：

意味着在函数体内部，比较操作只使用小于号(<)进行判断，而不使用其他比较操作符，比如大于号(>)或等于号(==)。

举个例子，假设我们有一个通用的比较函数模板：

template <typename T>
int compare(const T &v1, const T &v2) {
    if (v1 < v2) return -1;
    if (v2 < v1) return 1;
    return 0;
}

在这个例子中，我们只使用小于号(<)进行比较判断。如果v1小于v2，我们返回-1；如果v2小于v1，我们返回1；如果它们相等，我们返回0。这样的设计保证了我们只依赖于小于号来进行比较，而不会依赖于其他比较操作符。

这种方法的好处在于，它降低了函数对于要处理的类型的要求。被比较的类型只需要支持小于号(<)运算符，而不需要同时支持其他比较操作符。

模版编译

模板编译指的是使用C++中的模板来生成特定类型的代码实例。在C++中，当使用模板时，编译器并不直接生成代码，而是在实际使用时根据模板参数生成对应的代码。

函数模版和类模版成员函数的定义通常放在头文件中

1.2. 类模版

类似函数模版，类模版以关键字template开始，后跟模版参数列表。

定义类模版
template <typename T1, typename T2>
class Pair {
private:
    T1 first;
    T2 second;

public:
    Pair(const T1& f, const T2& s) : first(f), second(s) {}

    T1 getFirst() const { return first; }
    T2 getSecond() const { return second; }
};
实例化类模版
  • 实例化了一个 Pair 对象，其中 T1 被实例化为int，T2 被实例化为 double：
Pair<int, double> myPair(5, 3.14);
  • 使用显式模版实参：

作用:使用显式模板实参列表来明确指定模板实例化时使用的模板参数，而不是让编译器根据上下文推断，这在某些情况下可能是必要的。

格式：当使用显式模板实参列表时，可以在模板名称后面使用尖括号（<>）来指定模板参数。这样可以确保使用指定的模板参数进行实例化，而不依赖于编译器的模板参数推断。

#include <iostream>

template <typename T>
void printValue(T value) {
    std::cout << value << std::endl;
}

int main() {
    printValue<int>(5); // 显式指定模板参数为int
    // printValue(5); //不显式指定模版参数，编译器会推断模板参数为int
    printValue<double>(3.14); // 显式指定模板参数为double
    printValue(3.14); // 不显式指定模版参数,编译器会推断模板参数为double
    return 0;
}

<int>和 <double> 就是显式模板实参列表，它们明确指定了在调用printValue 函数时应该使用的模板参数类型。

类模版的成员函数
  • 定义在类模板之外的成员函数

在类模板之外定义成员函数时，需要显式指定模板参数，这样才能让编译器知道这个函数是属于哪个类模板的。这种方式使得你可以单独实现类模板的成员函数，而不必将实现和类模板的定义放在一起。

下面是一个示例代码：

template <typename T>
class MyContainer {
private:
T element;

public:
MyContainer(const T& elem) : element(elem) {}

T getElement() const;
};

// 在类模板之外定义成员函数
template <typename T>
T MyContainer<T>::getElement() const {
    return element;
}
  • 在类模版外定义成员函数时不指定模版参数的错误示例:
// 在类模板之外错误地未指定模板参数
// 这将导致编译错误
template
T MyContainer::getElement() const {
    return element;
}
  • 定义在类模板之内的成员函数

如果选择在类模板内部定义成员函数，可以直接访问类模板的成员和类型，而无需显式指定模板参数。这种方式更为简洁，因为函数的定义直接位于类模板内部。

下面是一个示例代码：

template <typename T>
class MyContainer {
private:
T element;

public:
MyContainer(const T& elem) : element(elem) {}

T getElement() const {
    return element;
}
};
类模版构造函数

在类模板内部定义构造函数时，不需要显式指定模板参数，因为在类模板内部，构造函数的定义已经在模板的作用域内，编译器可以自动识别模板参数：

template<typename T>
class MyContainer {
private:
	T element;
public:
	MyContainer(const T& element) :element(elem) {
		
	}
};

在类模板外部定义构造函数，需要使用与类模板的成员函数类似的语法来指定模板参数：

template<typename T>
class MyContainer {
private:
	T element;
public:
	MyContainer(const T& element);
};

template<typename T>
MyContainer<T>::MyContainer(const T& element:element(elem) {
}
在类模版外使用类模版名
// 声明类模板
template <typename T>
class MyTemplate {
public:
    void doSomething(const T& value); // 成员函数声明
};

// 类模版外定义成员函数
template <typename T>
void MyTemplate<T>::doSomething(const T& value) {
    // 在类模板外部使用类模板名 MyTemplate<T>
    // 实现类模板的成员函数
    // 这里可以使用模板参数 T
}
在类模版中的友元

1. 声明友元函数模板

#include <iostream>

// 定义一个类模板 MyClass
template <typename T>
class MyClass {
public:
    // 构造函数，初始化成员变量 value
    MyClass(T value) : value(value) {}

    // 声明一个友元函数模板
    // 这个友元函数模板可以访问 MyClass 的私有成员
    template <typename U>
    friend void printValue(const MyClass<U>& obj);

private:
    // 私有成员变量
    T value;
};

// 定义友元函数模板
// 这个函数可以访问 MyClass 的私有成员
template <typename U>
void printValue(const MyClass<U>& obj) {
    std::cout << "Value: " << obj.value << std::endl;
}

int main() {
    // 创建 MyClass<int> 的实例
    MyClass<int> obj(42);
    // 调用友元函数模板，输出成员变量 value 的值
    printValue(obj);  // 输出: Value: 42
    return 0;
}

2. 声明友元类模板

#include <iostream>

// 前向声明 MyClass 类模板
template <typename T>
class MyClass;
    
// 定义 MyClass 类模板
template <typename T>
class MyClass {
public:
    // 构造函数，初始化成员变量 value
    MyClass(T value) : value(value) {}

    // 声明 FriendClass<T> 为友元类
    // FriendClass<T> 可以访问 MyClass<T> 的私有成员
    friend class FriendClass<T>;

private:
    // 私有成员变量
    T value;
};
// 定义一个友元类模板 FriendClass
template <typename T>
class FriendClass {
public:
    // 定义一个成员函数，可以访问 MyClass 的私有成员
    void showValue(const MyClass<T>& obj);
};

// 定义 FriendClass<T> 的成员函数
// 这个函数可以访问 MyClass<T> 的私有成员
template <typename T>
void FriendClass<T>::showValue(const MyClass<T>& obj) {
    std::cout << "Value: " << obj.value << std::endl;
}

int main() {
    // 创建 MyClass<int> 的实例
    MyClass<int> obj(42);
    // 创建 FriendClass<int> 的实例
    FriendClass<int> friendObj;
    // 调用 FriendClass<int> 的成员函数，输出 MyClass<int> 的成员变量 value 的值
    friendObj.showValue(obj);  // 输出: Value: 42
    return 0;
}

3. 声明特定实例的友元函数

#include <iostream>

// 定义一个类模板 MyClass
template <typename T>
class MyClass {
public:
    // 构造函数，初始化成员变量 value
    MyClass(T value) : value(value) {}

    // 声明一个特定实例的友元函数
    // 这个友元函数可以访问 MyClass<T> 的私有成员
    friend void printValue(const MyClass<T>& obj) {
        std::cout << "Value: " << obj.value << std::endl;
    }

private:
    // 私有成员变量
    T value;
};

int main() {
    // 创建 MyClass<int> 的实例
    MyClass<int> obj(42);
    // 调用友元函数，输出成员变量 value 的值
    printValue(obj);  // 输出: Value: 42
    return 0;
}
类模版的static成员

C++中的类模板可以声明静态成员。静态成员变量和静态成员函数在类模板中的使用方式与非模板类类似。静态成员变量只有一个实例，无论模板实例化了多少次，而静态成员函数在类的所有实例之间共享。

1.3. 模版参数

我们通常将类型参数命名为T，但实际上我们可以使用任何名字：

template<typename Foo>Foo calc(const Foo& a, const Foo& b)
{
	Foo tmp = a;//tmp的类型与参数和返回类型一样
	//..
	return tmp;//返回类型和参数类型一样
}
模版声明
  • 模版声明必须包含模版参数：
template <typename T> T calc(const T&, const T&);//声明
  • 与函数参数相同，模版定义中模版参数的名字不必与声明中相同：
template<typename Type> 
Type calc(const Type& a, const Type& b) {/**/ }//定义

可以分成两行写，也可以都写在一行内

使用typename来区分成员和类型
  1. 在普通（非模板）代码中，编译器能够通过访问类定义来确定通过作用域运算符访问的名称是类型还是静态成员。
  2. 在处理模板类型参数（在本例中表示为T）时，编译器在实例化之前无法确定通过作用域运算符访问的名称是类型还是静态数据成员。
  3. 为了处理模板，编译器必须知道一个名称是否表示一个类型。例如，当遇到类似T::size_type * p;的语句时，编译器需要知道size_type是类型还是静态数据成员，以便正确解释该语句。
  4. 默认情况下，在模板的上下文中，语言假定通过作用域运算符访问的名称不是类型。这意味着，如果要使用模板类型参数的类型成员，必须明确告诉编译器该名称是一个类型。
typename T::size_type * p;
  • 当我们希望通知编译器一个名字表示类型时，必须使用关键字typename，而不能使用class
默认模板实参

我们也可以向能为函数参数提供默认实参一样，我们也可以提供默认模版实参

template <typename T, typename F = std::less<T>>
int compare(const T &v1, const T &v2, F f = F())
{
    if (f(v1, v2)) return -1; 
    if (f(v2, v1)) return 1; 
    return 0;
}

compare 函数是一个模板函数，它接受三个参数，但是只有前两个参数是必须的。第三个参数是一个可选的函数对象参数，它有一个默认值。

在调用 compare 函数时，如果只提供了前两个参数 v1 和 v2，编译器会根据函数模板参数的默认类型进行自动推导。这意味着它会使用 less<T> 作为默认的函数对象类型。因此，下面这两种调用方式都是合法的：

int result1 = compare(5, 10);  // 使用默认的比较函数对象 less<int>
int result2 = compare(5, 10, MyComparator());  // 使用自定义的比较函数对象 MyComparator

在第一种调用中，由于没有提供第三个参数，编译器会使用默认的函数对象 less<int> 进行比较。在第二种调用中，我们显式地提供了自定义的函数对象 MyComparator，因此它会被用于执行比较操作。

函数对象是一个行为类似函数的对象，它可以被调用并执行特定的操作。在C++中，函数对象通常是一个类对象，它重载了函数调用运算符 operator()。函数对象在泛型编程中非常有用，因为它们可以作为参数传递给函数或算法，从而实现定制化的行为。

举例来说，假设有一个自定义的比较函数对象 MyComparator，它实现了一个特定的比较操作。用户可以将这个函数对象传递给 compare 函数，以便在比较时使用这个自定义的比较行为，如以下示例：

struct MyComparator {
bool operator()(int a, int b) const {
    return a < b; // 自定义的比较操作
}
};

int main() {
    int result = compare(5, 10, MyComparator());
    // 使用自定义的比较函数对象进行比较
}

在这个例子中，MyComparator 是一个函数对象，它重载了函数调用运算符，因此可以被当作一个函数来调用。当它被传递给 compare 函数时，它将会被用于执行比较操作。

模板默认实参与类模板

无论任何时候使用类模版，都必须在模版名后接上一个尖括号。尖括号指出类必须从一个模板实例化而来。如果类模板为所有的模板参数提供了默认实参：

template <typename T = int, int N = 5>
class MyClassTemplate {
    // ... class definition
};

那么在调用时候，使用<>表示我们希望使用默认实参：

MyClassTemplate<> obj1;  // Using default template arguments for T and N

1.4. 成员模板

无论是普通类还是类模板，都可以包含一个本身是模板的成员函数。这种成员被称为成员模板。

【成员模板不能是虚函数】

非模板类的成员模板
#include <iostream>

// 普通类
class MyClass {
public:
    // 成员模板
    template <typename T>
    void print(const T& value) {
        std::cout << "Value: " << value << std::endl;
    }
};

int main() {
    MyClass obj;
    obj.print(5);  // 调用模板成员函数，T 被推导为 int
    obj.print("Hello");  // 调用模板成员函数，T 被推导为 const char*
    return 0;
}
类模板的成员模板

假设我们有一个类模板 MyClass，它有一个成员模板 func。我们需要在类模板外定义这个成员模板 func。为了做到这一点，必须同时为类模板和成员模板提供参数列表。

首先，定义类模板 MyClass：

#include <iostream>

template <typename T>
class MyClass {
public:
    // 成员模板
    template <typename U>
    void func(U value);
};

// 在类模板外定义成员模板
template <typename T>
template <typename U>
void MyClass<T>::func(U value) {
    std::cout << "T: " << typeid(T).name() << ", U: " << typeid(U).name() << ", value: " << value << std::endl;
}

int main() {
    MyClass<int> myClass;
    myClass.func(3.14);  // 调用 func 成员模板，U 被推断为 double
    myClass.func("Hello");  // 调用 func 成员模板，U 被推断为 const char*
    return 0;
}

在这个例子中：

  1. 定义了类模板 MyClass，它有一个模板参数 T。
  2. 在 MyClass 中，定义了一个成员模板 func，它有自己的模板参数 U。
  3. 在类模板外定义成员模板时，必须同时为类模板和成员模板提供参数列表。
  • template <typename T> 是类模板 MyClass 的参数列表。
  • template <typename U> 是成员模板 func 的参数列表。
  • 在 main 函数中，创建了一个 MyClass<int> 的实例，并调用了 func 成员模板。
实例化与成员模板

必须同时提供类和函数模板的实参，才能实例化一个类模板的成员模板：

template <typename T>
class MyClass {
public:
    template <typename U>
    void MyFunction(U value) {
        // 实现代码
    }
};

int main() {
    MyClass<int> obj;  // 实例化类模板 MyClass
    obj.MyFunction(5.5);  // 这里需要提供函数模板 MyFunction 的实参
    return 0;
}

可以在实例化类模板后，使用不同的类型来调用类模板的成员函数模板，比如这里使用double类型来实例化函数模板，而使用int型来实例化类模板

1.5. 继承关系

父类是一般类，子类是模板类

这种情况下，父类是一个普通的非模板类，而子类是一个模板类。子类可以通过模板参数来扩展父类的功能：

class Base {
public:
void baseFunction() {
    // 基类的方法
}
};

template <typename T>
class Derived : public Base {
public:
void derivedFunction() {
    // 子类的方法
}
};

用法示例：

Derived<int> d;
d.baseFunction();  // 调用基类的方法
d.derivedFunction();  // 调用子类的方法
父类是模板类，子类是普通类

这种情况下，父类是一个模板类，而子类是一个普通类。子类需要在定义时明确父类的模板参数：

template <typename T>
class Base {
public:
void baseFunction() {
    // 基类的方法
}
};

class Derived : public Base<int> {
public:
void derivedFunction() {
    // 子类的方法
}
};

用法示例：

Derived d;
d.baseFunction();  // 调用基类的方法
d.derivedFunction();  // 调用子类的方法
父类和子类都是模板类

这种情况下，父类和子类都是模板类。子类可以继承父类并扩展其功能，且可以有不同的模板参数：

template <typename T>
class Base {
public:
void baseFunction() {
    // 基类的方法
}
};

template <typename T, typename U>
class Derived : public Base<T> {
public:
void derivedFunction() {
    // 子类的方法
}
};

用法示例：

Derived<int, double> d;
d.baseFunction();  // 调用基类的方法
d.derivedFunction();  // 调用子类的方法
注意事项
  1. 访问基类成员：在模板类中访问基类成员时，有时需要使用 this-> 或 Base<T>:: 来明确指示编译器成员是来自基类的。
  2. 模板参数的传递：在继承模板类时，子类需要明确父类的模板参数，或者将父类的模板参数传递给子类。
  3. 模板类的实例化：模板类在使用时需要提供具体的模板参数，否则编译器无法生成对应的类定义。

LeoKing0218
关注
  • 25
    点赞
  • 踩
  • 36
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++ atl控件开发详解
07-11
4. **属性、方法和事件**：ATL提供了很多宏来声明和实现属性、方法和事件，比如BEGIN_PROP_MAP、END_PROP_MAP、BEGIN_METHOD_MAP、END_METHOD_MAP和BEGIN_EVENT_MAP、END_EVENT_MAP等。你需要在类定义中使用这些宏来...
C++ Template 基础篇（一）：函数模板详解
08-26
主要介绍了C++ Template函数模板，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Halcon c++ 源代码
06-03
Halcon cpp源代码 里面封装了c++调用Halcon的好几个例子，包括各种调用和算法，直接在c++里实现Halcon的各种功能。
C++ 模板保姆级详解——template＜class T＞(什么是模板？模板分哪几类
最新发布
2401_84976219的博客
05-15 613
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以添加戳这里获取一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！ 网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以添加戳这里获取
有趣算法之C++函数模板
Xor0ne
10-02 1137
C++函数模板 20200924 原文链接：https://www.runoob.com/w3cnote/c-templates-detail.html （原文正在慢慢理解中……） 模板是C++支持参数化多态的工具，使用模板可以使用户为类或者函数声明一种一般模式，使得类中的某些数据成员或者成员函数的参数、返回值取得任意类型。 模板是一种对类型进行参数化的工具，通常有两种形式：函数模板和类模板； 函数模板针对仅参数类型不同的函数； 类模板针对仅数据成员和成员函数类型不同的类。 ...
C++ 泛型编程 之模板（template）
qq_24472227的博客
04-29 4128
C++的 函数模板与类模板
C++模板
weixin_63246738的博客
05-19 5807
c++的模板
C++之模板
m0_74893211的博客
06-22 4758
C++泛型编程和STL技术详细讲解。
C++模板详解
qq_52905520的博客
10-21 1万+
C++模板详解
C++——模板（超详细的模板解析）
热门推荐
JAN6055的博客
04-01 5万+
超详细的C++模板知识列表，持续维护。
C++模板（template）详解
2301_81261654的博客
03-09 6548
原因是在链接过程中，编译器找不到模板函数的定义，因为在使用模板时，.h文件中的模板的声明知晓了模板参数的类型，但在.cpp文件中的模版不知道，所以.cpp中模板的定义没法实例化,也就没法在编译阶段生成一份经过实例化的具体的代码，这将导致程序在链接阶段找不到模板函数的实现而报链接错误。这样一来，在调用Add函数的时候，其本质上是调用了上面的经过实例化的模板函数，这样做的好处就是，程序员就可以不用对每一种数据类型都去实现对应的函数，大大提高了效率，而且只实现这么一份通用的模板函数可以使其更易于维护。
C、C++的作业、代码示例和操作指南.zip
06-27
这个资源包中的"ccodebase-master"很可能包含了各种代码示例和练习，涵盖以上所述知识点，通过实践这些代码，你可以更深入地理解和运用C、C++语言。操作指南可能提供了详细的步骤和解释，帮助你在实际编程中避免常见...
《VC++深入详解》源代码
08-28
9. **Windows API调用**：虽然MFC提供了很多功能，但有时直接使用Windows API能实现更底层的操作，如消息处理和系统调用。 通过《VC++深入详解》的源代码，读者可以逐步掌握以上知识，并通过实践加深理解。在阅读和...
C++编程实例详解
04-28
在C++编程领域，实例详解通常意味着通过具体的代码示例来深入理解语言特性和编程技巧。C++是一种强大且灵活的面向对象编程语言，广泛应用于系统软件、游戏开发、科学计算等多个领域。以下是对C++编程实例详解的一些...
C++编程语言中模板（template）介绍
liitdar的博客
06-05 7577
泛型编程是一种代码编写方式，通过使用泛型编程，可以编写出独立于任何特定类型的代码。模板是泛型编程的基础，是创建泛型函数或类的蓝图（公式）。C++的STL(Standard Template Library)容器及其迭代器和算法，都是泛型编程的例子，它们都使用了模板的概念。每个容器都有一个单一的定义，比如vector，我们可以定义许多包含不同类型元素的vector，比如：“vector ”或“vector ”。C++的模板包括函数模板和类模板。
C++ 模板详解——template＜class T＞
2402_83315537的博客
04-20 2585
通过使用函数模板，可以写出更通用、更灵活的代码，同时减少重复和错误。编译时的类型检查提供了比C语言中的宏更高的类型安全性。函数模板在C++标准库中被广泛使用，例如在STL（标准模板库）的各种算法和容器中。这使得STL非常强大，因为它不仅能够处理几乎任何类型的数据，还保持了代码的紧凑和高效。
【C++】—— 模板介绍
m0_56069910的博客
06-08 2579
模板的详细介绍
c++模板类 和 模板函数的代码示例
03-19
C++模板类和模板函数是C++中的泛型编程特性，它们可以根据不同的数据类型生成对应的代码。下面是它们的代码示例： 1. 模板类示例： ```cpp template <typename T> class MyArray { private: T* arr; int size; public: MyArray(int s) { size = s; arr = new T[size]; } ~MyArray() { delete[] arr; } T& operator[](int index) { return arr[index]; } }; // 使用示例 MyArray<int> intArray(5); intArray[0] = 1; intArray[1] = 2; intArray[2] = 3; MyArray<double> doubleArray(3); doubleArray[0] = 1.1; doubleArray[1] = 2.2; doubleArray[2] = 3.3; ``` 2. 模板函数示例： ```cpp template <typename T> T getMax(T a, T b) { return (a > b) ? a : b; } // 使用示例 int maxInt = getMax<int>(3, 5); float maxFloat = getMax<float>(3.14, 2.71); ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值