顺序存储实现的vector

已于 2022-04-12 16:06:33 修改
阅读量820 收藏
点赞数
分类专栏： 练习 文章标签： 算法 c++ 类
于 2022-03-26 16:44:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45419976/article/details/123758113
版权

文章目录

大作业vector：

1、完成vector数据结构的基本功能
2、内嵌类iterator和const_iterator（iterator是可以访问和修改的迭代器，const_iterator是只可访问，不可修改）
3、对于某些变量类型，并没有默认的构造函数。请尝试用指针存储。（意思是你在开空间的时候不要同时构造！！！）

代码如下：

version 1：使用了malloc和free

#ifndef SJTU_VECTOR_HPP
#define SJTU_VECTOR_HPP

#include "exceptions.hpp"

#include <climits>
#include <cstddef>

namespace sjtu {
 // a data container like std::vector
 // store data in a successive memory and support random access.
template<typename T>
class vector {
	private:
		T *data;
		int len;
		size_t cpct;
	public:
	    class iterator;
	    class const_iterator;
	    class const_iterator {
			friend class iterator;
			friend class vector;
			private:
				const vector *vecname;
				int idx;
			public:
				const_iterator(vector *vecn,int index){
					vecname = vecn;
					idx = index;
				}
				const_iterator(const vector *vecn,int index){
					vecname = vecn;
					idx = index;
				}
				const_iterator operator+(const int &n) const {
	          		const_iterator tmp(vecname,idx+n);
	            	return tmp;
	        	}
	        	const_iterator operator-(const int &n) const {
	           		const_iterator tmp(vecname,idx-n);
	            	return tmp;
	        	}
	        	// return the distance between two iterators,
	        	// if these two iterators point to different vectors, throw invalid_iterator.
	        	int operator-(const iterator &rhs) const {
	            	if(vecname != rhs.vecname ) throw invalid_iterator();
	            	if(idx > rhs.idx ) return idx-rhs.idx ;
	            	else return rhs.idx-idx;
	        	}
	        	T operator*() const{
					return vecname->data[idx];
				}
		        const_iterator operator++(int) {//iter++
					iterator tmp(vecname,idx);
					idx++;
					return tmp;
				}
		        const_iterator& operator++() {// ++iter
					idx++;
					return *this;
				}
		        const_iterator operator--(int) {// iter--
					iterator tmp(vecname,idx);
					idx--;
					return tmp;
				}
		        const_iterator& operator--() {//--iter
					idx--;
					return *this;
				}
		    	// a operator to check whether two iterators are same 
				//(pointing to the same memory address).
		    	bool operator==(const iterator &rhs) const {
					if(vecname != rhs.vecname ) return false;
					if(idx != rhs.idx )  return false;
					return true;
				}
		        bool operator==(const const_iterator &rhs) const {
					if(vecname != rhs.vecname ) return false;
					if(idx != rhs.idx )  return false;
					return true;
				}
		        bool operator!=(const iterator &rhs) const {// some other operator for iterator.
					return !(*this == rhs);
				}
		        bool operator!=(const const_iterator &rhs) const {
					return !(*this == rhs);
				}
	    };
	    class iterator {
	    	friend class const_iterator;
			friend class vector;
		   	private:
	    		vector<T> *vecname;
				int idx;
	    	public:
	    		iterator(vector<T> *vecn,int index){
					vecname = vecn;
					idx = index;
				}
				iterator(const vector<T> *vecn,int index){
					vecname = vecn;
					idx = index;
				}
	         	//return a new iterator which pointer n-next elements
	          	//as well as operator-
	        	iterator operator+(const int &n) const {
	          		iterator tmp(vecname,idx+n);
	            	return tmp;
	        	}
	        	iterator operator-(const int &n) const {
	           		iterator tmp(vecname,idx-n);
	            	return tmp;
	        	}
	        // return the distance between two iterators,
	        // if these two iterators point to different vectors, throw invalid_iterator.
	        	int operator-(const iterator &rhs) const {
	            	if(vecname != rhs.vecname ) throw invalid_iterator();
	            	if(idx > rhs.idx ) return idx-rhs.idx ;
	            	else return rhs.idx-idx;
	        	}
		        iterator& operator+=(const int &n) {
		            idx += n;
		            return *this;
		        }
		        iterator& operator-=(const int &n) {
		            idx -= n;
		            return *this;
		        }
		        iterator operator++(int) {//iter++
					iterator tmp(vecname,idx);
					idx++;
					return tmp;
				}
		        iterator& operator++() {// ++iter
					idx++;
					return *this;
				}
		        iterator operator--(int) {// iter--
					iterator tmp(vecname,idx);
					idx--;
					return tmp;
				}
		        iterator& operator--() {//--iter
					idx--;
					return *this;
				}
		        T& operator*() const{//*it    0-base的吧 
					return *((vecname->data)+idx);
				}
		         // a operator to check whether two iterators are same 
				 //(pointing to the same memory address).
		        bool operator==(const iterator &rhs) const {
					if(vecname != rhs.vecname ) return false;
					if(idx != rhs.idx )  return false;
					return true;
				}
		        bool operator==(const const_iterator &rhs) const {
					if(vecname != rhs.vecname ) return false;
					if(idx != rhs.idx )  return false;
					return true;
				}
		        bool operator!=(const iterator &rhs) const {// some other operator for iterator.
					return !(*this == rhs);
				}
		        bool operator!=(const const_iterator &rhs) const {
					return !(*this == rhs);
				}
		};
	
