【STL】vector模拟实现

已于 2024-08-17 21:01:08 修改
阅读量733 收藏 24
点赞数 26
分类专栏： STL 文章标签： c++ 开发语言 stl
于 2024-08-15 13:28:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_64076540/article/details/140994852
版权

这里写目录标题

vector引入
​​
在这里插入图片描述 vector的实现主要依靠三个成员变量:start,finish和end_of_storage
其中：
[start]指向容器中的起始位置
[finish]指向容器中最后一个有效数据的下一个位置
[end_of_storage]指向容器中现有容量的位置
通过这三个指针，就使得vector的size() = finish - start
capacity = end_of_storage - start.

成员函数

[函数模板]
为了使我们的vector实用性更好，我们需要使用函数模板。
在这里插入图片描述

[迭代器]
在这里插入图片描述

构造函数

在这里插入图片描述
上面是vector的构造函数，每个构造函数的使用如下：
在这里插入图片描述
我们根据这里提供的接口自己实现构造函数。
在这里插入图片描述

[默认构造]

在这里插入图片描述

[迭代器构造]

左边是迭代器构造函数的实现，右边是调用迭代器构造，发现确实是调用了迭代器构造。
需要注意的地方为什么迭代器要使用模板？

因为我们不知道传进来的是什么类型，就需要用模板来接收，保证泛型编程。
在这里插入图片描述

[拷贝构造函数]

下面有两种拷贝构造函数的实现，都是错误的，因为这是浅拷贝。
在这里插入图片描述
浅拷贝会导致两个vector指向同一个地址空间。
对v1的操作同时也是对v的操作了。
在这里插入图片描述
浅拷贝对内置类型没有影响，因为不会对堆上的内容进行析构。
例如下面这样：
在这里插入图片描述
但是浅拷贝对自定义类型影响很大，会导致析构的的时候析构两次，导致崩溃：

在这里插入图片描述

//1.4 拷贝构造  -- 用v来初始化this
		vector(const vector<T>& v)
		{
			//注意：不能使用memcpy,memcpy是浅拷贝
			_start = new T[v.capacity()];   //开辟一块新的空间
			for (size_t i = 0; i < v.size(); ++i)
			{
				_start[i] = v[i];
			}

			_finish = _start + v.size();
			_end_of_storage = _start + v.capacity();
		}

对拷贝构造函数进行测试：

在这里插入图片描述

[赋值运算符重载函数]

需要注意的地方有两个：
1. 判断一下，不能自己给自己赋值
2. 要先释放掉原来的空间

vector<T>& operator=(const vector<T> &v)
		{
			//防止自己给自己赋值
			if (this != &v)
			{
				//1.释放掉原来的空间
				delete[] _start;
				_start = new T[v.capacity()];

				for (int i = 0; i < v.size(); ++i)
				{
					_start[i] = v[i];
				}

				_finish = _start + v.size();
				_end_of_storage = _start + v.capacity();
			}

			return *this;
		}

对赋值运算符重载函数进行测试：
在这里插入图片描述
n个值构造因为涉及调用resize()函数，所以放在后面写。

扩容函数

实现reserve()函数 reserve()函数实现逻辑是什么？
在这里插入图片描述

[reserve()函数]

在这里插入图片描述
这样写会出现什么问题？ 我们用如下代码对reserve()进行测试。
在这里插入图片描述
测试结果如下：
在这里插入图片描述

这是因为在计算新空间的_finish的时候，调用的是size()函数。
先看看size()函数是如何实现的？
在这里插入图片描述
因此，改进的方式，是在_start指向新空间之前将size()的内容存储下来。

		void reserve(size_t n)
		{
			if (n <= capacity())
			{
				//不进行任何操作
			}
			else
			{
				//先将size()的内容存储下来
				int sz = size();
				//这里的扩容是开辟一块空间，将旧的内容拷贝的新空间上
				T* tmp = new T[n]; 
				if (_start)
				{
					for (int i = 0; i < size(); ++i)
					{
						tmp[i] = _start[i];
					}
					//释放掉以前的空间
					delete[] _start;
				}
				//让_start指向新开辟的空间
				_start = tmp;
				_finish = _start + sz;
				_end_of_storage = _start + n;
			}
		}

