C++ 泛编程 —— 嵌套使用模板类

于 2024-12-26 15:17:52 发布
阅读量1k 收藏 11
点赞数 10
文章标签： c++ 开发语言 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/MaoSiri/article/details/144498821
版权

嵌套使用模板类

嵌套使用模板类最常见的场景

容器中有容器
数组的元素可以是栈，栈中的元素可以是数组。先来看一下Stack和Vector的基本代码，定长数组Array的代码也给出来，但是不会用到，代码如下：

#include <iostream>
using namespace std;

// 定长数组 Array
template <class T, int len=10>
class Array {
private:
    T* items[len];
public:
    Array() {}
    ~Array() {}
    T& operator[](int index) {return items[index];}
    const T& operator[] (int index) const {return items[index];}
};

// 栈 Stack
template <class DataType>
class Stack {
private:
    DateType* items;
    int stacksize;   
    int top;
public:
    Stack(int size=3): stacksize(size), top(0) {
        items  = new DataType[stacksize];
    }
    ~Stack() {
        delete [] items; items = nullptr;
    }

    bool isEmpty() {return top == 0;}
    
    bool isFull() {return top == stacksize;}

    bool push(const DateType& item) {
        if(top < stacksize) {items[top++] = item; return true;}
        return false;
    }
    
    bool pop() {
        if(top > 0) {item = items[--top]; return true;}
        return false;
    }
};

// 动态数组 Vector
template <class T>
class Vector {
privatet:
    int len; // 数组元素的个数
    T* items; // 数组元素
public:
    Vector(int size=2): len(size) { // 元素个数的缺省值为 2
        items = new T[len];
    }
    ~Vector() {
        delete [] items; items = nullptr;
    }

    void resize(int size) {
        if(size <= len) return; // 只能往更大的方向扩容
        T* tmp = new T[size]; // 分配更大的内存空间
        for(int i = 0; i < len; i++) tmp[i] = items[i]; // 复制旧数组元素到新数组
        delete [] items; // 释放旧数组
        items = tmp;
        len = size;
    }

    int size() {return len;}

    T& operator [] (int index) {
        if(index >= len) resize(index + 1);
        return items[index];
    }

    const T& operator [] (int index) const {return items[index];} // 重载操作符[]，不能修改数组中的元素。
};

int main() {
	return 0;
}

数组容器中有栈容器

目前的代码中，Vector容器的大小缺省值是2，Stack容器的大小缺省值是3。现在演示数组容器Vector中有栈Stack容器的情况，代码如下：

#include <iostream>
using namespace std;

// 栈 Stack
template <class DataType>
class Stack {
private:
    DataType* items;
    int stacksize;   
    int top;
public:
    Stack(int size=3): stacksize(size), top(0) {
        items  = new DataType[stacksize];
    }
    ~Stack() {
        delete [] items; items = nullptr;
    }

    bool isEmpty() {return top == 0;}
    
    bool isFull() {return top == stacksize;}

    bool push(const DataType& item) {
        if(top < stacksize) {items[top++] = item; return true;}
        return false;
    }
    
    bool pop(DataType& item) {
        if(top > 0) {item = items[--top]; return true;}
        return false;
    }
};

// 动态数组 Vector
template <class T>
class Vector {
private:
    int len; // 数组元素的个数
    T* items; // 数组元素
public:
    Vector(int size=2): len(size) { // 元素个数的缺省值为 2
        items = new T[len];
    }
    ~Vector() {
        delete [] items; items = nullptr;
    }

    void resize(int size) {
        if(size <= len) return; // 只能往更大的方向扩容
        T* tmp = new T[size]; // 分配更大的内存空间
        for(int i = 0; i < len; i++) tmp[i] = items[i]; // 复制旧数组元素到新数组
        delete [] items; // 释放旧数组
        items = tmp;
        len = size;
    }

    int size() {return len;}

    T& operator [] (int index) {
        if(index >= len) resize(index + 1);
        return items[index];
    }

