myTamplate.h
#ifndef MYTAMPLATE_H
#define MYTAMPLATE_H
#include <iostream>
using namespace std;
template<typename T>
class Node
{
T *data; //数据域
int size; //指针域
int len;//实际长度
public:
//无参构造
Node():size(10),len(0)
{
data = new T[size]();
}
//有参构造
Node(T e);
//析构函数
~Node()
{
delete []data;
}
//给容器适配器赋值
Node &operator=(Node &other);
//访问第一个元素
T front_element();
//二倍扩容
void double_fold();
//判断是否为空
bool empty();
//头插
bool head_push(T e);
//头删
bool head_pop();
//尾插
bool tail_push(T e);
//尾删
bool tail_pop();
//访问任意一个元素
T at(int index);
//返回实际大小
int my_len();
//返回开辟空间
int my_size();
//遍历
void show();
};
//有参构造
template<typename T>
Node<T>::Node(T e) : size(10), len(1) {
data = new T[size]();
data[0] = e; // 初始化第一个元素
}
template<typename T>
//给容器适配器赋值
Node<T> &Node<T>::operator=(Node &other)
{
if(this!=other)
{
delete []data;
this->size = other.size;
this->len = other.len;
data = new T[size]();
for(int i = 0;i<size;i++)
{
data[i] = other.data[i];
}
}
return *this;
}
//访问第一个元素 Node<T>::front_element()
template<typename T>
T Node<T>::front_element()
{
return data[0];
}
//判断是否为空
template<typename T>
bool Node<T>::empty()
{
return len == 0;
}
//头插
template<typename T>
bool Node<T>::head_push(T e)
{
len++;
double_fold();
//循环前移
for(int i = len;i>0;i--)
{
data[i] = data[i-1];
}
data[0] = e;
return true;
}
//头删
template<typename T>
bool Node<T>::head_pop()
{
if(len<=0)
{
cout<<"没有数据"<<endl;
return false;
}else
{
for(int i=0;i<len-1;i++)
{
data[i] = data[i+1];
}
//data[len-1]=NULL;//第len-1个置空
len--;
return true;
}
}
//尾插
template<typename T>
bool Node<T>::tail_push(T e)
{
len++;
double_fold();
data[len-1] = e;
return true;
}
//尾删
template<typename T>
bool Node<T>::tail_pop()
{
if(len<=0)
{
cout<<"没有数据"<<endl;
return false;
}else
{
//data[len-1]=NULL;
len--;
return true;
}
}
//访问任意一个元素
template<typename T>
T Node<T>::at(int index)
{
if(index<0 ||index>len)
{
cout<<"参数错误"<<endl;
return 0;
}
else
{
return data[index-1];
}
}
//返回实际大小
template<typename T>
int Node<T>::my_len()
{
return len;
}
//返回开辟空间
template<typename T>
int Node<T>::my_size()
{
return size;
}
//遍历
template<typename T>
void Node<T>::show()
{
for(int i=0;i<len ;i++)
{
cout<<data[i]<<" ";
}
cout<<endl;
}
//二倍扩容
template<typename T>
void Node<T>::double_fold()
{
if(len >=size)
{
T *temp = new T[size * 2]();
for(int i = 0;i<size;i++)
{
temp[i] = data[i];
}
delete[] data;
data = temp;
size *= 2;
}
}
#endif // MYTAMPLATE_H
main.cpp
#include "myTamplate.h"
int main() {
Node<int> intNode(5); // 使用有参构造函数
// 测试头插
intNode.head_push(1);
cout << "头插1后: ";
intNode.show();
// 测试头删
intNode.head_pop();
cout << "头删后: ";
intNode.show();
// 测试尾插
intNode.tail_push(2);
intNode.tail_push(3);
intNode.tail_push(4);
cout << "尾插2, 3, 4后: ";
intNode.show();
// 测试尾删
intNode.tail_pop();
cout << "尾删后: ";
intNode.show();
// 测试访问第一个元素
cout << "第一个元素: " << intNode.front_element() << endl;
// 测试判断是否为空
cout << "是否为空: " << (intNode.empty() ? "是" : "否") << endl;
// 测试访问任意一个元素
cout << "索引1处的元素: " << intNode.at(1) << endl;
// 测试返回实际大小
cout << "实际大小: " << intNode.my_len() << endl;
// 测试遍历
cout << "遍历元素: ";
intNode.show();
cout<<"*******************下面是字符串类型******************"<<endl;
// 创建一个字符串类型的Node容器
Node<string> strNode("第一个"); // 使用有参构造函数
// 测试头插
strNode.head_push("第一个");
cout << "头插 '第一个' 后: ";
strNode.show();
// 测试头删
strNode.head_pop();
cout << "头删后: ";
strNode.show();
// 测试尾插多个字符串
strNode.tail_push("第二个");
strNode.tail_push("第三个");
strNode.tail_push("第四个");
cout << "尾插 '第二个', '第三个', '第四个' 后: ";
strNode.show();
// 测试尾删
strNode.tail_pop();
cout << "尾删后: ";
strNode.show();
// 测试访问第一个元素
cout << "第一个元素: " << strNode.front_element() << endl;
// 测试判断是否为空
cout << "是否为空: " << (strNode.empty() ? "是" : "否") << endl;
// 测试访问任意一个元素
cout << "索引1处的元素: " << strNode.at(1) << endl;
// 测试返回实际大小
cout << "实际大小: " << strNode.my_len() << endl;
// 测试遍历
cout << "遍历元素: ";
strNode.show();
return 0;
}
代码展示