	     //TODO Constructs
	     // Atleast two: default constructor, copy constructor
	    vector() {
			len = 0;
			data = NULL;
			cpct = 0;
		}
	    vector(const vector &other) {
			len = other.len;
			cpct = other.cpct;
			data = (T*) malloc(sizeof(T)*cpct);//分配空间，多搞点……？？ 
			for(int i=0;i<len;i++){
				new(data+i)T(other.data[i]); //存进去数据 
			}
		}
	    ~vector() {// TODO Destructor
			for(int i=0;i<len;i++)
				data[i].~T();
			free(data); 
			len = 0;
			data = NULL;
			cpct = 0;
		}
		void doublespace(){
			if(cpct == 0){
				data = (T*) malloc(sizeof(T));
				cpct = 1;
				return ;
			} 
			cpct *= 2;
			T* data2 = (T*) malloc(sizeof(T)*cpct);
			for(int i=0;i<len;i++)
				new(data2+i)T(data[i]);
			for(int i=0;i<len;i++)
				data[i].~T();
//			operator delete(data,sizeof(T)*(cpct/2));
			free(data);
			data = data2;
		}
	    vector &operator=(const vector &other) {// TODO Assignment operator赋值运算符 
	    	if(this == &other) return *this;//return 自己 
	    	if(cpct < other.cpct) {
				for(int i=0;i<len;i++)//记得删除的时候~T() 
					data[i].~T();
//				operator delete(data,sizeof(T)*cpct);
				free(data);
				cpct = other.cpct;	
				len = other.len;
				data = (T*) malloc(sizeof(T)*cpct);
				for(int i=0;i<len;i++)
					new(data+i)T(other.data[i]);
			}
			else{//完了呀这里写的有问题呀！！已经改好了……
				for(int i=0;i<other.len;i++)
					data[i].~T();
				for(int i=0;i<other.len;i++)
					new(data+i)T(other.data[i]);
				for(int i=other.len;i<len;i++)
					data[i].~T();
				len = other.len;
			}
			return *this;
		}
	      //assigns specified element with bounds checking
	     // throw index_out_of_bound if pos is not in [0, size)
	    T & at(const size_t &pos) {//size_t是一个变量类型，和int型大小一样，一般会用 size_t size = sizeof(a);//a是int型变量 
			if(pos >= len) throw index_out_of_bound();
			else return  *(this->data+pos);
		}
	    const T & at(const size_t &pos) const {
			if(pos >= len) throw index_out_of_bound();
			else return  *(this->data+pos);
		}
	     // assigns specified element with bounds checking
	     // throw index_out_of_bound if pos is not in [0, size)
	     // !!! Pay attentions
	     //   In STL this operator does not check the boundary but I want you to do.
	    T & operator[](const size_t &pos) {
			if(pos >= len) throw index_out_of_bound();
			else return *(this->data+pos);
		}
	    const T & operator[](const size_t &pos) const {
			if(pos >= len) throw index_out_of_bound();
			else return *(this->data+pos);
		}
	     // access the first element.  throw container_is_empty if size == 0
	    const T & front() const {
			if(len==0) throw container_is_empty();
			else return *(this->data);
		}
	     //access the last element.  throw container_is_empty if size == 0
	    const T & back() const {
			if(len==0) throw container_is_empty();
			else return *(this->data+len-1);
		}
	     //returns an iterator to the beginning.
	    iterator begin() {
	    	iterator tmp(this,0);//要不要throw？ 
			return tmp;
		}
	    const_iterator cbegin()const{
			const_iterator tmp(this,0);
			return tmp;
		}
	     // returns an iterator to the end.
	    iterator end() {
			iterator tmp(this,len);
			return tmp;
		}
	    const_iterator cend() const {
			const_iterator tmp(this,len);
			return tmp;
		}
	     // checks whether the container is empty
	    bool empty() const {
			if(size) return false;
			else return true;
		}
	     // returns the number of elements
	    size_t size() const {
			size_t siz = len;
			return siz;
		}
	     // clears the contents
	    void clear() {
	    	for(int i=0;i<len;i++)
				data[i].~T();//删掉内容而已，没让你清空内存啊 
			len = 0; 
		}
	     // inserts value before pos
	     // returns an iterator pointing to the inserted value.
	    iterator insert(iterator pos, const T &value) {
			if(pos.vecname->len+1 > pos.vecname->cpct) pos.vecname->doublespace(); 
			for(int i=pos.vecname->len;i>=pos.idx;i--)
				new(pos.vecname->data+i+1)T(pos.vecname->data[i]);
			new(data+pos.idx)T(value);
			pos.vecname->len ++;
			iterator tmp(pos.vecname,pos.idx);
			return tmp;
		}
	     // inserts value at index ind.
	     // after inserting, this->at(ind) == value
	     // returns an iterator pointing to the inserted value.
	     // throw index_out_of_bound if ind > size (in this situation ind can be size because after inserting the size will increase 1.)
	    iterator insert(const size_t &ind, const T &value) {
			if(ind > len) throw index_out_of_bound();
			if(len+1 > cpct) doublespace();
			for(int i=len;i>=ind;i--)
				new(data+i+1)T(data[i]);
			new(data+ind)T(value);	
			len ++;
			iterator tmp(this,ind);
			return tmp;
		}
	     // removes the element at pos.
	     // return an iterator pointing to the following element.
	     // If the iterator pos refers the last element, the end() iterator is returned.
	    iterator erase(iterator pos) {
			for(int i=pos.idx;i<pos.vecname->len-1;i++)
				new(pos.vecname->data+i)T(pos.vecname->data[i+1]);
			pos.vecname->data[pos.vecname->len-1].~T();
			pos.vecname->len --;
			if(pos.vecname->len == pos.idx) return pos.vecname->end();
			iterator tmp(pos.vecname,pos.idx);
			return tmp;
		}
	    /**
	     * removes the element with index ind.
	     * return an iterator pointing to the following element.
	     * throw index_out_of_bound if ind >= size
	     */
	    iterator erase(const size_t &ind) {
			if(ind >= len) throw index_out_of_bound();
			for(int i=ind;i<len-1;i++)
				new(data+i)T(data[i+1]);
			data[len-1].~T();
			len--;
			if(len == ind) return this->end();
			iterator tmp(this,ind);
			return tmp;
		}
	    /**
	     * adds an element to the end.
	     */
	    void push_back(const T &value) { 
	    	if(len+1 > cpct) this->doublespace();
			new(data+len)T(value);
			len++;
		}
	    /**
	     * remove the last element from the end.
	     * throw container_is_empty if size() == 0
	     */
	    void pop_back() {
			if(len==0) throw container_is_empty();
			data[len-1].~T();
			len--;
		}
	};
}
#endif