    const T& operator [] (int index) const {return items[index];} // 重载操作符[]，不能修改数组中的元素。

};

int main() {
    // 创建Vector对象vs，vs是一个Vector，Vector中存储Stack<string>类型的元素。
    Vector<Stack<string>> vs;
    // 往容器中插入数据
    vs[0].push("hello world!"); vs[0].push("hihihi"); vs[0].push("123456"); // vs[0]是一个栈，往vs[0]中插入数据
    vs[1].push("你好！"); vs[1].push("abcdef"); vs[1].push("xxxxx"); // vs[1]也是一个栈，往vs[1]中插入数据
    // 用嵌套循环，遍历vs中的所有元素
    for(int i = 0; i < vs.size(); i++) {
        while(vs[i].isEmpty() == false) {
            string item;
            vs[i].pop(item);
            cout << "pop item = " << item << endl;
        }
    }

    return 0;
}

运行的结果如下：

pop item = 123456
pop item = hihihi
pop item = hello world!
pop item = xxxxx
pop item = abcdef
pop item = 你好！

容器中的容器就是二维容器，但不能简单把它说成二维数组。因为不同的容器可以实现不同的数据结构。像二维数组，但不是二维数组。目前的程序，Stack是没有扩展功能的，而Vector是有resize()扩展功能的，那就往Vector容器中再多加一个元素，只入栈两个元素，其他代码不变，main()函数代码如下：

int main() {
    Vector<Stack<string>> vs;
    vs[0].push("hello world!"); vs[0].push("hihihi"); vs[0].push("123456");
    vs[1].push("你好！"); vs[1].push("abcdef"); vs[1].push("xxxxx");
    vs[2].push("Happy Everyday!"); vs[1].push("吃好喝好，身体健康！"); // 往Vector中再增加一个Stack数据

    for(int i = 0; i < vs.size(); i++) {
        while(vs[i].isEmpty() == false) {
            string item;
            vs[i].pop(item);
            cout << "pop item = " << item << endl;
        }
    }

    return 0;
}

我的电脑编译运行的结果如下，你的电脑可能编译不通过，或者编译运行的结果与我的不同，总之是不正常的：

pop item = 123456
pop item = hihihi
pop item =
pop item = xxxxx
pop item = abcdef
pop item =
pop item = Happy Everyday!
free(): double free detected in tcache 2
Aborted (core dumped)

目前这个代码异常的原因在Vector类中，具体在扩展数组内存空间的resize()函数里面。 tmp[i] = items[i];这条语句的意思是：把原数组中的数据拷贝到新数组中去。如果复制的是C++内置的数据类型，则不存在问题；如果复制的是自定义的类，并且类中使用了堆区内存，就存在浅拷贝的问题。
具体解释一下，在Stack类中，根据语句：DataType* items;可以确定items这个成员变量是指针，使用了堆区内存。这样的话，对Stack类用浅拷贝是不行的，要用深拷贝。也就是说，对于Stack这种类，一定要重写拷贝构造函数和赋值函数。在此实例中，未用到Stack类的拷贝构造函数，无需在意；但这条语句：tmp[i] = items[i];用到了Stack类的赋值函数。所以，应该为Stack类重写赋值函数，实现深拷贝。具体的做法是，在Stack类中添加如下代码：

Stack& operator = (const Stack& v) {
    delete [] items;
    stacksize = v.stacksize;
    items = new DataType[stacksize];
    for(int i = 0; i < stacksize; i++) {items[i] = v.items[i];}
    top = v.top;
    return *this;
}

再次编译运行，结果如下：

pop item = 123456
pop item = hihihi
pop item = hello world!
pop item = xxxxx
pop item = abcdef
pop item = 你好！
pop item = Happy Everyday!

栈容器中有数组容器

给Vector类也加上赋值运算符的重载函数，实现深拷贝，以便演示栈容器Stack中有数组容器Vector的情况，代码如下：

#include <iostream>
using namespace std;

