线性表实现--数组描述，vector描述，链表描述

最新推荐文章于 2024-11-02 20:20:37 发布
最新推荐文章于 2024-11-02 20:20:37 发布
阅读量185 收藏
点赞数
分类专栏： C++之巩固提高 文章标签： c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53953432/article/details/128001148
版权

文章目录


加深了解线性表，跟书上敲了一遍，了解一下线性表的实现，异常类出错有点多，后期学底层时候，再回来好好看看

线性表实现-数组描述

//#pragma once
#ifndef _数组_
#define _数组_

#include<iostream>
using namespace std;
#include<algorithm>
#include<exception>//异常处理头文件
#include<string>
#include<sstream>//ostringstream的头文件


class illegalParameterValue//异常类
{
public:
	illegalParameterValue(string theMessage = "Illegal parameter value")
	{
		message = theMessage;
	}
	void outputMessage() { cout << message << endl; }
private:
	string message;
};


// illegal index
class illegalIndex
{
public:
	illegalIndex(string theMessage = "Illegal index")
	{
		message = theMessage;
	}
	void outputMessage() { cout << message << endl; }
private:
	string message;
};



template<class T>
class linearList
{
public:
	virtual ~linearList() {};
	virtual bool empty() const = 0;//表示纯虚函数，const不能修改其数据成员 // 空返回1
	virtual int size() const = 0;//返回元素个数
	virtual T& get(int theIndex) const = 0;//返回索引为theIndex的元素
	virtual int indexOf(const T& theElement)const = 0;//返回元素theELement第一次出现的时候的索引
	virtual void erase(int theIndex) = 0;//删除索引为theIndex的元素
	virtual void insert(int theIndex, const T& theElemet) = 0;//把theELement插入到索引为theIndex的位置上
	virtual void output(ostream& out)const = 0;//把线性表插入输出流out
};


//定义派生类
template<class T>
class arrayList : public linearList<T>
{
	friend ostream& operator<<(ostream& out, const arrayList<T>& x);
public:
	arrayList(int initialCapacity = 10);//普通构造函数
	arrayList(const arrayList<T>&);//拷贝构造
	~arrayList() { delete[] element; }

	//ADT(抽象数据类型)方法
	bool empty() const { return listSize == 0; }
	int size() const { return listSize; }
	T& get(int theIndex) const;
	int indexOf(const T& theElement)const;
	void erase(int theIndex);
	void insert(int theIndex, const T& theElemet);
	void output(ostream& out)const;

	//其他方法
	int capacity() { return arrayLength; }
	void changeLength1D(T*& a, int oldLength, int newLength);

protected:
	void checkIndex(int theIndex)const;//若索引无效，则抛出异常
	T* element;//存储线性表元素的一维数组
	int arrayLength;//一维数组的容量
	int listSize;//线性表的元素个数
};

//修改数组长度
template<class T>
void arrayList<T>::changeLength1D(T*& a, int oldLength, int newLength)
{
	if (newLength < 0)
		throw illegalParameterValue("newlength must be >= 0");

	T* temp = new T[newLength];
	int number = min(oldLength, newLength);
	copy(a, a + number, temp);
	delete[] a;
	a = temp;
}


template<class T> //普通构造函数类外实现
arrayList<T>::arrayList(int initialCapacity)
{
	if (initialCapacity < 1)
	{
		ostringstream s;
		s << "Initial capacity =" << initialCapacity << "Must be > 0";
		throw illegalParameterValue(s.str()); //str()将ostringstream转换为string
	}

	arrayLength = initialCapacity;
	element = new T[arrayLength];
	listSize = 0;
}

template<class T>//拷贝构造函数类外实现
arrayList<T>::arrayList(const arrayList<T>& theList)
{
	arrayLength = theList.arrayLength;
	listSize = theList.listSize;
	element = new T[arrayLength];
	copy(theList.element, theList.element + listSize, element);
}



template<class T>//checkIndex函数类外实现
void arrayList<T>::checkIndex(int theIndex)const
{
	if (theIndex < 0 || theIndex >= listSize)
	{
		ostringstream s;
		s << "index = " << theIndex << "size = " << listSize;
		throw illegalIndex(s.str());
	}
}

template<class T>//get函数类外实现
T& arrayList<T>::get(int theIndex)const
{
	checkIndex(theIndex);
	return element[theIndex];
}

