【C++】再谈模板,深入理解C++模板

这篇具有很好参考价值的文章主要介绍了【C++】再谈模板,深入理解C++模板。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

🎉博客主页:小智_x0___0x_

🎉欢迎关注:👍点赞🙌收藏✍️留言

🎉系列专栏:C++初阶

🎉代码仓库:小智的代码仓库

typename和class的区别

在C++中,typenameclass关键字都可以用于模板参数声明,它们的作用是相同的,用于指定一个类型参数。但是,在一些情况下,typenameclass更加灵活。

首先,当模板参数是一个嵌套类型的时候,必须使用typename关键字来告诉编译器这是一个类型而不是一个静态成员变量或者函数。例如:

template<class Container>
void Print(const Container& v)
{
	// 编译不确定Container::const_iterator是类型还是对象
	// typename就是明确告诉编译器这里是类型,等模板实例化再去找
	typename Container::const_iterator it = v.begin(); //必须使用 typename 关键字
	auto it = v.begin();//当然使用auto就不会有以上的各种问题
	while (it != v.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
}

【补充】:当模板参数是一个模板类型的时候,必须使用class关键字来指定这个模板参数。例如:

template <class T, template <class> class Container>
class MyClass {
public:
    Container<T> c;
};

在这个例子中,Container是一个模板类,它接受一个类型参数,因此必须使用class关键字来指定。

总的来说,虽然在大多数情况下typenameclass可以互换使用,但是在一些特殊情况下,必须使用其中的一个关键字来保证代码正确性。

非类型模板参数

  • 模板参数分类类型形参与非类型形参。
  • 类型形参即:出现在模板参数列表中,跟在class或者typename之类的参数类型名称。
  • 非类型形参,就是用一个常量作为类(函数)模板的一个参数,在类(函数)模板中可将该参数当成常量来使用。

静态栈是一种使用数组实现的栈,它的大小在编译时确定。我们可以使用非类型模板参数来指定静态栈的大小。下面是一个简单的静态栈的实现:

template <typename T, int N>
class StaticStack {
public:
    void push(const T& value) {
        if (size_ < N) {
            data_[size_++] = value;
        } else {
            cout<<"StaticStack is full"<<endl;
        }
    }

    void pop() {
        if (size_ > 0) {
            --size_;
        } else {
            cout<<"StaticStack is empty"<<endl;
        }
    }

    T& top() {
        if (size_ > 0) {
            return data_[size_ - 1];
        } else {
            cout<<"StaticStack is empty"<<endl;
        }
    }

    bool empty() const {
        return size_ == 0;
    }

    int size() const {
        return size_;
    }

private:
    T data_[N];
    int size_ = 0;
};

在这个例子中,StaticStack是一个模板类,它接受两个参数:T表示栈中元素的类型,N表示栈的大小。data_是一个长度为N的数组,用于存储栈中的元素。其他成员函数实现了栈的基本操作。

我们可以使用这个静态栈来存储任何类型的数据,并且在编译时指定栈的大小。例如,下面的代码创建了一个能够存储10个整数的静态栈:

StaticStack<int, 10> s;
s.push(1);
s.push(2);
s.push(3);
std::cout << s.top() << std::endl; // 输出 3
s.pop();
std::cout << s.top() << std::endl; // 输出 2

【C++】再谈模板,深入理解C++模板,C++初阶,c++,开发语言,模板方法模式

在这个例子中,我们使用了非类型模板参数10来指定静态栈的大小。这使得我们可以在编译时就确定静态栈的大小,从而避免了动态分配内存的开销,提高了代码的效率。

【注意】:

  1. 浮点数、类对象以及字符串是不允许作为非类型模板参数的。
  2. 非类型的模板参数必须在编译期就能确认结果。

模板的特化

在C++中,模板的特化是指为某些特定的模板参数提供一个专门的实现。模板特化可以用于优化代码、解决特殊情况下的问题等。

模板特化有两种形式:完全特化和部分特化。完全特化是指为某些特定的模板参数提供一个完全不同的实现,而部分特化是指为某些特定的模板参数提供一个更为通用的实现。

函数模板特化

函数模板的特化步骤:

  1. 必须要先有一个基础的函数模板
  2. 关键字template后面接一对空的尖括号<>
  3. 函数名后跟一对尖括号,尖括号中指定需要特化的类型
  4. 函数形参表: 必须要和模板函数的基础参数类型完全相同,如果不同编译器可能会报一些奇怪的错误。
template<class T>
bool Less(T left, T right)
{
    return left < right;
}

// 函数模板的特化
template<>
bool Less<int*>(int* left, int* right)
{
	return *left < *right;
}

但是一般函数遇到需要特化的情况可以直接重载:

template<class T>
bool Less(T left, T right)
{
    return left < right;
}

template<class T>
bool Less(T* left, T* right)
{
    return *left < *right;
}

int main()
{
	cout << Less(1, 2) << endl;

	int a = 1, b = 2;
	cout << Less(&a, &b) << endl;

	double c = 1.1, d = 2.2;
	cout << Less(&c, &d) << endl;

	return 0;
}

【C++】再谈模板,深入理解C++模板,C++初阶,c++,开发语言,模板方法模式

类模板特化

全特化

全特化是指为某些特定的模板参数提供一个完全不同的实现。在C++中,全特化是指为所有的模板参数提供一个专门的实现。全特化可以用于优化代码、解决特殊情况下的问题等。

下面是一个使用全特化的例子:

template <typename T>
class MyClass {
public:
    void print() {
        std::cout << "Generic implementation" << std::endl;
    }
};

template <>
class MyClass<int> {
public:
    void print() {
        std::cout << "Specialized implementation for int" << std::endl;
    }
};

template <>
class MyClass<double> {
public:
    void print() {
        std::cout << "Specialized implementation for double" << std::endl;
    }
};

int main() {
    MyClass<char> c1;
    c1.print(); // 输出 "Generic implementation"

    MyClass<int> c2;
    c2.print(); // 输出 "Specialized implementation for int"

    MyClass<double> c3;
    c3.print(); // 输出 "Specialized implementation for double"

    return 0;
}

在这个例子中,MyClass是一个模板类,我们为MyClass<int>MyClass<double>提供了专门的实现。当我们创建一个MyClass<int>或者MyClass<double>对象时,它会调用对应的专门实现;而对于其他类型的对象则会使用通用的实现。

需要注意的是,在使用全特化时,必须使用空的模板参数列表来表示这是一个特化版本。例如,上面例子中的template <> class MyClass<int>template <> class MyClass<double>就是空的模板参数列表。

总的来说,全特化可以使得模板更加灵活和通用,同时也可以优化代码性能。但是,在使用全特化时需要谨慎,避免过度使用导致代码难以维护。

偏特化

偏特化:任何针对模版参数进一步进行条件限制设计的特化版本。比如对于以下模板类:

template<class T1, class T2>
class Data
{
public:
    Data() { cout << "Data<T1, T2>" << endl; }
private:
    T1 _d1;
    T2 _d2;
};

偏特化有两种表现方式:

  • 部分特化
    将模板参数类表中的一部分参数特化。
// 将第二个参数特化为int
template <class T1>
class Data<T1, int>
{
public:
    Data() { cout << "Data<T1, int>" << endl; }
private:
    T1 _d1;
    int _d2;
};
  • 参数更进一步的限制
    偏特化并不仅仅是指特化部分参数,而是针对模板参数更进一步的条件限制所设计出来的一个特化版
    本。
//两个参数偏特化为指针类型
template <typename T1, typename T2>
class Data <T1*, T2*>
{
public:
    Data() { cout << "Data<T1*, T2*>" << endl; }

private:
    T1 _d1;
    T2 _d2;
};
//两个参数偏特化为引用类型
template <typename T1, typename T2>
class Data <T1&, T2&>
{
public:
    Data(const T1& d1, const T2& d2)
        : _d1(d1)
        , _d2(d2)
    {
        cout << "Data<T1&, T2&>" << endl;
    }

private:
    const T1& _d1;
    const T2& _d2;
};
void test()
{
    Data<double, int> d1; // 调用特化的int版本
    Data<int, double> d2; // 调用基础的模板
    Data<int*, int*> d3; // 调用特化的指针版本
    Data<int&, int&> d4(1, 2); // 调用特化的指针版本
}

【C++】再谈模板,深入理解C++模板,C++初阶,c++,开发语言,模板方法模式

模板分离编译

一个程序(项目)由若干个源文件共同实现,而每个源文件单独编译生成目标文件,最后将所有目标文件链
接起来形成单一的可执行文件的过程称为分离编译模式。

模板的分离编译

//a.h
template<class T>
T Add(const T& left, const T& right);
//a.cpp
template<class T>
T Add(const T& left, const T& right)
{
	return left + right;
}
//Test.cpp
#include"a.h"
int main()
{
    Add(1, 2);
    Add(1.0, 2.0);

    return 0;
}

我们以上面这个例子来测试一下模板分离编译>

【C++】再谈模板,深入理解C++模板,C++初阶,c++,开发语言,模板方法模式
可以发现这里报错了。
【C++】再谈模板,深入理解C++模板,C++初阶,c++,开发语言,模板方法模式

解决方法

  1. 将声明和定义放到一个文件 xxx.cpp 里面或者xxx.h其实也是可以的。推荐使用这种。
  2. 模板定义的位置显式实例化。这种方法不实用,不推荐使用。
template<class T>
T Add(const T& left, const T& right)
{
	return left + right;
}
template int Add<int>(const int& left, const int& right);//显示实例化
template double Add<double>(const double& left, const double& right);

这样实例化之后就可以正常编译运行了。

总结

【优点】:

  1. 模板复用了代码,节省资源,更快的迭代开发,C++的标准模板库(STL)因此而产生
  2. 增强了代码的灵活性

【缺点】:

  1. 模板会导致代码膨胀问题,也会导致编译时间变长
  2. 出现模板编译错误时,错误信息非常凌乱,不易定位错误

🍀小结🍀

今天我们学习了深入理解C++模板相信大家看完有一定的收获。
种一棵树的最好时间是十年前,其次是现在! 把握好当下,合理利用时间努力奋斗,相信大家一定会实现自己的目标!加油!创作不易,辛苦各位小伙伴们动动小手,三连一波💕💕~~~,本文中也有不足之处,欢迎各位随时私信点评指正!
本篇代码已上传gitee仓库文章来源地址https://www.toymoban.com/news/detail-603957.html

到了这里,关于【C++】再谈模板,深入理解C++模板的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【C++】模板初阶——函数模板和类模板

    🚀 作者简介:一名在后端领域学习,并渴望能够学有所成的追梦人。 🚁 个人主页:不 良 🔥 系列专栏:🛸C++  🛹Linux 📕 学习格言:博观而约取,厚积而薄发 🌹 欢迎进来的小伙伴,如果小伙伴们在学习的过程中,发现有需要纠正的地方,烦请指正,希望能够与诸君一同

    2024年02月10日
    浏览(43)
  • C++初阶(十七)模板进阶

    📘北尘_ :个人主页 🌎个人专栏 :《Linux操作系统》《经典算法试题 》《C++》 《数据结构与算法》 ☀️走在路上,不忘来时的初心 📘北尘_ :个人主页 🌎个人专栏 :《Linux操作系统》《经典算法试题 》《C++》 《数据结构与算法》 ☀️走在路上,不忘来时的初心 模板参数

    2024年02月03日
    浏览(33)
  • C++——模板(初阶) + string

    作者:几冬雪来 时间:2023年5月19日 内容:C++模板 + string讲解 目录 前言: 1.模板:  1.函数模板的隐/显示实例化:  2.类模板: 2.STL:  1.  什么是STL:  2.STL六大组件:  3.string类:  结尾:  在上一篇博客我们结束了动态管理的讲解,并且在最后的时候我们引出了下一个学

    2024年02月05日
    浏览(55)
  • C++初阶--类型模板

    先看一个例子: 这是一些对于Swap重载的函数,区别是类型不同; 虽然能够重载使用,但 代码复用率比较低 ,如果我们让别人直接调用我们的函数,只使用整形类型的Swap(),那么其他函数就有点浪费了; 而且 代码的维护性比较低 ,一个出错可能会导致重载都出错。 所以

    2024年02月05日
    浏览(38)
  • c++之模板初阶

    💗 💗 博客:小怡同学 💗 💗 个人简介:编程小萌新 💗 💗 如果博客对大家有用的话,请点赞关注再收藏 🌞 函数重载的缺点 重载的函数仅仅是类型不同,代码复用率比较低,只要有新类型出现时,就需要用户自己增加对应的函 数 代码的可维护性比较低,一个出错可能所有

    2024年02月08日
    浏览(48)
  • <C++> 四、模板初阶

    泛型编程:编写与类型无关的通用代码,是代码复用的一种手段。模板是泛型编程的基础。 如何实现一个通用的交换函数呢?使用 函数重载 可以实现 使用函数重载虽然可以实现,但是有一下几个不好的地方: 重载的函数仅仅是类型不同,代码 复用率 比较 低 ,只要有新类

    2023年04月12日
    浏览(32)
  • C++模板初阶

    使用函数重载虽然可以实现,但是有一下几个不好的地方: 重载的函数仅仅是类型不同,代码复用率比较低,只要有新类型出现时,就需要用户自己增加对应的函数 代码的可维护性比较低,一个出错可能所有的重载均出错 那能否告诉编译器一个模子,让编译器根据不同的类

    2024年02月08日
    浏览(43)
  • C++——模板初阶

    前言: 本章我们将学习 模板 ,正式接触泛型编程。 C++ 相比于 C 语言有这么多丰富的接口与类型,都源于泛型编程。本章的内容为模板初阶知识,为接下来的 STL 学习打下坚实的基础。 如何实现一个通用的交换函数( swap )呢?我们已经学过函数重载的使用,函数重载在这

    2024年02月06日
    浏览(83)
  • C++:模板初阶

    本篇文章主要对模板有个简单的认识,方便我们后面对模板进行更加深入的学习。 目录 1.泛型编程 2.函数模板 2.1 函数模板的概念 2.2 函数模板格式 2.3 函数模板的原理 2.4 函数模板的实例化 2.5 模板参数的匹配原则 3.类模板 3.1 类模板的格式定义 3.2 类模板的实例化 如何实现一

    2024年02月08日
    浏览(32)
  • 【C++初阶】八、初识模板(泛型编程、函数模板、类模板)

    ========================================================================= 相关代码gitee自取 : C语言学习日记: 加油努力 (gitee.com)  ========================================================================= 接上期 : 【C++初阶】七、内存管理 (C/C++内存分布、C++内存管理方式、operator new / delete 函数、定位new表

    2024年02月04日
    浏览(43)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包