// 栈 Stack
template <class DataType>
class Stack {
private:
    DataType* items;
    int stacksize;   
    int top;
public:
    Stack(int size=3): stacksize(size), top(0) {
        items  = new DataType[stacksize];
    }
    ~Stack() {
        delete [] items; items = nullptr;
    }

    Stack& operator = (const Stack& v) {
        delete [] items;
        stacksize = v.stacksize;
        items = new DataType[stacksize];
        for(int i = 0; i < stacksize; i++) {items[i] = v.items[i];}
        top = v.top;
        return *this;
    }

    bool isEmpty() {return top == 0;}
    
    bool isFull() {return top == stacksize;}

    bool push(const DataType& item) {
        if(top < stacksize) {items[top++] = item; return true;}
        return false;
    }
    
    bool pop(DataType& item) {
        if(top > 0) {item = items[--top]; return true;}
        return false;
    }
};

// 动态数组 Vector
template <class T>
class Vector {
private:
    int len; // 数组元素的个数
    T* items; // 数组元素
public:
    Vector(int size=2): len(size) { // 元素个数的缺省值为 2
        items = new T[len];
    }
    ~Vector() {
        delete [] items; items = nullptr;
    }

    Vector& operator = (const Vector& v) {
        delete [] items;
        len = v.len;
        items = new T[len];
        for(int i = 0; i < len; i++) items[i] = v.items[i];
        return *this;
    }

    void resize(int size) {
        if(size <= len) return; // 只能往更大的方向扩容
        T* tmp = new T[size]; // 分配更大的内存空间
        for(int i = 0; i < len; i++) tmp[i] = items[i]; // 复制旧数组元素到新数组
        delete [] items; // 释放旧数组
        items = tmp;
        len = size;
    }

    int size() {return len;}

    T& operator [] (int index) {
        if(index >= len) resize(index + 1);
        return items[index];
    }

    const T& operator [] (int index) const {return items[index];} // 重载操作符[]，不能修改数组中的元素。

};

int main() {
	// 创建Stack对象，sv是一个栈，栈中存储Vector<string>类型的元素。
    Stack<Vector<string>> sv;
    // 先创建Vector<string>对象，再插入到Stack中
    Vector<string> tmp;
    // 第一次把字符串数据放到临时容器tmp中，再第一次入栈。
    tmp[0] = "hi ~"; tmp[1] = "hello ~"; sv.push(tmp);
    // 第二次把字符串数据放到临时容器tmp中，再第二次入栈。
    tmp[0] = "666"; tmp[1] = "888"; sv.push(tmp);
    // 第二次把字符串数据放到临时容器tmp中，再第二次入栈。
    tmp[0] = "qqqqq"; tmp[1] = "324fwre"; tmp[2] = "09ji"; sv.push(tmp);

    // 用嵌套循环，遍历sv中的所有元素
    while(sv.isEmpty() == false) {
        sv.pop(tmp);
        for(int i = 0; i < tmp.size(); i++) {
            cout << "sv[" << i << "] = " << tmp[i] << endl;
        }
    }

    return 0;
}

运行结果如下：

sv[0] = qqqqq
sv[1] = 324fwre
sv[2] = 09ji
sv[0] = 666
sv[1] = 888
sv[0] = hi ~
sv[1] = hello ~

递归使用模板类

递归使用模板类，属于嵌套使用模板类的特殊情况，自己嵌套自己。对于以上代码，仅需修改main函数中的调用代码即可，参考如下：

int main() {
	// Vector嵌套Vector
    Vector<Vector<string>> vv; // 递归使用模板类

    vv[0][0] = "hello"; vv[0][1] = "world"; vv[0][2] = "!";
    vv[1][0] = "你好"; vv[1][1] = "世界";
    vv[2][0] = "Happy"; vv[2][1] = "Everyday"; vv[2][2] = "!"; vv[2][3] = "吃好喝好";

    for(int i = 0; i <vv.size(); i++){
        for(int j = 0; j < vv[i].size(); j++) {
            cout << "vv[" << i << "][" << j << "] = " << vv[i][j] << endl;
        }
    }

    return 0;
}

