CMyStirng代码的问题分析
class CMyString
{
public:
CMyString(const char *str = nullptr)
{
cout << "CMyString(const char*)" << endl;
if (str != nullptr)
{
mptr = new char[strlen(str) + 1];
strcpy(mptr, str);
}
else
{
mptr = new char[1];
*mptr = '\0';
}
}
~CMyString()
{
cout << "~CMyString" << endl;
delete[]mptr;
mptr = nullptr;
}
//带左值引用参数的拷贝构造
CMyString(const CMyString &str)
{
cout << "CMyString(const CMyString&)" << endl;
mptr = new char[strlen(str.mptr) + 1];
strcpy(mptr, str.mptr);
}
//带左值引用参数的赋值重载函数
CMyString& operator=(const CMyString &str)
{
cout << "operator=(const CMyString&)" << endl;
if (this == &str)
return *this;
delete[]mptr;
mptr = new char[strlen(str.mptr) + 1];
strcpy(mptr, str.mptr);
return *this;
}
const char* c_str()const { return mptr; }
private:
char *mptr;
};
由于问题场景的特殊,子函数调用时我们无法返回一个临时对象。
而且我们也只能用赋值的方式接收一个函数调用的返回值。
我们来分析分析上面的代码
1、首先,str1和str2都是调用普通构造函数。
实参str1到形参str是引用的方式接收,没有产生构造。
2、然后普通构造tmpStr局部对象。 tmpStr这个对象占4个字节,有一个char*指针,指向外部的一个new出来的堆内存,堆内存存放的是字符串。
然后return tmpStr;tmpStr是局部对象,3、只能调用拷贝构造函数,
构建一个新的对象,
4、tmpStr拷贝构造新对象,然后调用析构函数析构tmpStr对象,这样就白耗费资源了,tmpStr资源不要就早说,直接给函数栈帧上的对象就好啦。
我们想要拷贝构造函数做这个事情:
就完全没有内存开辟,内存释放和数据拷贝了。
这是我们的目的,但是不能这样改,不然正常的拷贝构造函数就没法做了
接下来我们再看第二个问题
用临时量给str2赋值,str2是原本已经存在的对象,它也有一个指针mptr,原先也指向了一个空间。
对于赋值来说,排除自赋值,然后把原先指向的空间释放掉,然后按照str的尺寸开辟空间,然后拷贝数据进行来。即按照临时对象的字符串大小开辟空间,然后把数据一个一个拷贝进来。
然后出语句,把这个临时对象析构及它指向的堆内存空间释放掉。
瞎折腾!直接把临时对象的外部资源给str2不就完了吗?
复习一下右值引用
int main()
{
//右值引用
int a = 10;
int &b = a;//左值:有内存、有名字 右值:没名字(临时量)或没内存
//int &&c = a;//无法将左值绑定到右值引用
//int &c = 20;//不能用左值引用绑定一个右值
/*
int tmp = 20;
const int &c = tmp; 通过这个c不可以改临时量的值
*/
const int &c = 20;//可以!
/*
int tmp = 20;
int &&d = tmp; 通过这个d是可以改临时量的值
*/
int &&d = 20;//可以把一个右值绑定到一个右值引用上
//C++11把临时量都当做右值处理
CMyString &&e = CMyString("aaa");//可以!
const CMyString &e = CMyString("aaa");//可以!
int &f = d;//一个右值引用变量,本身是一个左值,d:有内存有名字
return 0;
}
用右值引用优化CMyStirng代码
class CMyString
{
public:
CMyString(const char *str = nullptr)
{
cout << "CMyString(const char*)" << endl;
if (str != nullptr)
{
mptr = new char[strlen(str) + 1];
strcpy(mptr, str);
}
else
{
mptr = new char[1];
*mptr = '\0';
}
}
~CMyString()
{
cout << "~CMyString" << endl;
delete[]mptr;
mptr = nullptr;
}
//带左值引用参数的拷贝构造
CMyString(const CMyString &str)
{
cout << "CMyString(const CMyString&)" << endl;
mptr = new char[strlen(str.mptr) + 1];
strcpy(mptr, str.mptr);
}
//带右值引用参数的拷贝构造
CMyString(CMyString &&str)//str引用的就是一个临时对象
{
cout << "CMyString(CMyString&&)" << endl;
mptr = str.mptr;
str.mptr = nullptr;
}
//带左值引用参数的赋值重载函数
CMyString& operator=(const CMyString &str)
{
cout << "operator=(const CMyString&)" << endl;
if (this == &str)
return *this;
delete[]mptr;
mptr = new char[strlen(str.mptr) + 1];
strcpy(mptr, str.mptr);
return *this;
}
//带右值引用参数的赋值重载函数
CMyString& operator=(CMyString &&str)//str引用的是临时对象
{
cout << "operator=(CMyString&&)" << endl;
if (this == &str)
return *this;
delete[]mptr;
mptr = str.mptr;
str.mptr = nullptr;
return *this;
}
const char* c_str()const { return mptr; }
private:
char *mptr;
friend CMyString operator+(const CMyString &lhs,
const CMyString &rhs);
friend ostream& operator<<(ostream &out, const CMyString &str);
};
CMyString operator+(const CMyString &lhs,
const CMyString &rhs)
{
//char *ptmp = new char[strlen(lhs.mptr) + strlen(rhs.mptr) + 1];
CMyString tmpStr;
tmpStr.mptr = new char[strlen(lhs.mptr) + strlen(rhs.mptr) + 1];
strcpy(tmpStr.mptr, lhs.mptr);
strcat(tmpStr.mptr, rhs.mptr);
//delete []ptmp;
return tmpStr;//直接调用右值拷贝构造函数
//return CMyString(ptmp);
}
ostream& operator<<(ostream &out, const CMyString &str)
{
out << str.mptr;
return out;
}
示意图如下:
同样的代码,我们运行一下
没有任何内存的开辟和释放和数据的拷贝
CMyStirng在vector上的应用
这两个push_back是调用的是普通的拷贝构造函数还是右值的拷贝构造函数?
int main()
{
CMyString str1 = "aaa";//普通构造
vector<CMyString> vec;
vec.reserve(10);
cout << "-----------------------" << endl;
vec.push_back(str1);//在底层数组上拷贝构造一个新对象
vec.push_back(CMyString("bbb"));//先进行临时对象的构造,然后调用右值拷贝构造,把资源直接给vector底层
cout << "-----------------------" << endl;
return 0;
}
move和forward
剖析并完成push_back方法
引用重叠:
左值引用+右值引用=左值引用
右值引用+右值引用=右值引用
一个模板可以代替下面这2个函数
但是模板函数中调用construct传入的val还是一个左值啊!怎么区分左值右值引用调用?
在模板函数调用construct中引入std::forward
可以返回val到底是左值还是右值
forward:类型完美转发,能够识别左值和右值类型
可以根据参数val本身的定义识别出val是左值还是右值。如果val是左值类型它就会返回左值类型,调用construct的左值引用的函数。如果val是右值类型,它就返回右值类型,调用construct的右值引用的函数。
forward是通过模板的非完全特例化实现的。
move(左值):移动语义,得到右值类型 (int&&)a
#include <iostream>
#include <vector>
using namespace std;
template<typename T>
struct Allocator
{
T* allocate(size_t size)//负责内存开辟
{
return (T*)malloc(sizeof(T) * size);
}
void deallocate(void *p)//负责内存释放
{
free(p);
}
/*void construct(T *p, const T &val)//负责对象构造
{
new (p) T(val); // 定位new
}
void construct(T *p, T &&val)//负责责对象构造
{
new (p) T(std::move(val));
//定位new 强转成右值引用类型 调用底层的CMyString的右值引用的拷贝构造函数
}*/
//可以用std::move强转成右值,也可以如下做法:
//无法区分右值和左值的简便的解决办法:
template<typename Ty>
void construct(T *p, Ty &&val)
{
new (p) T(std::forward<Ty>(val));
}
void destroy(T *p)//负责对象析构
{
p->~T();// ~T()代表了T类型的析构函数
}
};
/*
容器底层内存开辟,内存释放,对象构造和析构,都通过allocator空间配置器来实现
*/
template<typename T, typename Alloc = Allocator<T>>
class vector
{
public:
vector(int size = 10)//构造函数
{
//需要把内存开辟和对象构造分开处理
//_first = new T[size];
_first = _allocator.allocate(size);
_last = _first;
_end = _first + size;
}
~vector()//析构函数
{
//析构容器有效的元素,然后释放_first指针指向的堆内存
//delete[]_first;
for (T *p = _first; p != _last; ++p)
{
_allocator.destroy(p);//把_first指针指向的数组的有效元素进行析构操作
}
_allocator.deallocate(_first);//释放堆上的数组内存
_first = _last = _end = nullptr;
}
vector(const vector<T> &rhs)//拷贝构造函数
{
int size = rhs._end - rhs._first;
//_first = new T[size];
_first = _allocator.allocate(size);
int len = rhs._last - rhs._first;
for (int i = 0; i < len; ++i)
{
//_first[i] = rhs._first[i];
_allocator.construct(_first + i, rhs._first[i]);
}
_last = _first + len;
_end = _first + size;
}
vector<T>& operator=(const vector<T> &rhs)//赋值函数
{
if (this == &rhs)
return *this;
//delete[]_first;
for (T *p = _first; p != _last; ++p)
{
_allocator.destroy(p);//把_first指针指向的数组的有效元素进行析构操作
}
_allocator.deallocate(_first);
int size = rhs._end - rhs._first;
//_first = new T[size];
_first = _allocator.allocate(size);
int len = rhs._last - rhs._first;
for (int i = 0; i < len; ++i)
{
//_first[i] = rhs._first[i];
_allocator.construct(_first + i, rhs._first[i]);
}
_last = _first + len;
_end = _first + size;
return *this;
}
void pop_back()//从容器末尾删除元素
{
if (empty())
return;
//--_last; //不仅要把_last指针--,还需要析构删除的元素
--_last;
_allocator.destroy(_last);
}
T back()const//返回容器末尾的元素的值
{
return *(_last - 1);
}
bool full()const { return _last == _end; }
bool empty()const { return _first == _last; }
int size()const { return _last - _first; }
//
/*void push_back(const T &val)//接收左值
{
if (full())
expand();
_allocator.construct(_last, val);
_last++;
}
void push_back(T &&val)//接收右值 一个右值引用变量本身还是一个左值
{
if (full())
expand();
_allocator.construct(_last, std::move(val));
//val本身还是左值啊。匹配的还是左值的construct。怎么办?
//使用std::move把val 强转成右值引用类型
_last++;
}*/
//void push_back(CMyString &val)
//CMyString&& + && = void push_back(CMyString&&val)
template<typename Ty>//函数模板的类型推演 + 引用折叠
void push_back(Ty &&val)//Ty CMyString& + && = CMyString&
{
if (full())
expand();
//move(左值):移动语义,得到右值类型 (int&&)a
//forward:类型完美转发,能够识别左值和右值类型
_allocator.construct(_last, std::forward<Ty>(val));
_last++;
}
private:
T *_first;//指向数组起始的位置
T *_last;//指向数组中有效元素的后继位置
T *_end;//指向数组空间的后继位置
Alloc _allocator; // 定义容器的空间配置器对象
void expand()//容器的二倍扩容
{
int size = _end - _first;
//T *ptmp = new T[2 * size];
T *ptmp = _allocator.allocate(2 * size);
for (int i = 0; i < size; ++i)
{
//ptmp[i] = _first[i];
_allocator.construct(ptmp + i, _first[i]);
}
//delete[]_first;
for (T *p = _first; p != _last; ++p)
{
_allocator.destroy(p);
}
_allocator.deallocate(_first);
_first = ptmp;
_last = _first + size;
_end = _first + 2 * size;
}
};
int main()
{
CMyString str1 = "aaa";
vector<CMyString> vec;
cout << "-----------------------" << endl;
vec.push_back(std::move(str1));//CMyString&
vec.push_back(CMyString("bbb"));//CMyString&& move forword
cout << "-----------------------" << endl;
return 0;
}
返回容器的效率
#include <iostream>
#include <vector>
using namespace std;
class CMyString
{
public:
CMyString(const char *str = nullptr)
{
cout << "CMyString(const char*)" << endl;
if (str != nullptr)
{
mptr = new char[strlen(str) + 1];
strcpy(mptr, str);
}
else
{
mptr = new char[1];
*mptr = '\0';
}
}
~CMyString()
{
cout << "~CMyString" << endl;
delete[]mptr;
mptr = nullptr;
}
//带左值引用参数的拷贝构造
CMyString(const CMyString &str)
{
cout << "CMyString(const CMyString&)" << endl;
mptr = new char[strlen(str.mptr) + 1];
strcpy(mptr, str.mptr);
}
//带右值引用参数的拷贝构造
CMyString(CMyString &&str)
{
cout << "CMyString(CMyString&&)" << endl;
mptr = str.mptr;
str.mptr = nullptr;
}
//带左值引用参数的赋值重载函数
CMyString& operator=(const CMyString &str)
{
cout << "operator=(const CMyString&)" << endl;
if (this == &str)
return *this;
delete[]mptr;
mptr = new char[strlen(str.mptr) + 1];
strcpy(mptr, str.mptr);
return *this;
}
//带右值引用参数的赋值重载函数
CMyString& operator=(CMyString &&str)//临时对象
{
cout << "operator=(CMyString&&)" << endl;
if (this == &str)
return *this;
delete[]mptr;
mptr = str.mptr;
str.mptr = nullptr;
return *this;
}
const char* c_str()const { return mptr; }
private:
char *mptr;
};
vector<CMyString> GetVector()
{
CMyString str1 = "aaa", str2 = "bbb", str3 = "ccc";
cout << "------------------------" << endl;
vector<CMyString> vec;
vec.reserve(10);
vec.push_back(std::move(str1));
vec.push_back(std::move(str2));
vec.push_back(std::move(str3));
return vec;//匹配的是容器的右值引用参数的拷贝构造
}
int main()
{
vector<CMyString> vec;
vec = GetVector();//匹配的是容器的右值引用参数的赋值函数
return 0;
}