C++系列-类模板案例

最新推荐文章于 2024-08-28 20:31:15 发布
最新推荐文章于 2024-08-28 20:31:15 发布
阅读量517 收藏 15
点赞数 14
文章标签： c++ 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48668114/article/details/141642687
版权

const用法总结

苏轼《饮湖上初晴后雨二首·其二》
水光潋滟晴方好，山色空蒙雨亦奇。
欲把西湖比西子，淡妆浓抹总相宜

案例要求

实现一个通用的数组类，此类主要管理数组，有如下要求：

  1. 可以对自定义的数据类型或者内置数据进行存储
  2. 数组中的数据存储在堆区
  3. 构造函数中传入数组的容量(给数据开辟了多大的空间)
  4. 实现拷贝构造函数，实现=的重载，实现数组的赋值
  5. 实现尾插法和尾删法对数组中的数据增加或删除
  6. 可以通过下标的方式访问数组元素
  7. 可以获取数组中元素的个数(元素不一定要占据所有空间)和数组的容量

案例实现分析

需要由类模板实现，类模板实现分析如下(对应以上各条)：
1，类中主要的成员属性是该数组，数组的容量，数组元素的个数，m_p_array, m_capacity, m_size
其中m_p_array是该数组的首地址，指针类型。m:member，p:pointer
2，存储在堆区，需要在构造函数中使用new方法来开辟空间，同时，析构函数也要自己实现，用于
释放堆区空间。
3，有参构造。
4，拷贝构造应用于使用已有对象来实例化一个新的对象。=重载应用于数组的直接赋值
5，通过写成员函数实现，删除元素时，将m_size减小。增加元素时，m_size增加，并给增加的位置
赋值。
6，数组名[]是可以直接访问数组元素的，但是通过对象名[]访问其中的一个属性(数组)中的元素需
进行运算符重载。
7，成员函数实现。
8，再增加拼接数组的代码。

案例实现

总代码

#include <iostream>    
using namespace std;

class Person
{
public:
	string m_name;
	int m_age;
public:
	Person() 
	{
		//cout << "Person无参构造" << endl;
	}
	Person(string name, int age)
	{
		//cout << "Person有参构造" << endl;
		m_name = name;
		m_age = age;
	}
};

// 创建类模板
template<class T>
class MyArray
{
	// 函数模板作为类模板的友元，可以直接把函数的定义部分拷贝进来
	template<class T1>
	friend void print_array(T1 ref_array);
	friend void print_array(MyArray<Person>& ref_array);
private:
	int m_capacity;	// 为数组开辟的内存大小,有些空间不一定有元素
	int m_size;		// 数组中元素的个数
	T *m_p_array;	// 数组的首地址

public:
	MyArray(int capacity)		// 有参构造
	{
		//cout << "有参构造调用" << endl;
		m_capacity = capacity;
		m_size = 0;
		m_p_array = new T[m_capacity];
	}
	
	MyArray(const MyArray& ref_array)		// 拷贝构造
	{
		//cout << "拷贝构造调用" << endl;
		m_capacity = ref_array.m_capacity;
		m_size = ref_array.m_size;
		m_p_array = new T[ref_array.m_capacity];	// 开辟好内存空间
		// 数组中的元素也进行拷贝
		for (int i_loop = 0; i_loop < ref_array.m_size; i_loop++)
		{
			m_p_array[i_loop] = ref_array.m_p_array[i_loop];
		}
	}

	MyArray& operator=(const MyArray& ref_array)	// 实现连等，返回必须是MyArray& 
	{
		//cout << "=运算符重载" << endl;
		// 如果赋值目标对象中原来有数据，先都删除掉，包括堆区内存也要释放，然后再赋值
		if (m_p_array != NULL)
		{
			delete[] m_p_array;
			m_p_array = NULL;
			m_capacity = 0;
			m_size = 0;
		}
		m_capacity = ref_array.m_capacity;
		m_size = ref_array.m_size;
		m_p_array = new T[ref_array.m_capacity];	// 开辟好内存空间
		for (int i_loop = 0; i_loop < m_size; i_loop++)
		{
			m_p_array[i_loop] = ref_array.m_p_array[i_loop];
		}
		return *this;
	}

	T& operator[](int idx)		// 如果要作为左值，返回引用,如a[5]=3;
	{
		//cout << "[]运算符重载" << endl;
		return m_p_array[idx];
	}
	
	void append(T append_data)
	{
		if (m_size == m_capacity)
		{
			cout << "没有空间可以添加元素了" << endl;
			return;
		}
		else
		{
			m_p_array[m_size] = append_data;
			m_size += 1;
		}
	}