运行结果如下：

vv[0][0] = hello
vv[0][1] = world
vv[0][2] = !
vv[1][0] = 你好
vv[1][1] = 世界
vv[2][0] = Happy
vv[2][1] = Everyday
vv[2][2] = !
vv[2][3] = 吃好喝好

注意，这跟二维数组不同。二维数组是一个矩阵，第二维的大小是固定的。而vv的大小不是固定的。也可以调整一下输出格式，更能直观感受vv第二维不固定的特点，代码如下：

int main() {
    // Vector嵌套Vector
    Vector<Vector<string>> vv; // 递归使用模板类

    vv[0][0] = "hello"; vv[0][1] = "world"; vv[0][2] = "xxx";
    vv[1][0] = "你好"; vv[1][1] = "世界";
    vv[2][0] = "Happy"; vv[2][1] = "Everyday"; vv[2][2] = "qqq"; vv[2][3] = "吃好喝好";

    for(int i = 0; i <vv.size(); i++){
        for(int j = 0; j < vv[i].size(); j++) {
            cout << vv[i][j] << " ";
        }
        cout << endl;
    }

    return 0;
}

运行的结果如下：

hello world xxx
你好 世界
Happy Everyday qqq 吃好喝好

由此可以看出，vv的第一行有3个元素、第二行有2个元素、第三行有4个元素。故Vector<Vector<string>> vv;的第二个纬度是不固定的。

感谢浏览，一起学习！