运行测试：
在这里插入图片描述

在这里插入图片描述

resize()函数]

实现resize()函数可以分为三种情况：
1.n <= _finish
2.n >_finish && n <= _end_of_storage
3.n > _end_of_storage
在这里插入图片描述
其实，前两种可以合并成一种。因为他们都不需要对vector进行扩容。
后面的一种需要对vector进行扩容，可以使用reserve()函数进行复用。
resize()函数的具体实现：

		void resize(size_t n, const T& value = T())
		{
			if (n <= size())
			{
				_finish = _start + n;
			}
			else
			{
				//1.扩容
				reserve(n);
				//2.将内容插入到vector中
				while (_finish != _start + n)
				{
					*_finish = value;
					++_finish;
				}
			}
		}

测试：
在这里插入图片描述

测试n个值构造的时候，出现报错，非法的间接寻址：
在这里插入图片描述
首先弄明白，什么是非法的间接寻址？
只有指针和迭代器可以解引用，内置类型不能解引用。而如果对内置类型解引用，就会出现非法的间接寻址。
为什么明明我们调用的是n个值的构造函数，确走到了迭代器初始化？

这就要提一下最匹配的问题了。因为我们传递的是int类型，但是n个值的构造函数却是size_t类型。所以不是最匹配，就会走到迭代器构造函数这里来。
因此，解决办法就是调用最匹配的构造函数，对原来的构造函数进行重载即可。
在这里插入图片描述

修改

[pop_back()函数]

函数实现：

不需要将删除的元素置空，只用挪动_finish指针，以后有新的操作时，直接对原数据进行覆盖

在这里插入图片描述

对函数进行测试：
在这里插入图片描述

[pop_back()函数]

void push_back(const T& x)
{
	if (_finish == _end_of_storage)
	{
		size_t newCapacity = capacity() == 0 ? 4 : capacity() * 2;
		reserve(newCapacity);
	}
	*_finish = x;
	_finish++;
}

[insert()函数]迭代器失效问题

_finish是最后一个元素的下一个位置。我们要插入值，就需要找到最后一个元素，并且将这些元素一个一个往后挪动，直到空出pos的位置，插入value
在这里插入图片描述

实现逻辑如下：

void insert(iterator pos, const T& val)
		{
			assert(pos >= _start && pos <= _finish);

			//1.判断扩容逻辑
			if (_finish == _end_of_storage)
			{
				int newCapacity = capacity() == 0 ? 4 : capacity() * 2;
				reserve(newCapacity);
			}

			//2.将pos后的内容往后移动
			auto end = _finish - 1;   //_finish指向的是最后一个元素的下一个位置
			while (end >= pos)
			{
				*(end + 1) = *end;
				--end;
			}

			//3.将val插入到vector中
			*pos = val;
			++_finish;
		}

当没有扩容时，对函数进行测试：

在这里插入图片描述
一旦前面进行扩容：
在这里插入图片描述
插入的数是随机数。
这就是内部迭代器失效的问题。