version 2：使用了operator new和operator delete

#ifndef SJTU_VECTOR_HPP
#define SJTU_VECTOR_HPP

#include "exceptions.hpp"

#include <climits>
#include <cstddef>

namespace sjtu {
 // a data container like std::vector
 // store data in a successive memory and support random access.
template<typename T>
class vector {
	private:
		T *data;
		int len;
		size_t cpct;
	public:
	    class iterator;
	    class const_iterator;
	    class const_iterator {
			friend class iterator;
			friend class vector;
			private:
				const vector *vecname;
				int idx;
			public:
				const_iterator(vector *vecn,int index){
					vecname = vecn;
					idx = index;
				}
				const_iterator(const vector *vecn,int index){
					vecname = vecn;
					idx = index;
				}
				const_iterator operator+(const int &n) const {
	          		const_iterator tmp(vecname,idx+n);
	            	return tmp;
	        	}
	        	const_iterator operator-(const int &n) const {
	           		const_iterator tmp(vecname,idx-n);
	            	return tmp;
	        	}
	        	// return the distance between two iterators,
	        	// if these two iterators point to different vectors, throw invalid_iterator.
	        	int operator-(const iterator &rhs) const {
	            	if(vecname != rhs.vecname ) throw invalid_iterator();
	            	if(idx > rhs.idx ) return idx-rhs.idx ;
	            	else return rhs.idx-idx;
	        	}
	        	T operator*() const{
					return vecname->data[idx];
				}
		        const_iterator operator++(int) {//iter++
					iterator tmp(vecname,idx);
					idx++;
					return tmp;
				}
		        const_iterator& operator++() {// ++iter
					idx++;
					return *this;
				}
		        const_iterator operator--(int) {// iter--
					iterator tmp(vecname,idx);
					idx--;
					return tmp;
				}
		        const_iterator& operator--() {//--iter
					idx--;
					return *this;
				}
		    	// a operator to check whether two iterators are same 
				//(pointing to the same memory address).
		    	bool operator==(const iterator &rhs) const {
					if(vecname != rhs.vecname ) return false;
					if(idx != rhs.idx )  return false;
					return true;
				}
		        bool operator==(const const_iterator &rhs) const {
					if(vecname != rhs.vecname ) return false;
					if(idx != rhs.idx )  return false;
					return true;
				}
		        bool operator!=(const iterator &rhs) const {// some other operator for iterator.
					return !(*this == rhs);
				}
		        bool operator!=(const const_iterator &rhs) const {
					return !(*this == rhs);
				}
	    };
	    class iterator {
	    	friend class const_iterator;
			friend class vector;
		   	private:
	    		vector<T> *vecname;
				int idx;
	    	public:
	    		iterator(vector<T> *vecn,int index){
					vecname = vecn;
					idx = index;
				}
				iterator(const vector<T> *vecn,int index){
					vecname = vecn;
					idx = index;
				}
	         	//return a new iterator which pointer n-next elements
	          	//as well as operator-
	        	iterator operator+(const int &n) const {
	          		iterator tmp(vecname,idx+n);
	            	return tmp;
	        	}
	        	iterator operator-(const int &n) const {
	           		iterator tmp(vecname,idx-n);
	            	return tmp;
	        	}
	        // return the distance between two iterators,
	        // if these two iterators point to different vectors, throw invalid_iterator.
	        	int operator-(const iterator &rhs) const {
	            	if(vecname != rhs.vecname ) throw invalid_iterator();
	            	if(idx > rhs.idx ) return idx-rhs.idx ;
	            	else return rhs.idx-idx;
	        	}
		        iterator& operator+=(const int &n) {
		            idx += n;
		            return *this;
		        }
		        iterator& operator-=(const int &n) {
		            idx -= n;
		            return *this;
		        }
		        iterator operator++(int) {//iter++
					iterator tmp(vecname,idx);
					idx++;
					return tmp;
				}
		        iterator& operator++() {// ++iter
					idx++;
					return *this;
				}
		        iterator operator--(int) {// iter--
					iterator tmp(vecname,idx);
					idx--;
					return tmp;
				}
		        iterator& operator--() {//--iter
					idx--;
					return *this;
				}
		        T& operator*() const{//*it    0-base的吧 
					return *((vecname->data)+idx);
				}
		         // a operator to check whether two iterators are same 
				 //(pointing to the same memory address).
		        bool operator==(const iterator &rhs) const {
					if(vecname != rhs.vecname ) return false;
					if(idx != rhs.idx )  return false;
					return true;
				}
		        bool operator==(const const_iterator &rhs) const {
					if(vecname != rhs.vecname ) return false;
					if(idx != rhs.idx )  return false;
					return true;
				}
		        bool operator!=(const iterator &rhs) const {// some other operator for iterator.
					return !(*this == rhs);
				}
		        bool operator!=(const const_iterator &rhs) const {
					return !(*this == rhs);
				}
		};
	