C++编程：详解模板偏特化及其在实际编程中的高效应用
03-25
适合人群：具有一定的C++基础，并对进阶C++编程感兴趣的程序员，尤其是那些希望优化自己的代码结构和提高程序性能的人群。 使用场景及目标：本文的目标读者能在实际项目开发中利用C++的高级特性更好地进行软件架构...
c++模板 --- 模板的嵌套
路过的熊的博客
04-23 1292
c++模板 --- 模板的嵌套
C++类模板——嵌套使用
Crush_66的博客
05-17 2823
C++类模板的嵌套使用
C++学习笔记（11）
m0_60958852的博客
03-10 1660
介绍了C++模板，包括函数模板，类模板，模板嵌套以及模板特化。
C++模板嵌套类
Jasmine-Lily的博客
11-23 1039
C++模板嵌套类
跟我学c++中级篇——模板嵌套中的依赖限定
fpcc的专栏
05-20 644
遇到问题不要慌，先拍个照，发个朋友圈”。遇到问题时，需要冷静的联想相关的知识，然后再有针对性的查找相关资料。说一句不太准确的话，在大多数人的认知体系中，几乎所有的知识都是有传承体系的，不会突然出现，遇到一些不太清楚的用法，也不要着急，因为要明白，学习的知识是已有的，而不是需要你去创造的。否则，就是发明家了。学习还是有技巧有方法可以掌握的。好好学习，天天向上。
C++入门学习——模板示例代码
06-24
在C++编程语言中，模板是一种强大的特性，它允许我们编写通用代码，以处理不同类型的对象，无需重复编写相似的代码。本篇文章将深入探讨C++模板的基本概念、类型和函数模板，以及模板特化和元编程等高级主题。 首先...
C++编程思想——很实用的一本书
04-08
本书作者根据自己学习C++的亲身体会及多年教学经验，用简单的例子和简练的叙述讲解C++编程，别具特色。 全书共分十八章，内容涉及对象的演化、数据抽象、隐藏实现、初始化与清除、函数重载与缺省参数、输入输出流...
c++————————笔记
01-12
根据提供的文档内容，我们可以归纳出一系列关于C++的重要知识点，这些知识点主要涵盖了C++的基础语法、数据类型、内存管理、程序结构以及高级特性如类、继承与多态等。下面将详细阐述这些知识点： ### 1. 引言 C++...
华为谷歌编程规范,华为的编程规范,C,C++
09-10
3. **模板与泛型编程**：谷歌鼓励使用模板来实现代码复用，但同时强调避免过度使用导致编译时膨胀。 4. **异常安全**：谷歌的规范强调函数应提供异常安全保证，即使在抛出异常时，也能保持数据的完整性。 5. **...
C++嵌套类
weixin_50866517的博客
04-20 4012
嵌套类介绍二级目录三级目录 介绍 在c++中，可以将类的声明放在另一个类中。在另一个类中声明的类被称为嵌套类，它通过提供新的类型类作用域来避免混乱。包含类的成员函数可以创建和使用被嵌套类的对象；而仅当声明位于公有部分，才能在包含类的外面使用嵌套类，而且必须使用作用域解析运算符。 对类进行嵌套与包含并不不同。包含意味着将类对象作为另一个类的成员，而对类进行嵌套不创建类成员，而是定义了一种类型，该类型仅在包含嵌套类声明的类中有效。 对类进行嵌套通常是为了帮助实现另一个类，并避免名称冲突。Queue类示例嵌套了结
【类模板】类模板嵌套
Antonio915的博客
09-04 1144
在类内可以定义类，而这个类也可以使用类模板，因此，我们可以在普通的类内嵌套模板，也可以在类模板内嵌套类模板。这样的模板成为类模板的嵌套。在这个例子中，我们对A这个类模板中嵌套了另一个类模板OtherC，因此这个类模板称为嵌套类模板。在类内实现myfOC。
C++(17)：模板嵌套类的.template及::template
风静如云的博客
11-24 1352
告诉编译器后面的符号是一个嵌套类模板。告诉编译器后面的符号是一个模板成员。对象.template。类::template。
STL——array和vector容器
热爱编程的小K的博客
04-16 2096
STL——array和vector容器详解
C++ 模板类的嵌套
man_skill的博客
04-10 3343
模板类的嵌套 使用函数模板，当参数是自定义数据类型（如结构体，类）时，需要通过第三代具体化自定义数据类型来解决问题。 那么对于类模板中的成员对象的数据类型也是自定义数据类型呢。 实际上，只要类中包括了某个类型的成员或者方法，在实例化对象的时候就要声明数据类型。 那么如果类的成员也是模板类呢。 就出现了如下的嵌套： template<class T> class Nm { T a; }; template<class T> class Mn { T find() { T p
C++ 函数模板与类模板
灰太狼的小秘密
06-21 2192
一、函数模板 1、函数模板：建立一个通用函数，其函数类型和形参类型不具体指定，用一个虚拟类型来代表这个通用函数来代表。凡是函数体相同的函数都可以用这个模板来代替，不必定义多个函数，只需在模板中定义一次即可。在调用函数时系统会根据实参的类型来取代模板中虚拟的类型，从而实现不同函数的功能。 作用：功能相同而数据类型不同的一些函数，不必一一定义各个函数，通过定义一个可以对任何类型变量操作的模板函数，...
什么是嵌套模板
最新发布
一个做过前端开发的产品经理，经历过睿智产品的折磨导致脱发之后，励志要翻身"农奴"把歌唱，一边打入敌人内部一边持续提升自己，为我们广大开发同胞谋福祉，坚决抵制睿智产品折磨我们码农兄弟！
11-26 775
基本概念与作用基本概念作用示例一：简单的嵌套模板解释说明示例二：嵌套数组的处理解释说明示例三：动态嵌套模板解释说明示例四：使用模板引擎使用Handlebars示例解释说明示例五：Vue.js中的嵌套模板Vue.js示例解释说明实际开发中的技巧数据预处理性能优化错误处理可维护性在Web前端开发中，模板是一种非常重要的概念，它允许开发者以结构化的方式组织和呈现数据。嵌套模板则是指在一个模板内部使用另一个模板的技术，这种技术特别适用于处理复杂的数据结构，如列表、树形结构等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值