为什么会出现迭代器失效的问题？
从刚刚的测试可以看出，迭代器失效应该是和是否扩容有关的，我们从调试的角度来看看。
扩容之前_start和pos的内容：
在这里插入图片描述
扩容之后，_start因为使用reserve()进行异地扩容，位置就会发生改变，而pos没有改变位置。会导致后面的pos和end无法比较：
在这里插入图片描述
通过图示更直观的理解：
在这里插入图片描述
解决办法就是，让pos和_start一起走。计算出pos和_start之间的偏移量，在_start换到新的地址之后，根据偏移量计算出pos的新位置。
代码：

		void insert(iterator pos, const T& val)
		{
			assert(pos >= _start && pos <= _finish);

			//1.判断扩容逻辑
			if (_finish == _end_of_storage)
			{
				//1.1计算出pos和_start的偏移量
				int n = _start - pos;
				int newCapacity = capacity() == 0 ? 4 : capacity() * 2;
				reserve(newCapacity);
				//1.2扩容完之后根据偏移量找到新pos的位置
				pos = _start + n;
			}

			//2.将pos后的内容往后移动
			auto end = _finish - 1;   //_finish指向的是最后一个元素的下一个位置
			while (end >= pos)
			{
				*(end + 1) = *end;
				--end;
			}

			//3.将val插入到vector中
			*pos = val;
			++_finish;
		}

运行结果：
在这里插入图片描述
解决完内部迭代器失效问题之后，还存在外部迭代器失效的情况。

什么是外部迭代器失效？

用自己写的vector，看看会出现什么结果：
在这里插入图片描述
对迭代器解引用是随机值，这就代表迭代器失效了。

为什么会失效？

因为我们调用insert()插入值之后，迭代器的位置会改变，因此就失效了。
在这里插入图片描述

如何解决外部迭代器失效的问题呢？

1.在insert()函数中返回迭代器
2.在调用insert()之后接收改变后的迭代器

必须要接收迭代器，不然还是会出现迭代器失效的问题。

		iterator insert(iterator pos, const T& val)
		{
			assert(pos >= _start && pos <= _finish);

			//1.判断扩容逻辑
			if (_finish == _end_of_storage)
			{
				//1.1计算出pos和_start的偏移量
				int n = _start - pos;
				int newCapacity = capacity() == 0 ? 4 : capacity() * 2;
				reserve(newCapacity);
				//1.2扩容完之后根据偏移量找到新pos的位置
				pos = _start + n;
			}

			//2.将pos后的内容往后移动
			auto end = _finish - 1;   //_finish指向的是最后一个元素的下一个位置
			while (end >= pos)
			{
				*(end + 1) = *end;
				--end;
			}

			//3.将val插入到vector中
			*pos = val;
			++_finish;

			//返回迭代器
			return pos;
		}

在这里插入图片描述

[erase()函数]迭代器失效问题

删除的逻辑：
在这里插入图片描述

iterator erase(iterator pos)
		{
			assert(pos >= _start && pos <= _finish);

			auto it = pos + 1;
			while (it != _finish)
			{
				*(it - 1) = *it;
				++it;
			}

			--_finish;

			return pos;
		}

测试：

在这里插入图片描述
在这里插入图片描述

元素访问

[operation[]函数]

		T& operator[](size_t pos)
		{
			assert(pos < size());

			return _start[pos];
		}

		const T& operator[](size_t pos) const
		{
			assert(pos < size());

			return _start[pos];
		}

[迭代器]

		iterator begin()
		{
			return _start;
		}

		iterator end()
		{
			return _finish;
		}

		const_itertator begin() const
		{
			return _start;
		}

		const_itertator end() const
		{
			return _finish;
		}

容量

[size()函数]

		size_t size() const
		{
			return _finish - _start;
		}

[capacity()函数]

		size_t capacity() const
		{
			return _end_of_storage - _start;
		}

代码

模拟实现vector的全部代码

#pragma once
#include<iostream>
#include<assert.h>
using std::cout;
using std::cin;
using std::endl;

namespace zyy 
{
	template<class T>
	class vector
	{
		typedef T* iterator;
		typedef const T* const_itertator;
	public:
		//1.1默认构造
		vector()
			:_start(nullptr)
			,_finish(nullptr)
			,_end_of_storage(nullptr)
		{}


		//1.2 n个值构造 -- 这里使用匿名对象，是因为不知道要构造的对象是什么类型，
		vector(size_t n, const T& value = T())
		{
			resize(n, value);
		}