	     //TODO Constructs
	     // Atleast two: default constructor, copy constructor
	    vector() {
			len = 0;
			data = NULL;
			cpct = 0;
		}
	    vector(const vector &other) {
			len = other.len;
			cpct = other.cpct;
			data = (T*) malloc(sizeof(T)*cpct);//分配空间，多搞点……？？ 
			for(int i=0;i<len;i++){
				new(data+i)T(other.data[i]); //存进去数据 
			}
		}
	    ~vector() {// TODO Destructor
			for(int i=0;i<len;i++)
				data[i].~T();
			free(data); 
			len = 0;
			data = NULL;
			cpct = 0;
		}
		void doublespace(){
			if(cpct == 0){
				data = (T*) malloc(sizeof(T));
				cpct = 1;
				return ;
			} 
			cpct *= 2;
			T* data2 = (T*) malloc(sizeof(T)*cpct);
			for(int i=0;i<len;i++)
				new(data2+i)T(data[i]);
			for(int i=0;i<len;i++)
				data[i].~T();
//			operator delete(data,sizeof(T)*(cpct/2));
			free(data);
			data = data2;
		}
	    vector &operator=(const vector &other) {// TODO Assignment operator赋值运算符 
	    	if(this == &other) return *this;//return 自己 
	    	if(cpct < other.cpct) {
				for(int i=0;i<len;i++)//记得删除的时候~T() 
					data[i].~T();
//				operator delete(data,sizeof(T)*cpct);
				free(data);
				cpct = other.cpct;	
				len = other.len;
				data = (T*) malloc(sizeof(T)*cpct);
				for(int i=0;i<len;i++)
					new(data+i)T(other.data[i]);
			}
			else{
				for(int i=0;i<other.len;i++)
					new(data+i)T(other.data[i]);
				for(int i=other.len;i<len;i++)
					data[i].~T();
			}
			return *this;
		}
	      //assigns specified element with bounds checking
	     // throw index_out_of_bound if pos is not in [0, size)
	    T & at(const size_t &pos) {//size_t是一个变量类型，和int型大小一样，一般会用 size_t size = sizeof(a);//a是int型变量 
			if(pos >= len) throw index_out_of_bound();
			else return  *(this->data+pos);
		}
	    const T & at(const size_t &pos) const {
			if(pos >= len) throw index_out_of_bound();
			else return  *(this->data+pos);
		}
	     // assigns specified element with bounds checking
	     // throw index_out_of_bound if pos is not in [0, size)
	     // !!! Pay attentions
	     //   In STL this operator does not check the boundary but I want you to do.
	    T & operator[](const size_t &pos) {
			if(pos >= len) throw index_out_of_bound();
			else return *(this->data+pos);
		}
	    const T & operator[](const size_t &pos) const {
			if(pos >= len) throw index_out_of_bound();
			else return *(this->data+pos);
		}
	     // access the first element.  throw container_is_empty if size == 0
	    const T & front() const {
			if(len==0) throw container_is_empty();
			else return *(this->data);
		}
	     //access the last element.  throw container_is_empty if size == 0
	    const T & back() const {
			if(len==0) throw container_is_empty();
			else return *(this->data+len-1);
		}
	     //returns an iterator to the beginning.
	    iterator begin() {
	    	iterator tmp(this,0);//要不要throw？ 
			return tmp;
		}
	    const_iterator cbegin()const{
			const_iterator tmp(this,0);
			return tmp;
		}
	     // returns an iterator to the end.
	    iterator end() {
			iterator tmp(this,len);
			return tmp;
		}
	    const_iterator cend() const {
			const_iterator tmp(this,len);
			return tmp;
		}
	     // checks whether the container is empty
	    bool empty() const {
			if(size) return false;
			else return true;
		}
	     // returns the number of elements
	    size_t size() const {
			size_t siz = len;
			return siz;
		}
	     // clears the contents
	    void clear() {
	    	for(int i=0;i<len;i++)
				data[i].~T();//删掉内容而已，没让你清空内存啊 
			len = 0; 
		}
	     // inserts value before pos
	     // returns an iterator pointing to the inserted value.
	    iterator insert(iterator pos, const T &value) {
			if(pos.vecname->len+1 > pos.vecname->cpct) pos.vecname->doublespace(); 
			for(int i=pos.vecname->len;i>=pos.idx;i--)
				new(pos.vecname->data+i+1)T(pos.vecname->data[i]);
			new(data+pos.idx)T(value);
			pos.vecname->len ++;
			iterator tmp(pos.vecname,pos.idx);
			return tmp;
		}
	     // inserts value at index ind.
	     // after inserting, this->at(ind) == value
	     // returns an iterator pointing to the inserted value.
	     // throw index_out_of_bound if ind > size (in this situation ind can be size because after inserting the size will increase 1.)
	    iterator insert(const size_t &ind, const T &value) {
			if(ind > len) throw index_out_of_bound();
			if(len+1 > cpct) doublespace();
			for(int i=len;i>=ind;i--)
				new(data+i+1)T(data[i]);
			new(data+ind)T(value);	
			len ++;
			iterator tmp(this,ind);
			return tmp;
		}
	     // removes the element at pos.
	     // return an iterator pointing to the following element.
	     // If the iterator pos refers the last element, the end() iterator is returned.
	    iterator erase(iterator pos) {
			for(int i=pos.idx;i<pos.vecname->len-1;i++)
				new(pos.vecname->data+i)T(pos.vecname->data[i+1]);
			pos.vecname->data[pos.vecname->len-1].~T();
			pos.vecname->len --;
			if(pos.vecname->len == pos.idx) return pos.vecname->end();
			iterator tmp(pos.vecname,pos.idx);
			return tmp;
		}
	    /**
	     * removes the element with index ind.
	     * return an iterator pointing to the following element.
	     * throw index_out_of_bound if ind >= size
	     */
	    iterator erase(const size_t &ind) {
			if(ind >= len) throw index_out_of_bound();
			for(int i=ind;i<len-1;i++)
				new(data+i)T(data[i+1]);
			data[len-1].~T();
			len--;
			if(len == ind) return this->end();
			iterator tmp(this,ind);
			return tmp;
		}
	    /**
	     * adds an element to the end.
	     */
	    void push_back(const T &value) { 
	    	if(len+1 > cpct) this->doublespace();
			new(data+len)T(value);
			len++;
		}
	    /**
	     * remove the last element from the end.
	     * throw container_is_empty if size() == 0
	     */
	    void pop_back() {
			if(len==0) throw container_is_empty();
			data[len-1].~T();
			len--;
		}
	};
}
#endif