template<class T>//indexOf函数类外实现
int arrayList<T>::indexOf(const T& theElement)const
{
	int theIndex = (int)(find(element, element + listSize, theElement) - element);//find如果没找到会返回end，所以减去begin就是listsize

	if (theIndex == listSize) return -1;
	else return theIndex;
}

//template<class T>//erase函数类外实现
//void arrayList<T>::erase(int theIndex)
//{
//	checkIndex(theIndex);
//	copy(element + theIndex + 1, element + listSize, element + theIndex);
//	element[--listSize].~T();//调用析构函数
//}


template<class T>//insert函数类外实现
void arrayList<T>::insert(int theIndex, const T& theElement)
{
	checkIndex(theIndex);
	if (listSize == arrayLength)
	{
		changeLength1D(element, arrayLength, 2 * arrayLength);
		arrayLength *= 2;
	}

	copy_backward(element + theIndex, element + listSize, element + listSize + 1);
	element[theIndex] = theElement;
	listSize++;
}

//打印线性表
template<class T>
void arrayList<T>::output(ostream &out)const
{
	copy(element, element + listSize, ostream_iterator<T>(out, " "));
}
template<class T>
ostream& operator<<(ostream& out, const arrayList<T>& x)
{
	x.output(out);
	return out;
}

//改进erase函数
template<class T>//erase函数类外实现
void arrayList<T>::erase(int theIndex)
{
	checkIndex(theIndex);
	copy(element + theIndex + 1, element +` listSize, element + theIndex);

	if (listSize < arrayLength / 4)
	{
		changeLength1D(element, arrayLength, arrayLength / 2);//减少释放数组空间
	}

	element[--listSize].~T();//调用析构函数
}

#endif // !_数组_

线性表实现-vector描述

#ifndef _vectorList_
#define _vectorList_

#include<iostream>
using namespace std;

#include<algorithm>
#include<exception>
#include<string>
#include<sstream>
#include<vector>

class illegalParameterValue
{
public:
	illegalParameterValue(string theMessage = "Illegal parameter value")
	{
		message = theMessage;
	}
	void outputMessage() { cout << message << endl; }
private:
	string message;
};
// illegal index
class illegalIndex
{
public:
	illegalIndex(string theMessage = "Illegal index")
	{
		message = theMessage;
	}
	void outputMessage() { cout << message << endl; }
private:
	string message;
};

template<class T>
class linearList
{
public:
	virtual ~linearList() {};
	virtual bool empty() const = 0;//表示纯虚函数，const不能修改其数据成员 // 空返回1
	virtual int size() const = 0;//返回元素个数
	virtual T& get(int theIndex) const = 0;//返回索引为theIndex的元素
	virtual int indexOf(const T& theElement)const = 0;//返回元素theELement第一次出现的时候的索引
	virtual void erase(int theIndex) = 0;//删除索引为theIndex的元素
	virtual void insert(int theIndex, const T& theElemet) = 0;//把theELement插入到索引为theIndex的位置上
	virtual void output(ostream& out)const = 0;//把线性表插入输出流out
};

template<class T>
class vectorList : public linearList<T>
{
public:
	vectorList(int initialCapcity = 10);
	vectorList(const vectorList<T>&);
	~vectorList() { delete element; }

	//Adt
	bool empty() const { return element->empty(); }
	int size() const { return element->size(); }
	T& get(int theIndex) const;
	int indexOf(const T& theElement)const;
	void erase(int theIndex);
	void insert(int theIndex, const T& theElemet);
	void output(ostream& out)const;

	//其他方法
	int capacity() { return element->capacity(); }
	
	//线性表的起始和结束位置的迭代器
	typedef typename vector<T>::iterator iterator;
	iterator begin() { return element->begin(); }
	iterator end() { return element->end(); }

protected:
	void checkIndex(int theIndex)const;
	vector<T>* element;//存储线性表元素的向量
};

//数组的长度是动态增长的

//构造函数
template<class T>
vectorList<T>::vectorList(int initialCapacity)
{
	if (initialCapacity < 1) {
		ostringstream s;
		s << "Initial capacity =" << initialCapacity << "Must be > 0";
		throw illegalParameterValue(s.str()); //str()将ostringstream转换为string
	}
	element = new vector<T>;
	element->reserve(initialCapacity);//扩容到规定容量
}

template<class T>
vectorList<T>::vectorList(const vectorList<T>& theLIst)
{
	element = new vector<T>(*theLIst.element);//定义里面是指针
}

template<class T>//checkIndex函数类外实现
void vectorList<T>::checkIndex(int theIndex)const
{
	if (theIndex < 0 || theIndex >= size())
	{
		ostringstream s;
		s << "index = " << theIndex << "size = " << size();
		throw illegalIndex(s.str());
	}
}


template<class T>//get函数类外实现
T& vectorList<T>::get(int theIndex)const
{
	checkIndex(theIndex);
	return element[theIndex];
}

template<class T>//indexOf函数类外实现
int vectorList<T>::indexOf(const T& theElement)const
{
	int theIndex = (int)(find(element, element + size(), theElement) - element);//find如果没找到会返回end，所以减去begin就是listsize

	if (theIndex == size()) return -1;
	else return theIndex;
}

template<class T>//erase函数类外实现
void vectorList<T>::erase(int theIndex)
{
	checkIndex(theIndex);
	element->erase(begin() + theIndex);
}

template<class T>//insert函数类外实现
void vectorList<T>::insert(int theIndex, const T& theElement)
{
	checkIndex(theIndex);
	element->insert(element->begin() + theIndex, theElement);
}

//打印线性表
template<class T>
void vectorList<T>::output(ostream& out)const
{
	copy(element, element + size(), ostream_iterator<T>(out, " "));
}
template<class T>
ostream& operator<<(ostream& out, const vectorList<T>& x)
{
	x.output(out);
	return out;
}



#endif // !_vectorList_

线性表实现–链表

#ifndef _chain_
#define _chain_

#include<iostream>
using namespace std;

#include<algorithm>
#include<exception>
#include<sstream>


class illegalParameterValue//异常类
{
public:
	illegalParameterValue(string theMessage = "Illegal parameter value")
	{
		message = theMessage;
	}
	void outputMessage() { cout << message << endl; }
private:
	string message;
};


// illegal index
class illegalIndex
{
public:
	illegalIndex(string theMessage = "Illegal index")
	{
		message = theMessage;
	}
	void outputMessage() { cout << message << endl; }
private:
	string message;
};

//定义父类
template<class T>
class linearList
{
public:
	virtual ~linearList() {};
	virtual bool empty() const = 0;//表示纯虚函数，const不能修改其数据成员 // 空返回1
	virtual int size() const = 0;//返回元素个数
	virtual T& get(int theIndex) const = 0;//返回索引为theIndex的元素
	virtual int indexOf(const T& theElement)const = 0;//返回元素theELement第一次出现的时候的索引
	virtual void erase(int theIndex) = 0;//删除索引为theIndex的元素
	virtual void insert(int theIndex, const T& theElemet) = 0;//把theELement插入到索引为theIndex的位置上
	virtual void output(ostream& out)const = 0;//把线性表插入输出流out
};

//定义节点
template<class T>
class chainNode
{
private:
	//数据成员
	T element;
	chainNode<T>* next;

public:
	//方法
	chainNode() {}
	chainNode(const T& element)
	{
		this->element = element;
	}
	chainNode(const T& element, chainNode<T>* next)
	{
		this->element = element;
		this->next = next;
	}
};

//定义结构
template<class T>
class chain :public linearList<T>
{
public:
	chain(int initialCapacity = 10);//普通构造函数
	chain(const chain<T>&);//拷贝构造
	~chain();//析构

	//ADT(抽象数据类型)方法
	bool empty() const { return listSize == 0; }
	int size() const { return listSize; }
	T& get(int theIndex) const;
	int indexOf(const T& theElement)const;
	void erase(int theIndex);
	void insert(int theIndex, const T& theElemet);
	void output(ostream& out)const;

	//其他方法
	int capacity() { return arrayLength; }
	void changeLength1D(T*& a, int oldLength, int newLength);

protected:
	void checkIndex(int theIndex)const;//若索引无效，则抛出异常
	chainNode<T>* firstNode;//第一个节点指针
	int listSize;//线性表元素个数
};

template<class T>
chain<T>::chain(int initialCapacit)
{
	if (initialCapacity < 1)
	{
		ostringstream s;
		s << "Initial capacity =" << initialCapacity << "Must be > 0";
		throw illegalParameterValue(s.str()); //str()将ostringstream转换为string
	}
firstNode = NULL;
listSize = 0;
}

template<class T>
chain<T>::chain(const chain<T>& theList)//拷贝构造
{
	listSize = theList.listSize;

	if (listSize == 0) //链表为空
	{
		firstNode = NULL;
		return;
	}

	//不为空
	chainNode<T>* sourceNode = theList.fistNode;
	firstNode = new chainNode<T>(sourceNode->element);
	sourceNode = sourceNode->next;
	chainNode<T>* targetNode = firstNode;

	while (sourceNode != NULL)
	{
		targetNode->next = new chainNode<T>(sourceNode->element);
		targetNode = targetNode->next;
		sourceNode = sourceNode->next;
	}
	targetNode->next = NULL;
}

//析构函数
template<class T>
chain<T>::~chain()
{
	while (firstNode != NULL)
	{
		chainNode<T>* nextNode = firstNode->next;
		delete firstNode;
		firstNode = nextNode;
	}
}


template<class T>//checkIndex函数类外实现
void chain<T>::checkIndex(int theIndex)const
{
	if (theIndex < 0 || theIndex >= size())
	{
		ostringstream s;
		s << "index = " << theIndex << "size = " << size();
		throw illegalIndex(s.str());
	}
}

template<class T>
T& chain<T>::get(int theIndex)const
{
	checkIndex(theIndex);

	chainNode<T>* currentNode = firstNode;
	for (int i = 0; i < theIndex; i++)
	{
		currentNode = currentNode->next;
	}
	return currentNode->next;
}

template<class T>
int chain<T>::indexOf(const T& theElement)const
{
	chainNode<T>* currentNode = firstNode;
	int index = 0;//当前节点的索引
	while (currentNode != NULL && currentNode->element != theElement)
	{
		currentNode = currentNode->next;
		index++;
	}
	if (currentNode == NULL)
	{
		return -1;
	}
	else
		return index;
}

template<class T>
void chain<T>::erase(int theIndex)
{
	checkIndex(theIndex);

	chainNode<T>* deleteNode;
	if (theIndex == 0)
	{
		deleteNode = firstNode;
		firstNode = firstNode->next;
	}
	else
	{
		chainNode<T>* p = firstNode;
		for (int i = 0; i < theIndex - 1; i++)
		{
			p = p->next;
		}
		deleteNode = p->next;
		p->next = p->next->next;
	}
	listSize--;
	delete deleteNode;
}

template<class T>
void chain<T>::insert(int theIndex, const T& theElement)
{
	checkIndex(theIndex);
	
	if (theIndex == 0)
	{
		firstNode = new chainNode<T>(theElement, firstNode);//next  -> firstNode
	}
	else
	{
		chainNode<T>* p = firstNode;
		for (int i = 0; i < theIndex - 1; i++)
		{
			p = p->next;
		}
		p->next = new chainNode<T>(theElement, p->next);
	}
	listSize++;
}

template<class T>
void chain<T>::output(ostream& out)const
{
	for (chainNode<T>* currentNode = firstNode; currentNode != NULL; currentNode = currentNode->next)
	{
		cout << currentNode->element << " ";
	}
}
template<class T>
ostream& operator<<(ostream& out, const chain<T>& x)
{
	x.output(out);
	return out;
}


//迭代器
template<class T>
class iterator
{
public:
	iterator(chainNode<T>* theNode = NULL) {
		node = theNode;
	}

	T& operator*()const { return node->element; }
	T* operator->()const { return &node->element; }

	iterator& operator++()
	{
		node = node->next;
		return *this;
	}
	iterator operator++(int)
	{
		iterator old = *this;
		node = node->next;
		return *this;
	}

	bool operator !=(const iterator right)const
	{
		return node != right.node;
	}
	bool operator ==(const iterator right)const
	{
		return node == right.node;
	}


protected:
	chainNode<T>* node;
};


#endif
华氏451度。
关注
专栏目录
cpp代码-线性表的数组存储，实现了快速排序，用vector存储数据
07-16
在本文中，我们将深入探讨C++编程中关于线性表的数组存储以及快速排序算法的实现，这些都是在软件开发中非常基础且重要的概念。线性表是数据结构的基础，而快速排序则是高效的排序算法之一。 首先，让我们了解...
C++ 数据结构线性表-数组实现
08-30
总的来说，C++中的线性表数组实现涉及到了动态内存分配、对象生命周期管理、数组操作以及基本数据结构的操作方法实现。这样的实现允许高效地访问和修改数组内的元素，但由于数组大小固定，插入和删除操作在表满或...
C++实现线性表 - 01 数组
Newin2020的博客
02-21 3659
数据结构与算法C++代码实现之线性表数组部分
java 数组线性表_线性表--数组、单链表、双链表(C/C++/Java)
weixin_36469682的博客
03-05 93
线性表是一种线性结构，它是具有相同类型的n(n≥0)个数据元素组成的有限序列。本章介绍线性表的几个基本组成部分：数组、单向链表、双向链表；并给出双向链表的C/C++/Java的实现源码。数组数组有上界和下界，数组的元素在上下界内是连续的。存储10,20,30,40,50的数组的示意图如下：数组的特点是：数据是连续的；随机访问速度快。数组中稍微复杂一点的是多维数组和动态数组。对于C语言而言，多维数组...
【线性表】- 数组
weixin_39303983的博客
05-04 412
数组（Array）是一种线性表数据结构。它用一组连续的内存空间，来存储一组具有相同类型的数据。 代码随想录-数组理论基础 1如何实现随机访问？ 1.1 线性表（Linear List） 线性表就是数据排成像一条线一样的结构。每个线性表上的数据最多只有前和后两个方向。其实除了数组，链表、队列、栈等也是线性表结构。 非线性表，比如二叉树、堆、图等。之所以叫非线性，是因为，在非线性表中，数据之间并不是简单的前后关系。 1.2 连续的内存空间和相同类型的数据 正是因为这两个限制，.
线性表 - 数组
生活需要深度
02-13 1422
线性表是一种线性结构，它是具有相同类型的n(n≥0)个数据元素组成的有限序列。本章先介绍线性表的几个基本组成部分：数组、单向链表、双向链表。 1. 数组 数组有上界和下界，数组的元素在上下界内是连续的。数组中稍微复杂一点的是多维数组和动态数组。对于C语言而言，多维数组本质上也是通过一维数组实现的。至于动态数组，是指数组的容量能动态增长的数组；对于C语言而言，若要提供动态数组，需要手动实现；而对于C++而言，STL提供了Vector；对于Java而言，Collection集合中提供了ArrayList和V
【数据结构C++】线性表/顺序表-数组与vector
JingYan_Chan的博客
03-12 1206
在数据结构专栏（本专栏）中，我们将总结数据结构与算法的理论知识和结合LEETCODE相关题目的应用，旨在将零散的知识点按章节形成系统的知识库，并将知识应用于代码编写中。因为数组的在内存空间的地址是连续的，所以我们在删除或者增添元素的时候，就难免要移动其他元素的地址。数组的元素是不能删的，只能覆盖。支持随机访问：用户可以向使用数组的方式访问vector中的每一个元素，但vector不适宜做任意位置的插入和删除操作，因为要进行大量元素的搬移，比如插入。C++数组C++ vector用法详解。
数据结构之线性表(C++)---数组描述
Xefvan的博客
09-30 2276
数据结构之线性表—数组描述前面我写了几节二叉树，现在想想还是回过头来吧线性表写了概述C++里提供了强大的STL（标准模板库），而且很多大神和相关书籍多提倡我们使用STL，切勿盲目自己写，这样反而效率更低。但是在使用STL的同时，能够了解如何实现简单的STL是很爽的。C++程序常用的数据描述方式是数组描述和链式描述，而线性表可以用来说明这两种方法。STL容器大致相当于线性表的数组描述方式和链式描述方式
数据结构-基础-逻辑结构-线性结构（线性表）-顺序表-链表-栈-队列-数组-哈希表-广义表-
LXMXHJ的博客
06-21 788
数据结构：基础-线性表； 顺序表、链表；栈、队列；数组、哈希表、广义表；
链表结构-数组-链表
qq_52889028的博客
02-18 959
线性表 线性表是一种线性结构，是由零个或者多个数据元素构成的有限序列。 特征：除了头尾元素，每个元素有且仅有一个直接前驱和一个直接后继；而头元素没有直接前驱，尾元素没有直 接后续 常见的线性结构有数组和链表结构 数组 存储区域是连续的，占用内存比较严重，所以空间复杂度较大；但是数组可以使用使用二分法进行查找元素，时 间复杂度比较小 特点： 寻址方便，时间复杂度 O(1) - 插入和删除比较困难，可能会引发元素移动，时间复杂度 O(n) - java 中的数组是定长的，如果需要变长则需要自行编程实现 使用数
java 线性表和链表_线性表——数组与链表
weixin_31110189的博客
02-25 102
概要线性表是一种线性结构，它是具有相同类型的n(n≥0)个数据元素组成的有限序列。本文先介绍线性表的几个基本组成部分：数组、单向链表、双向链表；随后给出双向链表的Java语言的实现。数组数组是一种最常用的线性数据结构，里面存放的元素的类型是一样的，并且有序的。数组的特点是：数据是连续的；随机访问速度快。对于Java而言，Collection集合中提供了ArrayList和Vector用于数组这种数...
数组实现线性表-VS2015.zip_数组实现线性表格
09-24
6. **其他实现方式**：除了数组，线性表还可以用链表实现，链表在插入和删除操作上更灵活，但访问速度相对较慢。 在实际编程中，根据具体需求，我们可能会结合数组和链表的优点，比如使用动态数组（如C++的`std::...
数组实现线性表-VS2015.zip_C++
09-23
在编程领域，数组是一种基础且重要的数据结构，它在实现线性表时起着关键作用。线性表是由n（n≥0）个相同类型元素构成的有限序列，这些元素可以按照它们在表中的顺序进行访问。在C++中，数组就是一种自然的方式来...
C++ 模板专题 - 静态分支(if)
GPU全栈博主-程序哥
10-31 245
模板元编程（Template Metaprogramming，简称 TMP）是一种在 C++ 中使用模板进行编程的技术，它允许在编译时执行计算、生成代码，提供类似脚本语言的功能。TMP 常用于生成高效的代码，避免运行时的计算开销。在高性能编程、类型处理、泛型编程等领域，模板元编程非常有用。模板元编程的一个使用场景就是进行编译器条件分支判断，称为“静态 if”。它允许我们在模板中根据条件编译选择不同的代码分支，而不需要实例化不符合条件的代码，这不仅可以提升编译性能，也可以简化模板代码逻辑。
c++中局部变量和全局变量同名，使用::访问全局变量
weixin_43845922的博客
11-02 207
局部变量可以与全局变量同名，在函数内引用这个变量时，会用到同名的局部变量，而不会用到全局变量。于有些编译器而言，在同一个函数内可以定义多个同名的局部变量，比如在两个循环体内都定义一个同名的局。答：能，局部会屏蔽全局。要用全局变量，需要使用”::”部变量，而那个局部变量的作用域就在那个循环体内。局部变量能否和全局变量重名？
第八天: C语言深度探索：指针与函数的奥秘
qq_57484399的博客
10-31 583
通过今天的学习，我们了解了字符指针和字符串在C语言中的处理方式。希望大家能够掌握这些基本概念，并在实际编程中灵活运用。好了，今天的课就到这里。希望大家能够掌握指针与函数参数的关系，以及如何通过指针来改变外部变量的值。如果有任何问题，或者想要更多的练习题，随时告诉我。下课！好了，今天的课就到这里。希望大家能够掌握数组名作为函数参数的用法，以及如何通过函数来处理数组。如果有任何问题，或者想要更多的练习题，随时告诉我。下课！好了，今天的课就到这里。
第20课-C++【二叉搜索树】
2401_83603768的博客
10-25 1181
二叉搜索树（Binary search tree）是一种特殊的二叉树，它的每个节点的左子树中的所有节点值都小于该节点值，而右子树中的所有节点值都大于该节点值。
C++ -- 模板进阶
最新发布
zy1215058242的博客
11-02 543
一个程序/项目由若干源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链接起来形成单一的可执行文件的过程称为分离编译模式。模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库(STL)因此而产生。增强了代码的灵活性。模板会导致会导致代码代码膨胀问题，也会导致编译时间变长。出现模板编译错误时，错误信息非常凌乱，不易定位错误。
C语言中的野指针以及避免野指针的常用方式
青衫客36的博客
10-29 285
在C语言中，（Dangling Pointer）是指一个指向无效或已释放内存区域的指针。使用野指针会导致不确定的行为，例如程序崩溃、数据损坏，甚至可能带来安全漏洞。freedelete。
C++实现线性表：数组、malloc、链表、模板类解析
- **顺序存储**：线性表的元素存储在一块连续的内存区域中，通常使用数组来实现。这种存储方式便于访问元素，但插入和删除操作可能需要大量移动元素。 - **链式存储**：每个元素包含数据域和指针域，通过指针将...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值