		//防止出现 非法的间接寻址 问题
		vector(int n, const T& value = T())
		{
			resize(n, value);
		}

		//1.3 用迭代器初始化
		template <class InputIterator>    //这里使用模板的原因是可能有很多类型的迭代器,string,int, double等
		vector(InputIterator first, InputIterator last)
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{
			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}
		
		//1.4 拷贝构造  -- 用v来初始化this
		//vector(const vector<T>& v)
		//{
		//	//注意：不能使用memcpy,memcpy是浅拷贝
		//	_start = new T[v.capacity()];   //开辟一块新的空间
		//	for (size_t i = 0; i < v.size(); ++i)
		//	{
		//		_start[i] = v[i];
		//	}

		//	_finish = _start + v.size();
		//	_end_of_storage = _start + v.capacity();
		//}

		// 拷贝构造
		vector(const vector<T>& v)
		{
			_start = new T[v.capacity()]; //开辟一块和容器v大小相同的空间
			memcpy(_start, v._start, sizeof(T) * v.size());//将容器v当中的数据一个个拷贝过来
			_finish = _start + v.size(); //容器有效数据的尾
			_end_of_storage = _start + v.capacity(); //整个容器的尾
		}

		//vector(const vector<T>& v)
		//{
		//	_start = v._start;
		//	_finish = _start + v.size(); //容器有效数据的尾
		//	_end_of_storage = _start + v.capacity(); //整个容器的尾
		//}

		//赋值运算符重载函数
		vector<T>& operator=(const vector<T> &v)
		{
			//防止自己给自己赋值
			if (this != &v)
			{
				//1.释放掉原来的空间
				delete[] _start;
				_start = new T[v.capacity()];

				for (int i = 0; i < v.size(); ++i)
				{
					_start[i] = v[i];
				}

				_finish = _start + v.size();
				_end_of_storage = _start + v.capacity();
			}

			return *this;
		}

		~vector()
		{
			delete[] _start;
			_start = nullptr;
			_finish = nullptr;
			_end_of_storage = nullptr;
		}
		//迭代器
		iterator begin()
		{
			return _start;
		}

		iterator end()
		{
			return _finish;
		}

		const_itertator begin() const
		{
			return _start;
		}

		const_itertator end() const
		{
			return _finish;
		}
		//operator[]
		T& operator[](size_t pos)
		{
			assert(pos < size());

			return _start[pos];
		}

		const T& operator[](size_t pos) const
		{
			assert(pos < size());

			return _start[pos];
		}

		//2.操作函数
		//2.1尾插
		void push_back(const T& val)
		{
			if (_finish == _end_of_storage)
			{
				int newCapacity = capacity() == 0 ? 4 : 2 * capacity();
				reserve(newCapacity);
			}

			*_finish = val;
			++_finish;
		}

		void pop_back()
		{
			assert(_finish >= _start);
			--_finish;
		}

		iterator insert(iterator pos, const T& val)
		{
			assert(pos >= _start && pos <= _finish);

			//1.判断扩容逻辑
			if (_finish == _end_of_storage)
			{
				//1.1计算出pos和_start的偏移量
				int n = _start - pos;
				int newCapacity = capacity() == 0 ? 4 : capacity() * 2;
				reserve(newCapacity);
				//1.2扩容完之后根据偏移量找到新pos的位置
				pos = _start + n;
			}

			//2.将pos后的内容往后移动
			auto end = _finish - 1;   //_finish指向的是最后一个元素的下一个位置
			while (end >= pos)
			{
				*(end + 1) = *end;
				--end;
			}

			//3.将val插入到vector中
			*pos = val;
			++_finish;

			//返回迭代器
			return pos;
		}