tips

  • 上述两种开辟空间的方式，均可以解决类型没有默认构造函数的问题。注意，malloc和free配合使用，operator new和operator delete配合使用，才能顺利开辟/释放空间。一些具体的语法如下，以doublespace中间的一段为例：（注释号写在前面的语句行是被代替掉的语句，是正常的new和delete的那种语句）
//	T *data = new T[capacity];
	T* data2 = (T*) malloc(sizeof(T)*capacity);//开辟空间不构造
	for(int i=0;i<len;i++)
//		data2[i] = data[i];
		new(data2+i)T(data[i]);//赋值操作（是构造，用的拷贝构造函数吧）
	for(int i=0;i<len;i++)
		data[i].~T();//记得这种情况下析构要分步，先析构每一个T型变量
//	delete []data;
	free(data);//最后释放data数组

//	T *data = new T[capacity];
	T* data2 = (T*) operator new(sizeof(T)*capacity);//开辟空间不构造
	for(int i=0;i<len;i++)
//		data2[i] = data[i];
		new(data2+i)T(data[i]);//赋值操作（构造，用的拷贝构造函数吧）
	for(int i=0;i<len;i++)
		data[i].~T();//记得这种情况下析构要分步，先析构每一个T型变量
//	delete []data;
	operator delete(data,sizeof(T)*capacity);//最后释放data数组

