使用自实现的string和vector类说明std::move和std::forward

已于 2023-08-14 22:03:06 修改
阅读量596 收藏
点赞数
分类专栏： C++2.0常用特性 文章标签： string vector move forward c++
于 2020-06-27 17:36:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/KingOfMyHeart/article/details/106984906
版权

在看文章前需要明确一点，引用的重叠：

template <typename T>
void Func(T &&val){//....}

1.当实例化的T的为一个左值引用时，即 T& ++ &&,最终val是一个左值；
2.当实例化的T的为一个右值引用时，即 T&& ++ &&,最终val是一个右值；

string和vector类的代码：

#include <iostream>
#include <string.h>
using namespace std;

#include<iostream>
#include <string.h>
using namespace std;

//自定义string类
class String
{
public:
//构造函数
String(const char *ptr = nullptr){
	std::cout << "String(const char *ptr)" << std::endl;
	if (ptr == nullptr){
		mpstr = new char[1];
		mpstr[0] = '\0';
	}else{
		mpstr = new char[strlen(ptr) + 1];
		strcpy(mpstr, ptr);
	}
}
//左值引用参数的拷贝构造函数
String(const String &src){ //src引用的是一个左值
	std::cout << "String(const String &src)" << std::endl;
	mpstr = new char[strlen(src.mpstr) + 1];
	strcpy(mpstr, src.mpstr);
}

//右值引用参数的拷贝构造函数
String(String &&src){//src引用的是一个临时对象
	std::cout << "String(const String &&src)" << std::endl;
	mpstr = src.mpstr;
	src.mpstr = nullptr;
}

//左值引用参数赋值运算符的重载函数
String& operator=(const String &src){//src引用的是一个左值
	std::cout << "String& operator=(const String &src)" << std::endl;
	if (this == &src)
		return *this;
	delete[]mpstr;
	mpstr = new char[strlen(src.mpstr) + 1];
	strcpy(mpstr, src.mpstr);
	return *this;
}

//右值引用参数赋值运算符的重载函数
String& operator=(String &&src){ //src引用的是一个临时对象
	std::cout << "String& operator=(const String &&src)" << std::endl;
	if (this == &src)
		return *this;
	delete[]mpstr;
	mpstr = src.mpstr;
	src.mpstr = nullptr;
	return *this;
}

~String(){
    std::cout << "~String()" << std::endl;
	if (mpstr != nullptr){
		delete mpstr;
		mpstr = nullptr;
	}
}

bool operator>(const String &src){
		if (strcmp(mpstr, src.mpstr) > 0)
			return true;
		return false;
}
bool operator<(const String &src){
		if (strcmp(mpstr, src.mpstr) < 0)
			return true;
		return false;
	}
bool operator==(const String &src){
		if (strcmp(mpstr, src.mpstr) == 0)
			return true;
		return false;
	}
	//获取字符串的长度
int length()const{ return strlen(mpstr); }
	//根据下标返回对应的字符
char& operator[](int index){ return mpstr[index]; }
	//返回该字符串
const char* c_str()const{ return mpstr; }
private:
	char *mpstr;
	friend String operator+(const String &lhs, const String &rhs);
	friend ostream& operator<<(ostream &out, const String &src);
};
//operator+
String operator+(const String &lhs, const String &rhs){
    String str;
	char* temp = new char[lhs.length() + rhs.length() + 1];
	strcpy(str.mpstr, lhs.mpstr);
	strcat(str.mpstr, rhs.mpstr);
	return str;
}
ostream& operator<<(ostream &out, const String &src){
	out << src.mpstr;
	return out;
}


//vector的空间配置器 Allocator
template<typename T>
struct Allocator{
    T*allocate(size_t size){ //负责开辟内存
        return (T*)malloc(sizeof(T)*size);
    }
    void deallocate(void *p){//负责内存的释放
        free(p);
    }
    //带左值参数的construct
    void construct(T*p,const T&val){//负责在指定位置构造对象
        new (p) T(val);//定位new
    }
    //带右值参数的construct
    void construct(T*p,T&&val){//负责在指定位置构造对象
        new (p) T(std::move(val));//定位new
    }
    void destroy(T*p){ //负责指定对象p的析构，类型为T
        p->~T();
    }
};

//自定义vector类
template <typename T, typename Alloca = Allocator<T>>
class Vector
{
public:
	//默认构造的vector，底层没分配过内存0
Vector() :mpVec(NULL), mSize(0), mCur(0){}
	//size表示初始的内存大小，val表示内存初始值
Vector(int size, const T &val = T())
	:mSize(size), mCur(size){
	mpVec = _allocator.allocate(mSize * sizeof(T));
	for (int i = 0; i < mSize; ++i){
		_allocator.construct(mpVec + i, val);
	}
}
//带左值参数的拷贝构造
Vector(const Vector &src)
	:mSize(src.mSize), mCur(src.mCur){
	mpVec = _allocator.allocate(sizeof(T)*mSize);
	for (int i = 0; i < mCur; ++i){
		_allocator.construct(mpVec + i, src.mpVec[i]);
	}
}

//operator=
Vector& operator=(const Vector &src){
	if (this == &src)
		return *this;

	for (int i = 0; i < mCur; ++i){
		_allocator.destroy(mpVec + i);
	}
	_allocator.deallocate(mpVec);

	mpVec = _allocator.allocate(sizeof(T)*mSize);
	for (int i = 0; i < mCur; ++i){
		_allocator.construct(mpVec + i, src.mpVec[i]);
	}
	return *this;
}
~Vector(){
	for (int i = 0; i < mCur; ++i){
		_allocator.destroy(mpVec + i);
	}
	_allocator.deallocate(mpVec);
	mpVec = NULL;
}

//带左值参数的末尾添加元素    
void push_back(const T &val) {
	std::cout<<"push_back(const T &val)"<<std::endl;
	if (full())
		reSize();
    _allocator.construct(mpVec + mCur, val);
	mCur++;
}

//带右值参数的末尾添加元素    
void push_back(T &&val) {
    std::cout<<"push_back(T &&val)"<<std::endl;
	if (full())
		reSize();
    _allocator.construct(mpVec + mCur, std::move(val));
	mCur++;
}
	//末尾删除
void pop_back(){
	if (empty())
		return;
	--mCur;
	_allocator.destroy(mpVec + mCur);
}

T front()const{ return mpVec[0]; }
T back()const{ return mpVec[mCur - 1]; }

bool full()const{ return mCur == mSize; }
bool empty()const{ return mCur == 0; }

T& operator[](int index){ return mpVec[index]; }

//内存以2倍方式增长
void reSize(){
	//默认的size==0
	if (mSize == 0){
		mpVec = _allocator.allocate(sizeof(T));mSize = 1;mCur = 0;
	}else{
	    T *ptmp = _allocator.allocate(mSize * 2 * sizeof(T));
		for (int i = 0; i < mCur; ++i){
		    _allocator.construct(ptmp + i, mpVec[i]);
		}
		mSize *= 2;
		for (int i = 0; i < mCur; ++i){
			_allocator.destroy(mpVec + i);
		}
		_allocator.deallocate(mpVec);
		mpVec = ptmp;
	}
}

int size()const{ return mCur; }

//定义当前容器的迭代器类型 ，遍历容器(遍历容器底层的数据结构)
class iterator
{
public:
	iterator(T *p = NULL){
		ptr = p;
	}
	bool operator!=(const iterator &it){
		return ptr != it.ptr;
	}
	int operator-(const iterator &it){
		return ptr - it.ptr;
	}
	void operator++(){
		++ptr;
	}
	T& operator*(){
	    return *ptr;
	}
	private:
		T *ptr;  //本质上就是一根被泛化的指针
	};

	iterator begin(){ return iterator(mpVec); }
	iterator end(){ return iterator(mpVec + mCur); }

private:
	T *mpVec;//动态数组的起始地址，相当于first
	int mSize;//容量
	int mCur;//当前size
	Alloca _allocator;//空间配置器对象
};

int main(){
    String str1 = "123";
    Vector<String> vec1;
    Vector<String> vec2;
    Vector<String> vec3;
    vec1.push_back(str1);
    vec2.push_back(std::move(str1));
    vec3.push_back(String("xxxx"));
    return 0;
}

我们将代码中vector的push_back和Allocator的construct取出来说明 std::move 的作用：

//带左值参数的末尾添加元素    
void push_back(const T &val) {
	if (full())
		reSize();
    _allocator.construct(mpVec + mCur, val);
	mCur++;
}

//带右值参数的末尾添加元素    
void push_back(T &&val) {
    std::cout<<"push_back(T &&val)"<<std::endl;
	if (full())
		reSize();
    _allocator.construct(mpVec + mCur, std::move(val));
    /*
    val接收的是一个右值，但是在当前函数本身是一个左值，所以，我们想
    调用配置器的带右值引用的construct，在这里调用String的带右值的拷贝构造函数，
    需要将val强转成一个右值进行传递，
    所以，使用std::move进行转换，不管val是左值还是右值，得到的都是一个右值。
    */
	mCur++;
}

总结：
std::move将一个值，无论是左值还是右值都强转为右值。但是出现一个问题，这样的代码我们每次都要去实现一个带右值参数的，一个带左值参数的，效率并不高，接下来将引出std::forward，将最初传进来的右值完美的转发，保证不会变为左值，不需要我们进行强转。

std::forward:

template <typename Ty>
void push_back(Ty &&val){
    std::cout<<"template push_back"<<std::endl;
	if (full())
		reSize();
    _allocator.construct(mpVec + mCur, std::forward(val));
    mCur++;
}

template <typename Ty>
void construct(T*p,Ty&&val){
     std::cout<<"template construct"<<std::endl;
     new (p) T(std::forward<Ty>(val));//定位new
}

运行结果：

String(const char *ptr)
template push_back
template construct
String(const String &src)
template push_back
template construct
String(const String &&src)
String(const char *ptr)
template push_back
template construct
String(const String &&src)
~String()
~String()
~String()
~String()
~String()

std::forward总结：

  1. 不过不加std::forward,在push_back中，val是一个左值，其实我们想给construct中传入一个右值；
  2. 加上std::forward,尽管val在函数push_back中是一个左值，但是std::forward能知道，能够识别，调用者传给push_back的一开始就是个右值，所以会把val是右值的类型完美的转发传达给construct，就不需要我们手动去调用std::move强转,一个函数写两个版本.

完美转发实现了参数在传递过程中保持其值属性的功能，即若是左值，则传递之后仍然是左值，若是右值，则传递之后仍然是右值。

这里放一个解释不错的文字链接，可以结合我上面例子进行学习

KingOfMyHeart
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
有效使用Lambda表达式和std::function
01-31
C++11的lambda表达式使它们更有效地被使用函数对象类，即实现operator()的类，多年来被C++程序员所熟知，它们被用做 STL算法中的谓词(predicate)。然而，实现简单的函数对象类是一件繁琐的事情，如：假设v是int为...
【C++】STL之vector功能及模拟实现
最新发布
m0_63198468的博客
07-24 691
本文讲解了vector接口的使用，并附有例子清晰易懂，重点讲解了vector的模拟实现，并且在模拟实现过程中，迭代器失效的问题和深浅拷贝的问题。
STL vector 模拟实现
叫我小秦就好了的博客
01-09 644
vector 的数据结构安排及操作方式，与原生数组十分相似，两者唯一的差别在于空间运用的灵活性。原生数组是静态空间，一旦配置了就不能改变大小；vector 是动态空间，可以在插入过程中动态调整空间大小。vector 的实现技术，关键在于它对大小的控制及重新配置时的数据移动效率。
一文带你详细介绍c++中的std::move函数
木牛的博客
03-17 7639
在C++11中，标准库在<utility>中提供了一个有用的函数std::move，std::move并不能移动任何东西，它唯一的功能是将一个左值强制转化为右值引用，继而可以通过右值引用使用该值，以用于移动语义。从实现上讲，std::move基本等同于一个类型转换：static_cast<T&&>(lvalue); 前言 在探讨c++11中的Move函数前，先介绍两个概念（左值和右值） 左值和右值 首先区分左值和右值 左值是表达式结束后依然存在的持久对象(
std:move基本用法和理解
Clement
08-30 2万+
场景: C++ 标准库使用比如vector::push_back 等这类函数时,会对参数的对象进行复制,连数据也会复制.这就会造成对象内存的额外创建, 本来原意是想把参数push_back进去就行了. C++11 提供了std::move 函数来把左值转换为右值, 而且新版的push_back也支持&&参数的重载版本,这时候就可以高效率的使用内存了. 对指针类型的标准库对象并不需要这么做. 参考: Move Constructors and Move Assignment Operat
std::vector容器 move语义测试代码
Joshua的专栏
03-26 818
因为新项目需要有在多线程传递容器的操作，特意做了一个vector容器move语义的测试代码。 1. 代码 #include <iostream> #include <vector> int main() { std::cout << "Hello World!\n"; std::vector<int> v0; for (int i = 0; i < 10; i++) v0.push_back(i);
std::vector 与 std::move 配合使用
smalbig的博客
04-10 566
含有堆上数据(data 和 value)的类D实现了移动构造函数 D(D&& other) 后，与std::vector 的 push_back 和 emplace_back 配合使用，特定条件下可以提高效率。从测试结果来看移动构造由于节省了很多拷贝 data 的时间， push_back 和 emplace_back 得到了速度上的优化，其他 std 容器类比一下应该具有同样特性。的一点是以下代码不能获得这种优化，在 emplace_back（push_back）时，调用的还是拷贝构造函数。
C++ 模板写的短小字符串类，用于替换字符数组和std::string
03-11
//短小字符串类 template struct TinyString { TinyString(); template<size_t K> TinyString(const TinyString<K>& str); TinyString(size_t n, char c); TinyString(const char* s, size_t n=0...
c++11 std::move() 的使用
01-07
std::move函数可以以非常简单的方式将左值引用转换为右值引用。（左值、左值引用、右值、右值引用 参见：http://www.cnblogs.com/SZxiaochun/p/8017475.html） 通过std::move，可以避免不必要的拷贝操作。 std::move...
std::string format格式化函数源代码及两种格式化方法
01-20
本程序提供了std::string 类型的Format格式化函数，以及两种格式化string字符串的方法，主方法在str.hpp文件中，测试文件在string_format.cpp中，已测试可用
自编MStirng(类似std::string)以及配套的4种iterators
09-10
自己编写的string类，名字叫做MString。并且编写了配套的iterator、const_iterator、reverse_iterator、const_reverse_iterator。完全支持stl的各种算法，包括支持insert_iterator()转换。编写它的目的不是为了使用...
2023最新C++面经(一):vector内存预分配,左值引用和右值引用,move语义
木牛的博客
03-31 1063
今天在朋友圈看到别人发的一套C++面经，特意思考了一下。
cpp std::vector 与 std::move
weixin_37210821的博客
06-17 1672
代码 #include<iostream> #include<vector> #include<utility> using namespace std; int main() { vector<int> a ; a.push_back(1); a.push_back(2); a.push_back(3); for(auto i : a) cout << "a i
c++ 之 std::move 原理实现与用法总结
热门推荐
学之知之的博客
11-30 25万+
在C++11中，标准库在&lt;utility&gt;中提供了一个有用的函数std::move，std::move并不能移动任何东西，它唯一的功能是将一个左值强制转化为右值引用，继而可以通过右值引用使用该值，以用于移动语义。从实现上讲，std::move基本等同于一个类型转换：static_cast&lt;T&amp;&amp;&gt;(lvalue); std::move函数可以以非常简单的方...
std::move()与移动构造函数
ThinPikachu的博客
01-17 3320
目录 std::move() C++移动构造函数 std::move() std::move的功能是将一个左值强制转化为右值引用，并返回该右值引用，继而可以通过右值引用使用该值，以用于移动语义（移动构造函数或移动赋值运算符）。 std::move 的函数原型定义 template <typename T> typename remove_reference<T>::type&& move(T&& t) { return static_c
C++:STL:vector: move赋值构造；右值引用；
mzhan017的博客
11-28 1847
理解这个的首要任务是理解 &&；两个地址符的含义就是对右值的引用；
C++11多线程中的detach()、join()、joinable()
KingOfMyHeart的博客
07-19 6651
一.传统多线程编写: 一般来说,我们在主线程中开辟出一些子线程来完成我们的任务,正常情况下,需要在主线程的最后调用join(),用于阻塞主线程,避免主线程先于其他子线程执行完毕,退出,然后导致整个进程的异常. join():阻塞主线程,等待其他子线程执行完毕,正常退出. 二.非传统多线程编写: 引入detach() 有人说,我们创建多个线程完成一些任务,不过需要主线程最后等待所有的子线程完毕才能...
std::vector<std::string> 和string[]
07-20
std::vector<std::string>和string[]都是用于存储多个字符串的数据结构，但在语法和使用上有一些不同之处。 1. std::vector<std::string>是C++中的容器类，用于动态存储和管理字符串。它提供了一系列成员函数来方便...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值