		iterator erase(iterator pos)
		{
			assert(pos >= _start && pos <= _finish);

			auto it = pos + 1;
			while (it != _finish)
			{
				*(it - 1) = *it;
				++it;
			}

			--_finish;

			return pos;
		}
		//2.2 扩容函数，将vector的容量扩大到n
		void reserve(size_t n)
		{
			if (n <= capacity())
			{
				//不进行任何操作
			}
			else
			{
				//先将size()的内容存储下来
				int sz = size();
				//这里的扩容是开辟一块空间，将旧的内容拷贝的新空间上
				T* tmp = new T[n]; 
				if (_start)
				{
					for (int i = 0; i < size(); ++i)
					{
						tmp[i] = _start[i];
					}
					//释放掉以前的空间
					delete[] _start;
				}
				//让_start指向新开辟的空间
				_start = tmp;
				_finish = _start + sz;
				_end_of_storage = _start + n;
			}
		}

		void resize(size_t n, const T& value = T())
		{
			if (n <= size())
			{
				_finish = _start + n;
			}
			else
			{
				//1.扩容
				reserve(n);
				//2.将内容插入到vector中
				while (_finish != _start + n)
				{
					*_finish = value;
					++_finish;
				}
			}
		}
		size_t size() const
		{
			return _finish - _start;
		}

		size_t capacity() const
		{
			return _end_of_storage - _start;
		}

		void print()
		{
			for (int i = 0; i < size(); ++i)
			{
				cout << _start[i] << " ";
			}
			cout << endl;
		}
	private:
		T* _start = nullptr;
		T* _finish = nullptr;
		T* _end_of_storage = nullptr;
	};
}

总结

在模拟实现vector中需要注意的地方：

  1. 拷贝构造函数必须使用深拷贝，不能使用memcpy()函数，因为memcpy()函数是浅拷贝。浅拷贝对内置类型没有什么影响，但是对自定义类型，可能会导致析构两次的错误。

  2. 在对vector进行扩容时，主要的思想是开辟一块新的空间，然后将原来的空间的内容拷贝到新的空间中。需要重新计算_finish和_end_of_storage，_finish = _start + size()。 如果调用size()函数就会导致访问出现问题。具体原因是size()函数的实现逻辑是_finish - _start。 在扩容之后，_start指向了新的空间，_finish还在原来的空间，使用_finish - _start会导致访问越界。因此解决办法就是在_start指向新空间时先用sz接收size()的返回值，在后续修改_finish时，就不会调用函数导致访问越界了。

  3. 当进行insert()插入时，可能会出现迭代器失效的问题。 主要原因是，在插入过程中，如果遇到扩容的情况，就会导致_start指向了新的空间，但是传入的pos还指向原来的空间，在扩容之后再进行插入，就会出现pos访问越界。
    做法和size()是一样的，先保存一下pos到_start的偏移量，在_start指向新空间之后，使用偏移量找到pos在新空间的位置。

  4. 外部迭代器失效的问题。在进行插入或者删除值之后，如果不对原来的迭代器进行更新，并且再次访问该迭代器时，就会出现迭代器失效问题。具体表现在访问迭代器为随机值。
    解决办法为：1.insert()和erase()函数都返回迭代器，并且在自己调用的时候接收迭代器（做到对迭代器的更新）。

在这里插入图片描述