如果operator delete写出来编译器不认，建议换个编译器。

  • 不写doublespace的倔强的我已经认输了，因为如果不写就一定会超时，具体案例是给的测试点2跑了40多分钟才跑完，仅仅是220而已（其实也很大了）
  • 其他超时的原因有：iterator和const_iterator初始化可以尝试初始化列表（可是我不会啊，因为有模板变量，但是也可能是我编译器的问题啦）；重载等号的时候，考虑开空间是开成和等号右边的len一样还是capacity一样，本题可能需要空间换时间，开成和capacity一样就能过了，否则过不了……
  • iterator和const_iterator的区别还是很大的，按照样例来分析的话，可能const_iterator指向的是一个const vector，并且只能访问不能修改（是这样的吗，还有待讨论），所以const_iterator的成员参数必须是一个const vector *类型的变量，剩下的可以自己定义，否则你不可以用const vector * 去给vector（非const）赋值。
矿矿不想吃饭
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线性表的顺序存储与实现
07-29
线性表是计算机科学中一种基础的数据结构，它是由n（n≥0）个相同...提供的文件"02-线性表的顺序存储与实现"很可能是关于如何在具体编程语言中实现这些操作的示例代码，可以作为学习和理解线性表顺序存储的参考资料。
C++实现动态顺序表（vector）
08-19
C++实现动态顺序表（vector） C++中的动态顺序表（vector）是一种非常重要的数据结构，它可以自动调整大小以适应不断变化的数据量。下面是对C++实现动态顺序表的详细介绍。 动态顺序表的定义 动态顺序表是一种...
C++(STL库)之顺序容器vector的使用
08-25
C++ STL 库中的顺序容器 vector 是一种常用的容器，它可以存储任意类型的元素，并且提供了丰富的操作接口。下面我们将详细介绍 vector 的使用。 特点 1. 可变大小数组，支持快速随机访问。 2. 元素保存在连续的...
c++ vector(向量)使用方法详解(顺序访问vector的多种方式）
09-04
C++中的`std::vector`是一个动态数组，它允许存储同一类型的元素集合，并提供了高效的操作接口。`vector`是标准模板库（STL）的一部分，是C++编程中常用的数据结构之一。以下是对`vector`的详细介绍，以及如何进行...
双向链表实现的list
weixin_45419976的博客
04-01 1606
文章目录手写listAC代码（没那么漂亮的版本）修改后list分析函数及其作用写的时候出现的重大问题1、代码逻辑问题2、代码理解问题3、请写好返回值4、充分理解`new和malloc和T()`、`delete和free和~T()` 手写list 要求如下： 给的algorithm如下： #ifndef SJTU_ALGORITHM_HPP #define SJTU_ALGORITHM_HPP #include <functional> namespace sjtu{ template&
A-B数对——题目解析
weixin_45419976的博客
04-21 1027
题目来源：Luogu P1102，OJ 1522 解法1：Hash表（取模hash函数+开散列表-拉链法） #include<iostream> using namespace std; const int N = 200005; const int P = 1000003; int n,c,x,tot = 0; long long ans = 0;//1e10要开long long了 struct Node{ int data; int cnt; int next; Node(){
回文数_20211202
weixin_45419976的博客
12-02 601
文章目录luogu P1217 luogu P1217 AC代码 #include<iostream> using namespace std; int a,b,cnt = 0; int pri[10000000] = {0}; bool vis[100000001] = {0}; bool check(int x){ int x1 = 0,x2=x; while(x){ x1 *= 10; x1 += x%10; x /= 10; } if(x1==x2) return
模板类的继承（类模板作为基类），内嵌类的继承
weixin_45419976的博客
02-24 549
C++模板类的继承，类模板作为基类，内嵌类的继承
模板类的重载
weixin_45419976的博客
03-11 430
放代码： #include<iostream> #include<cstdio> #define USE_OS template<class T>class ArrayList; template<class T>std::ostream &operator<<(std::ostream &os,const ArrayList<T> &obj); class error : public std::e...
Luogu 3916 图的遍历
weixin_45419976的博客
10-22 317
Luogu3916 图的遍历 给出N个点，M条边的有向图，对于每个点v，A(v)表示从点v出发，能到达的编号最大的点。 . 输入格式 第1 行，2 个整数N,M。 接下来M行，每行2个整数Ui,ViU_i,V_iUi​,Vi​，表示边(Ui,Vi)(U_i,V_i)(Ui​,Vi​)。点用1,2,⋯,N编号。 输出格式 N 个整数A(1),A(2),⋯,A(N)。 . 输入输出样例 输入 4 3...
Hotel G
weixin_45419976的博客
04-23 241
文章目录Luogu P2894 [USACO08FEB]Hotel G代码：一、倔强地没用lazytag二、加了lazy教训： Luogu P2894 [USACO08FEB]Hotel G 差点没整死我、、、 代码： 一、倔强地没用lazytag #include<iostream> using namespace std; const int N = 50005; int n,m,op,d,e; int maxlen[N*4] = {0},llen[N*4] = {0},rlen[N*4]
手写priority queue
weixin_45419976的博客
04-20 220
文章目录要求：基本功能（顺序存储）连接存储（左堆） 要求： 1、完成priority queue的基本功能 2、在至多logn的时间复杂度合并两个priority queue 基本功能（顺序存储） #ifndef SJTU_PRIORITY_QUEUE_HPP #define SJTU_PRIORITY_QUEUE_HPP #include <cstddef> #include <functional> #include "exceptions.hpp" #include<i
高级ST表（区间最长不下降子序列 & 区间GCD
weixin_45419976的博客
03-09 216
文章目录题面T两个点代码：T一个点代码：AC代码： 题面 Tips： 子序列没说连续！！ Hint：最长上升子序列只需要考虑区间内是否有0,1{0, 1}0,1子序列，考虑维护两个数组LastOne和FirstZero，为了使得该hint含蓄一些，数组含义请自己脑补qwq。最长不下降子序列只有三种情况{000…000},{111…111},{000…111}，前两种情况利用前缀和维护即可，第三种情况可以枚举0,1的分界点，总复杂度为O(NM)，会超时。考虑用ST表优化这一过程，做到O(1)查询，最终复
Poj 3259 Wormholes Bellman-Ford
weixin_45419976的博客
10-23 193
描述 在探索他的许多农场时，农夫约翰发现了许多惊人的虫洞。虫洞非常特殊，因为它是一条单向路径，可把您在进入 虫洞之前的时间 将您送至目的地！ FJ的每个农场均包含 N（1≤N≤500）个田地，编号为 1到 N，M（1≤M≤2500） 条路径和 W（1≤W≤200）虫洞。由于 FJ是一位热衷时间旅行的爱好者，因此他希望做到以下几点：从某个田地开始， 经过一些路径和虫洞，并在他初次离开之前的某个时间...
Luogu P1967 货车运输
weixin_45419976的博客
11-14 187
题目描述 A 国有 n 座城市，编号从 1到 n，城市之间有 m 条双向道路。每一条道路对车辆都有重量限制，简称限重。 现在有 q 辆货车在运输货物， 司机们想知道每辆车在不超过车辆限重的情况下，最多能运多重的货物。 . 输入格式 第一行有两个用一个空格隔开的整数 n,m，表示 A 国有 n 座城市和 m 条道路。 接下来 m行每行三个整数 x,y,z，每两个整数之间用一个空格隔开，表示从 x ...
Poj 1125 Stockbroker Grapevine
weixin_45419976的博客
10-24 159
Stockbroker Grapevine Floyd&Dijkstra 描述 众所周知，股票经纪人对谣言反应过度。您已签约开发一种在股票经纪人之间传播虚假信息的方法，以使您的雇主在股票市场上具有战术上的优势。为了获得最大效果，您必须以最快的方式传播谣言。 对于您来说不幸的是，股票经纪人仅信任来自其“受信任来源”的信息。这意味着在开始谣言时，您必须考虑其联系方式。一个特定的股票经纪人将谣...
Poj 1062 昂贵的聘礼
weixin_45419976的博客
10-23 143
Poj 1062 昂贵的聘礼 Description 年轻的探险家来到了一个印第安部落里。他和酋长的女儿相爱了，于是便向酋长去求亲。酋长要他用10000个金币作为聘礼才答应把女儿嫁给他。探险家拿不出这么多金币，便请求酋长降低要求。酋长说：“嗯，如果你能够替我弄到大祭司的皮袄，我可以只要8000金币。如果你能够弄来他的水晶球，那么只要5000金币。“探险家跑到大祭司那里，向他要皮袄或水晶球，大祭司...
双向约瑟夫数学解法
weixin_45419976的博客
03-11 138
这题是约瑟夫问题的加强版，需要双向杀人，同时由于数据的强度不能采用O(MN)或者O(N2)，必须采用数学方法达到O(N)的复杂度。 80分代码： #include<iostream> using namespace std; int n,m; bool f = true; struct Node{ int data; Node *next,*prev; Node(int k){ data = k; next = NULL; prev = NULL; } }; Node *.
c++类模板二叉树顺序存储
最新发布
05-12
下面是一个使用类模板实现的二叉树顺序存储的示例代码： ```c++ #include #include <vector> using namespace std; template class SeqBinaryTree { public: SeqBinaryTree() {} SeqBinaryTree(const vector...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值