	void pop()
	{
		if (m_size == 0)
		{
			cout << "没有元素可以删除了" << endl;
			return;
		}
		else
		{
			m_size --;
		}
	}
	
	void extend(T* normal_array, int array_len) // 函数重载，添加普通的数组元素，不用创建类对象
	{
		cout << "extend(T* normal_array, int array_len)" << endl;
		int i_loop = 0;
		if (m_size == m_capacity)
		{
			cout << "数组容量已满，不能再拼接任何数组" << endl;
			return;
		}
		else if ((m_size + array_len) > m_capacity)
		{
			cout << "添加所有会导致容量超标，只能添加部分元素" << endl;
		}
		for (i_loop = 0; i_loop < array_len; i_loop++)
		{
			if (m_size + i_loop == m_capacity)
			{
				break;
			}
			m_p_array[m_size+ i_loop] = normal_array[i_loop];
		}
		m_size += i_loop;
	}
	
	void extend(MyArray& ref_array)		// 函数重载，添加类对象中的数组元素
	{
		cout << "void extend(MyArray& ref_array)" << endl;
		int i_loop = 0;
		if (m_size == m_capacity)
		{
			cout << "数组容量已满，不能再拼接任何数组" << endl;
			return;
		}
		else if ((m_size + ref_array.m_size) > m_capacity)
		{
			cout << "添加所有会导致容量超标，只能添加部分" << endl;
		}

		for (i_loop = 0; i_loop < ref_array.m_size; i_loop++)
		{
			if (m_size + i_loop == m_capacity)
			{
				break;
			}
			m_p_array[m_size + i_loop] = ref_array.m_p_array[i_loop];
		}
		m_size += i_loop;
	}

	~MyArray()
	{
		//cout << "析构函数调用" << endl;
		if (m_p_array != NULL)
		{
			delete[] m_p_array;
			m_p_array = NULL;
		}
		m_capacity = 0;
		m_size = 0;
	}

	int get_size()
	{
		//cout << "数组的size: " << m_size << endl;
		return m_size;
	}
	int get_capacity()
	{
		//cout << "数组的capacity: " << m_capacity << endl;
		return m_capacity;
	}
};
template<class T>
void print_array(T ref_array)
{
	cout << "capacity: " << ref_array.m_capacity << ", size: " << ref_array.m_size << endl;
	for (int i_loop = 0; i_loop < ref_array.m_size; i_loop++)
	{
		cout << ref_array[i_loop];
		if (i_loop < ref_array.m_size - 1)
		{
			cout << ", ";
		};
	}
	cout << endl;
}

// 已经声明为友元，可以直接访问MyArray对象的私有成员变量
void print_array(MyArray<Person> &ref_array)
{
	cout << "capacity: " << ref_array.m_capacity << ", size: " << ref_array.m_size << endl;
	for (int i_loop = 0; i_loop < ref_array.m_size; i_loop++)
	{
		cout << "name: " << ref_array[i_loop].m_name << ", age: " << ref_array[i_loop].m_age << endl;
	}
	cout << endl;
}

void test01()
{
	cout << "\n\ntest01开始\n" << endl;
	MyArray<int> p1(10);
	cout << "\n---------- 末尾添加元素 ----------" << endl;
	print_array(p1);
	p1.append(1);
	p1.append(2);
	print_array(p1);

	cout << "\n---------- 末尾添加数组 ----------" << endl;
	print_array(p1);
	int normal_array[4] = { 44, 55, 66, 77 };
	p1.extend(normal_array, sizeof(normal_array)/ sizeof(normal_array[0]));
	print_array(p1);

	cout << "\n---------- 末尾删除元素 ----------" << endl;
	print_array(p1);
	p1.pop();
	print_array(p1);
}

void test02()
{
	cout << "\n\ntest02开始\n" << endl;
	MyArray<int> p1(6);
	int normal_array[4] = {11, 22, 33, 44};
	p1.extend(normal_array, sizeof(normal_array) / sizeof(normal_array[0])); // extend函数重载
	print_array(p1);
	MyArray<int> p2(p1);	// 拷贝构造函数
	print_array(p2);
	MyArray<int>p3(6);
	p3 = p1;				// = 赋值重载
	print_array(p3);
	p3.extend(p1);			// extend函数重载
	p3[1] = 666;
	print_array(p3);
}