gaogo12
关注
  • 26
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ STL vector 模拟实现
qq_63943454的博客
08-10 899
我们之前学习了，vector的使用，Vector在功能上就是我们数据结构阶段实现的顺序表基本一致，但是Vector在成员框架上与顺序表有所不同，且Vector使用类和对象封装支持模板泛型。
STL中vector的模拟实现
fengjunziya的博客
04-30 251
简介:STL(standard template libaray-标准模板库)：是C++标准库的重要组成部分，不仅是一个可复用的组件库，而且是一个包罗数据结构与算法的软件框架。网上有句话说：“不懂STL，不要说你会C++”。STL是C++中的优秀作品，有了它的陪伴，许多底层的数据结构，以及算法都不需要自己重新造轮子，站在前人的肩膀上，健步如飞的快速开发。而我们，则应该学会如何使用它，理解它，再到实现它。
【C++精华铺】11.STL vector模拟实现
C++领域内容分享
07-11 989
STL（Standard Template Library）是C++的标准库之一，提供了一系列的模板类和函数，用于实现常用的数据结构和算法。其中，STL的vector是一个动态数组，可以根据需要自动调整大小。vector可以存储任意类型的对象，并且可以在尾部插入和删除元素，还可以随机访问和修改任意位置的元素。它的实现使用了动态内存分配，因此在插入和删除元素时，可能会触发内存重新分配和数据拷贝，导致效率降低。vector提供了一系列的成员函数和操作符，用于操作和访问其中的元素。
STL之vector模拟实现
m0_62211222的博客
10-29 677
vector的中文意思是向量，他可以容纳很多类型的数据，因此vector也被称为容器。看到前面的解释可能你一脸蒙逼，下面我给出两种简单的理解。可以把vector理解为是一个可以动态增长的数组，一个数组可以存储多个相同类型的数据。也可以理解成是一个顺序表，里面可以存储不同类型的数据其实这两种说法本质都是一样的，因为顺序表就是用数组实现的。vector是c++的一个类，他像前面我介绍过的string类（没看过的同学看这里：）一样，有public函数，也有private成员。
C++ STL --- vector类模拟实现
weixin_57761086的博客
08-29 1483
C++STL之vector的模拟实现，模拟实现了构造模块、迭代器模块、容量模块、元素访问模块、修改模块。同时讲解了为什么不能用memset和memecpy函数。使用大量代码举例子。
C++ [STL之vector模拟实现]
ARMCSKGT的博客
05-27 5277
vector是STL容器容器之一，其底层实现类似于数据结构顺序表，相当于string来说得益于泛型模板的加持使得vector可以变为任何类型，且是可以动态扩容，堪称大号数组！在vector的实现中，有许多值得我们学习的细节，接下来将为大家一 一介绍！
C++ STL中 vector 的模拟实现
Butayarou的博客
03-20 1413
文章目录一、前言二、模拟实现的意义何在？三、vector类的模拟实现成员函数：0.迭代器相关函数begin 函数end 函数1.构造函数2.析构函数3.拷贝构造函数4.赋值重载函数5. size 函数6. capacity 函数7. swap 函数 一、前言 在C++的STL中，vector 是一个顺序容器，代表一个可动态增长的数组。因此，自己在进行模拟实现时，跟写动态顺序表类似。 vector 是一个类模板。 推荐的 C/C++ 参考文档：http://www.cplusplus.com 二、模拟实现
【C++】STL——vector模拟实现
M的博客
06-20 1391
vector的模拟实现
C++ vector模拟实现
Wzs040810的博客
01-10 3652
C++ STL vector模拟实现
STL中vector类模拟实现
08-06
vector的模拟实现，非常适合初学者学习
c++ vector模拟实现代码
08-25
下面是一个简化的`vector`模拟实现： ```cpp template class vector { public: typedef T* iterator; // 构造函数 vector() : start(nullptr), finish(nullptr), end_of_storage(nullptr) {} vector(size_t n,...
vector 模拟实现
03-20
在本模拟实现中，我们将探讨如何根据《C++ Primer》一书中的指导，创建一个基本的`vector`类，关注其核心功能，如内存管理、动态增长和STL（标准模板库）接口的兼容性。以下是对这个模拟实现的一些关键知识点的详细...
模拟vector的简易实现
07-21
下面我们将深入探讨`vector`的关键特性，并提供一个简单的模拟实现。 1. **动态内存分配**： `std::vector`的一个主要特点是它能够根据需要动态地增加或减少容量。在C++中，这通常通过调用`new`和`delete`操作符来...
C语言：文件（写入，读取）
2301_80311224的博客
08-21 695
区分二者很简单，我们可以选定一个文件，以记事本打开，如果其中的内容你能看懂，他就是一个文本文件，相反，如果是一堆你看不懂的东西，那他就是二进制文件。w+：既能读又能写，若文件不存在则创建，若文件存在则清空。若成功打开会返回文件指针，若失败则返回NULL。w：写入，若文件不存在则创建，若文件存在则清空。r：只读取，若文件不存在，fopen调用失败。a+：既能读又能写，若文件不存在则创建。在打开和关闭文件中，进行操作文件。a：追加写入，若文件不存在则创建。r+：既能读又能写，文件必须存在。
C++ 重载运算符和重载函数
lly202406的博客
08-25 360
在C++编程语言中，运算符重载和函数重载是两个非常核心的概念，它们允许开发者扩展或重新定义运算符和函数的行为，以适应特定的数据类型或对象。本文将详细探讨C++中的运算符重载和函数重载，包括它们的基本概念、使用场景、实现方式以及注意事项。
【C语言篇】
最新发布
2301_81072404的博客
08-25 43
条件编译（#ifdef、#ifndef、#else、#elif、#endif）指针与动态内存分配（malloc、calloc、realloc、free）文件的读写操作（fread、fwrite、fprintf、fscanf等）控制语句（if、for、while、do-while、switch等）字符串处理函数（strlen、strcpy、strcat等）运算符（算术运算符、关系运算符、逻辑运算符等）文件的打开与关闭（fopen、fclose）数据类型（整型、浮点型、字符型等）函数参数传递（传值、传址）
C++ 基础
weixin_51883798的博客
08-22 268
MyClass&& other:这是一个右值引用参数，指向要移动的对象。右值引用允许我们访问即将被销毁的对象，从中“窃取”资源。该关键字表示移动构造函数不会抛出异常。这是一个优化提示，告诉编译器在需要时可以安全地使用移动构造函数。这是C++11标准中新引入的一个特性，旨在提高性能，尤其是在涉及临时对象和资源管理时。特殊的成员函数，允许将一个对象的状态转移到另一个新创建的对象中，不需要进行复制。
Java以JNI形式调用C/C++动态库实现回调方法
liuyuxuan2388的博客
08-24 347
由于我需要做的是在DLL中的一个线程里改变某个java对象的值,所以,还必须获取那个java对象的jobject指针.同 JNIEnv 指针一样,jobject指针也不能在多个线程中共享. 就是说,不能直接在保存一个线程中的jobject指针到全局变量中,然后在另外一个线程中使用它.幸运的是,可以用。然而JNI文档上说，JNI接口的指针JNIEnv*不能在c++的线程间共享，在我的程序中，如果接收线程试图调用java对象的方法，程序会突然退出。Java生成.h头文件（以Test.java为例）
模拟C++STL中的vector的实现
05-11
下面是一个简单的C++STL中vector的实现，仅供参考： ```c++ template<class T> class myVector{ private: T *data; // 存储空间指针 int capacity; // 当前容量 int size; // 元素个数 public: // 构造函数 myVector(){ data = new T[1]; // 初始容量为1 capacity = 1; size = 0; } // 析构函数 ~myVector(){ delete[] data; } // 返回元素个数 int getSize(){ return size; } // 返回容量 int getCapacity(){ return capacity; } // 添加元素 void push_back(T element){ if(size == capacity){ // 容量不足，扩容 T *newData = new T[capacity * 2]; for(int i=0; i<size; i++){ newData[i] = data[i]; } delete[] data; data = newData; capacity *= 2; } data[size++] = element; } // 删除最后一个元素 void pop_back(){ if(size > 0){ size--; } } // 访问元素 T& operator[](int index){ return data[index]; } }; ``` 这个实现中，我们使用了动态内存分配来实现vector的扩容和缩容，同时提供了getSize、getCapacity、push_back、pop_back、operator[]等常用操作。需要注意的是，这个实现并没有考虑线程安全等问题，实际上STL中的vector是支持多线程的。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值