void test03()
{
	cout << "\n\ntest03开始\n" << endl;
	MyArray<Person> p1(3);		// 会用到无参构造，当自己写有参构造后，系统默认的无参构造不再提供
	Person stu1("张三", 10);
	Person stu2("李四", 8);
	Person stu3("王五", 12);
	p1.append(stu1);
	p1.append(stu2);
	p1.append(stu3);
	print_array(p1);
}

int main()
{
	test01();
	test02();
	test03();
	system("pause");
	return 0;
}

每段代码详细分析

  • 定义一个Person类，用于测试当数组元素为自定义类型Person时，类模板的各部分是否正常。
  • 之所以要写无参构造函数，是因为后面测试中MyArray <Person> p1(3); 会用到无参构造。当重写了有参构造后，默认的无参构造系统不再提供，所以要自己实现。
class Person
{
public:
	string m_name;
	int m_age;
public:
	Person() 
	{
		//cout << "Person无参构造" << endl;
	}
	Person(string name, int age)
	{
		//cout << "Person有参构造" << endl;
		m_name = name;
		m_age = age;
	}
};
  • 定义类模板，其中将要用到的数组的元素类型用模板参数T
  • template<class T1> friend void print_array(T1 ref_array); 声明友元函数，这个友元是一个函数模板。
  • friend void print_array(MyArray& ref_array); 普通友元函数的声明。
template<class T>
class MyArray
{
	// 函数模板作为类模板的友元，可以直接把函数的定义部分拷贝进来
	template<class T1>
	friend void print_array(T1 ref_array);
	friend void print_array(MyArray<Person>& ref_array);
private:
	int m_capacity;	// 为数组开辟的内存大小,有些空间不一定有元素
	int m_size;		// 数组中元素的个数
	T *m_p_array;	// 数组的首地址
  • 有参构造中有形参capacity，用于创建对象时，在堆区开辟空间确定空间大小。
  • 拷贝构造为了在使用已经存在的对象创建初始化新对象时使用，因为有空间开辟在堆区，不能使用默认的拷贝构造函数，否则会引起堆区内存重复释放的问题，所以要在拷贝构造函数中实现深拷贝，重新为新的对象开辟堆区空间。
  • 同时将已有对象中的元素进行拷贝。
public:
	MyArray(int capacity)		// 有参构造
	{
		//cout << "有参构造调用" << endl;
		m_capacity = capacity;
		m_size = 0;
		m_p_array = new T[m_capacity];
	}
	
	MyArray(const MyArray& ref_array)		// 拷贝构造
	{
		//cout << "拷贝构造调用" << endl;
		m_capacity = ref_array.m_capacity;
		m_size = ref_array.m_size;
		m_p_array = new T[ref_array.m_capacity];	// 开辟好内存空间
		// 数组中的元素也进行拷贝
		for (int i_loop = 0; i_loop < ref_array.m_size; i_loop++)
		{
			m_p_array[i_loop] = ref_array.m_p_array[i_loop];
		}
	}
  • 赋值运算符=重载，在对象之间互相赋值操作时，要用到=，为了实现连续赋值，返回值需要是对象本身的引用，*this的引用。
  • 在赋值前，如果赋值目标中原来有数据，先都删除，堆区内存释放，然后再在堆区开辟空间，进行数组中元素的赋值操作。
	MyArray& operator=(const MyArray& ref_array)	// 实现连等，返回必须是MyArray& 
	{
		//cout << "=运算符重载" << endl;
		// 如果赋值目标对象中原来有数据，先都删除掉，包括堆区内存也要释放，然后再赋值
		if (m_p_array != NULL)
		{
			delete[] m_p_array;
			m_p_array = NULL;
			m_capacity = 0;
			m_size = 0;
		}
		m_capacity = ref_array.m_capacity;
		m_size = ref_array.m_size;
		m_p_array = new T[ref_array.m_capacity];	// 开辟好内存空间
		for (int i_loop = 0; i_loop < m_size; i_loop++)
		{
			m_p_array[i_loop] = ref_array.m_p_array[i_loop];
		}
		return *this;
	}
  • 运算符[]重载，可以使用对象直接访问其属性中维护的指针指向的数组中的内容。
  • 返回引用，使得可以对a[]进行赋值操作，直接操作a[]，而不是返回a[]的副本。
	T& operator[](int idx)		// 如果要作为左值，返回引用,如a[5]=3;
	{
		//cout << "[]运算符重载" << endl;
		return m_p_array[idx];
	}
  • append在末尾添加元素，当m_capacity已满，说明给数组开辟的内存已经占满了，不能再添加数据。
  • pop删除末尾元素，当m_size=0时，数组里已经没元素了，否则，将m_size-1。
void append(T append_data)
	{
		if (m_size == m_capacity)
		{
			cout << "没有空间可以添加元素了" << endl;
			return;
		}
		else
		{
			m_p_array[m_size] = append_data;
			m_size += 1;
		}
	}

	void pop()
	{
		if (m_size == 0)
		{
			cout << "没有元素可以删除了" << endl;
			return;
		}
		else
		{
			m_size --;
		}
	}
  • extend函数是在数组的末尾拼接一个数组。
  • 要么是拼接普通的数组，要么是拼接一个对象维护的数组。
  • 按照传参进行函数的重载。
void extend(T* normal_array, int array_len) // 函数重载，添加普通的数组元素，不用创建类对象
	{
		cout << "extend(T* normal_array, int array_len)" << endl;
		int i_loop = 0;
		if (m_size == m_capacity)
		{
			cout << "数组容量已满，不能再拼接任何数组" << endl;
			return;
		}
		else if ((m_size + array_len) > m_capacity)
		{
			cout << "添加所有会导致容量超标，只能添加部分元素" << endl;
		}
		for (i_loop = 0; i_loop < array_len; i_loop++)
		{
			if (m_size + i_loop == m_capacity)
			{
				break;
			}
			m_p_array[m_size+ i_loop] = normal_array[i_loop];
		}
		m_size += i_loop;
	}
	
	void extend(MyArray& ref_array)		// 函数重载，添加类对象中的数组元素
	{
		cout << "void extend(MyArray& ref_array)" << endl;
		int i_loop = 0;
		if (m_size == m_capacity)
		{
			cout << "数组容量已满，不能再拼接任何数组" << endl;
			return;
		}
		else if ((m_size + ref_array.m_size) > m_capacity)
		{
			cout << "添加所有会导致容量超标，只能添加部分" << endl;
		}

		for (i_loop = 0; i_loop < ref_array.m_size; i_loop++)
		{
			if (m_size + i_loop == m_capacity)
			{
				break;
			}
			m_p_array[m_size + i_loop] = ref_array.m_p_array[i_loop];
		}
		m_size += i_loop;
	}
  • 析构函数，注意删除数组的方法。
  • 同时将m_capacity =0，m_size=0。
	~MyArray()
	{
		//cout << "析构函数调用" << endl;
		if (m_p_array != NULL)
		{
			delete[] m_p_array;
			m_p_array = NULL;
		}
		m_capacity = 0;
		m_size = 0;
	}
  • 打印数组信息，这两个函数是全局函数，声明为友元，可以访问类中的私有成员。
  • 函数模板声明成友元，template这句也要在友元中，为了避免T的混乱，可以重新叫个名字。
template<class T>
void print_array(T ref_array)
{
	cout << "capacity: " << ref_array.m_capacity << ", size: " << ref_array.m_size << endl;
	for (int i_loop = 0; i_loop < ref_array.m_size; i_loop++)
	{
		cout << ref_array[i_loop];
		if (i_loop < ref_array.m_size - 1)
		{
			cout << ", ";
		};
	}
	cout << endl;
}

// 已经声明为友元，可以直接访问MyArray对象的私有成员变量
void print_array(MyArray<Person> &ref_array)
{
	cout << "capacity: " << ref_array.m_capacity << ", size: " << ref_array.m_size << endl;
	for (int i_loop = 0; i_loop < ref_array.m_size; i_loop++)
	{
		cout << "name: " << ref_array[i_loop].m_name << ", age: " << ref_array[i_loop].m_age << endl;
	}
	cout << endl;
}
weixin_48668114
关注
  • 14
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++类模板案例.zip
08-11
本案例将深入探讨如何利用C++类模板实现泛型编程，以及如何处理数组等数据结构。 首先，我们来看类模板的基本语法。类模板定义时，我们用`template`关键字，后面跟着尖括号`<typename T>`，其中`T`是一个类型参数，...
C++ 类模板案例实践
03-12
实现一个通用的数组类，要求如下： * 可以对内置数据类型以及自定义数据类型的数据进行存储 * 将数组中的数据存储到堆区 * 构造函数中可以传入数组的容量 * 提供对应的拷贝构造函数以及operator=防止浅拷贝问题 * ...
18 模板-类模板案例-数组类封装（下）
12-15
18 模板-类模板案例-数组类封装（下）
17 模板-类模板案例-数组类封装（上）
12-15
17 模板-类模板案例-数组类封装（上）
16 模板-类模板案例-数组类封装的需求分析
12-15
16 模板-类模板案例-数组类封装的需求分析
【C/C++】C++程序设计基础（输入输出、数据类型、动态内存、函数重载、内联函数、常量、引用）
强者征服今天，懦夫哀叹昨天，懒汉坐等明天。
08-28 388
在后面的章节中，会讲到类与对象，欢迎各位的关注~
C++ 重载运算符和重载函数
lly202406的博客
08-25 934
在C++编程语言中，运算符重载和函数重载是两个非常核心的概念，它们允许开发者扩展或重新定义运算符和函数的行为，以适应特定的数据类型或对象。本文将详细探讨C++中的运算符重载和函数重载，包括它们的基本概念、使用场景、实现方式以及注意事项。
C语言破墙镐对称飞迷宫
qq_69383179的博客
08-22 1784
这里有我用C语言编译的破墙镐对称飞迷宫和与之相关的一些东西
初识顺序表---C语言
weixin_74202161的博客
08-23 677
顺序表是一种以数组为基础的结构，对数组进行封装，实现常用的增删改查等操作的。//销毁。
＜C++＞ 多态
prodigy623的博客
08-24 1167
多态的细节
适用于 Visual Studio 的 C++ 万能头
Xi Xu 的博客
08-25 422
修改版本是根据 GNU General Public License v3.0 or later 分发的。原始文件是根据 GNU General Public License v3.0 or later 分发的。用于在 Visual Studio 上预编译的 C++ 包含。文件的修改版本，与 Visual Studio 兼容。此文件是 GCC 13.1.0 中。此文件的配置方法可在互联网上搜索。修改由本文作者完成。
C++的内存模型
qhu1600417010的博客
08-28 630
C++ 的内存模型包含了程序运行时如何分配、访问、管理内存的规则，涵盖了多线程环境下的数据一致性、内存对齐、以及虚拟内存管理等内容。掌握这些概念对于编写高效、安全的 C++ 程序至关重要。
C++中完美转发std::forward的一点点分析
qq_41596730的博客
08-25 677
这一节我们分析了的调用流程，一步一步展示了其调用过程。但是还有很重要的一点是：没有提出一个必须要使用的场景，也就是说，学了这么多，不知道在什么时候使用。等日后遇到了补上吧。
Linux编程： 使用 C++ 监控进程和线程的 CPU 使用情况
Where there is life, there is hope.
08-25 725
在 Linux 系统中，监控进程和线程的 CPU 使用情况可以帮助我们找出系统瓶颈和性能热点。本文将介绍两种方法使用 C++ 来监控 Linux 系统中进程和线程的 CPU 使用情况。
Dijkstra(c++)
weixin_73378557的博客
08-24 689
迪杰斯特拉算法(Dijkstra)是由荷兰计算机科学家狄克斯特拉于1959年提出的，因此又叫狄克斯特拉算法。是从一个顶点到其余各顶点的最短路径算法，解决的是有权图中最短路径问题。迪杰斯特拉算法主要特点是从起始点开始，采用贪心算法的策略，每次遍历到始点距离最近且未访问过的顶点的邻接节点，直到扩展到终点为止。同时dijkstra算法主要用于解决单源最短路问题（边权为正数），其可以分为两种版本，两种版本各有用处，并不存在好坏之分，接下来我们用n代表点的数量，用m代表边的数量。
坐牢第三十天（c++）
m0_62828714的博客
08-27 1483
提示并输入一个字符串，统计该字符串中字母个数、数字个数、空格个数、其他字符的个数 效果图：
C++：list篇
2301_80894970的博客
08-27 834
我们可以看到，当erase后如果在对it迭代器进行操作，vs则会进行强制检查(根据编译环境不同，处理环境也不相同),则不允许再继续使用,如果想继续使用的话，C++同样也给出了方案，可以看到erase会返回一个迭代器，而返回的迭代器就是下一个链表的位置。那么从上面的begin与end可以看出，使用迭代器遍历list，仅仅只需要解引用迭代器以及++迭代器就能取得我们想要的值与让迭代器走向下一个节点，那么有没有想过一个问题，list的迭代器与vector这种类似数组的迭代器底层是否是一样的呢？
【并查集/C++】1013 Battle Over Cities (25分)
JeredYe的博客
08-28 647
【并查集/C++】1013 Battle Over Cities (25分)
8.28（C++&QT）C++绪论 数据类型--作业
最新发布
weixin_69367386的博客
08-28 87
【代码】8.28（C++&QT）C++绪论 数据类型--作业。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值