//#pragma once
//
//class String
//{
//public:
// String(char* str = "")
// :_str(new char[strlen(str)+1])
// {
// strcpy(_str, str);
// _str[strlen(str)] = '\0';
// }
//
// // 传统写法
// //String s2(s1);
// //String(const String& s)
// // :_str(new char[strlen(s._str)+1])
// //{
// // strcpy(_str, s._str);
// // _str[strlen(s._str)] = '\0';
// //}
//
// // s2 = s2
// // s2 = s3 => s2.operator(&s2, s3)
// //String& operator=(const String& s)
// //{
// // if (this != &s)
// // {
// // delete[] _str;
// // size_t len = strlen(s._str);
// // _str = new char[len+1];
// // //strcpy(this->_str, s._str);
// // //_str[len] = '\0';
// // memcpy(_str, s._str, len+1);
// // }
// //
// // return *this;
// //}
//
// // s2 = s3
// //String& operator=(const String& s)
// //{
// // if (this != &s)
// // {
// // size_t len = strlen(s._str);
// // char* tmp = new char[len+1];
// // memcpy(tmp, s._str, len+1);
//
// // delete[] _str;
// // _str = tmp;
// // }
//
// // return *this;
// //}
//
// // 现代写法
// String(const String& s)
// {
// String tmp(s._str);
// swap(_str, s._str);
// }
//
// String& operator=(String s)
// {
// swap(s._str, _str);
// return *this;
// }
//
// ~String()
// {
// delete[] _str;
// }
//
//public:
// //void PushBack(char ch);
// //void
//
//public:
// char* _str;
//
// size_t _size;
// size_t _capacity;
//};
//
//void TestString1()
//{
// // 深浅拷贝
// String s1("string1");
// String s2(s1);
// String s3("peter");
//
// s2 = s3;
// //s2 = s2;
//
// String s4;
//}
#pragma once
// mystrcpy
// mymemmove
// 传统写法
//class String
//{
//public:
// String(const char* str = "")
// :_str(new char[strlen(str)+1])
// {
// //strcpy(_str, str);
// //_str[strlen(str)] = '\0';
// memcpy(_str, str, strlen(str)+1);
// }
//
// //String s2(s1);
// String(const String& s)
// //:_str(new char[strlen(s._str)+1])
// {
// size_t len = strlen(s._str);
// _str = new char[len+1];
// memcpy(this->_str, s._str, len+1);
// }
//
// // s1 = s2;
// String& operator=(const String& s)
// {
// if (this != &s)
// {
// // 开辟新的空间,并且拷贝数据
// size_t len = strlen(s._str);
// char* tmp = new char[len+1];
// memcpy(tmp, s._str, len+1);
//
// // 释放旧的空间
// delete [] _str;
//
// _str = tmp;
// }
//
// return *this;
// }
//
// ~String()
// {
// delete[] _str;
// }
//
// char* GetStr()
// {
// return _str;
// }
//
//protected:
// char* _str;
//};
// 现代写法
//class String
//{
//public:
// String(const char* str = "")
// :_str(new char[strlen(str)+1])
// {
// //strcpy(_str, str);
// //_str[strlen(str)] = '\0';
// memcpy(_str, str, strlen(str)+1);
// }
//
// String(const String& s)
// :_str(NULL)
// {
// String tmp(s._str);
// swap(_str, tmp._str);
// }
//
// // s1 = s3
// // s1 = s1
// //String& operator=(const String& s)
// //{
// // if (this != &s)
// // {
// // //String tmp(s._str);
// // String tmp(s);
// // swap(_str, tmp._str);
// // }
//
// // return *this;
// //}
//
// // s1 = s2;
// // s1 = s1;
// String& operator=(String s)
// {
// swap(_str, s._str);
// return *this;
// }
//
// ~String()
// {
// delete[] _str;
// }
//
// char* GetStr()
// {
// return _str;
// }
//
//protected:
// char* _str;
//};
//
扩展String功能--增删查改
//class String
//{
//public:
// String(const char* str = "")
// :_size(strlen(str))
// ,_capacity(_size+1)
// {
// _str = new char[_capacity];
// memcpy(_str, str, _size+1);
// }
//
// String(const String& s)
// :_str(NULL)
// {
// String tmp(s._str);
// //swap(_str, tmp._str);
// //this->Swap(tmp);
// Swap(tmp); //Swap(this, tmp);
// }
//
// // s1 = s2
// String& operator=(String s)
// {
// //swap(_str, s._str);
// Swap(s); //
// return *this;
// }
//
// // s1.Swap(s2)
// void Swap(String& s)
// {
// swap(this->_str, s._str);
// swap(this->_capacity, s._capacity);
// swap(this->_size, s._size);
// }
//
// void PushBack(char ch)
// {
// /* _CheckCapacity();
// _str[_size] = ch;
// ++_size;
// _str[_size] = '\0';*/
//
// Insert(_size, ch);
// }
//
// void PopBack()
// {
// assert(_size > 0);
// --_size;
// _str[_size] = '\0';
// }
//
// void Insert(size_t pos, char ch)
// {
// _CheckCapacity(_size+2);
//
// int end = _size;
// while (end >= (int)pos) // ?bug
// {
// _str[end+1] = _str[end];
// --end;
// }
//
// ++_size;
// _str[end+1] = ch;
// }
//
// // 删除pos位置这个数据
// void Erase(size_t pos)
// {
// assert(pos < _size);
//
// for (size_t i = pos+1; i <= _size; ++i)
// {
// _str[i-1] = _str[i];
// }
//
// --_size;
// }
//
// // 删除pos位置开始往后的n个数据
// void Erase(size_t pos, size_t n)
// {
// assert(pos < _size);
//
// if (pos+n >= _size)
// {
// _str[pos] = '\0';
// }
// else
// {
// for (size_t i = pos+n; i <= _size; ++i)
// {
// _str[pos++] = _str[i];
// }
// }
//
// _size -= n;
// }
//
// void Insert(size_t pos, const char* str)
// {
// size_t len = strlen(str);
// _CheckCapacity(_size+1+len);
//
// int end = _size; //?
// while (end >= (int)pos)
// {
// _str[end+len] = _str[end];
// --end;
// }
//
// char* dst = _str+pos;
// while (*str)
// *dst++ = *str++;
//
// _size += 3;
// }
//
// bool operator>(const String& s)
// {
// char* str1 = _str;
// char* str2 = s._str;
//
// // "01234"
// // 0 NULL '\0' '0' "0"
// while (*str1 && *str2)
// {
// if (*str1 > *str2)
// {
// return true;
// }
// else if (*str1 < *str2)
// {
// return false;
// }
// else
// {
// ++str1;
// ++str2;
// }
// }
//
// //"hello"
// //"hello world"
//
// if (*str2)
// {
// return false;
// }
// else
// {
// return true;
// }
//
// if (*str1)
// {
// return true;
// }
// else if(*str2)
// {
// return false;
// }
// else
// {
// return true;
// }
// }
//
// bool operator<(const String& s)
// {
// return !(*this > s || *this == s);
// }
//
// bool operator==(const String& s) const
// {
// if (_size == s._size)
// {
// for (size_t i = 0; i < _size; ++i)
// {
// if (_str[i] != s._str[i])
// {
// return false;
// }
// }
//
// return true;
// }
//
// return false;
// }
// bool operator>=(const String& s);
// bool operator<=(const String& s);
//
//
// char& operator[](size_t pos) //???
// {
// return _str[pos];
// }
//
// // s1 + s2
// String operator+(const String& s)
// {
// //String tmp(*this);
// String tmp(this->_str);
// tmp.Insert(tmp._size, s._str);
//
// return tmp;
// }
//
// // s1 + "sssss"
// String operator+(const char* str)
// {
// //String tmp(*this);
// String tmp(this->_str);
// tmp.Insert(tmp._size, str);
//
// return tmp;
// }
//
// String& operator+=(const String& s)
// {
// Insert(_size, s._str);
// return *this;
// }
//
// size_t Size()
// {
// return _size;
// }
//
// ~String()
// {
// delete[] _str;
// }
//
// char* GetStr()
// {
// return _str;
// }
//
//private:
// void _CheckCapacity(size_t needSize)
// {
// if (needSize > _capacity)
// {
// size_t newCapacity = _capacity*2;
// _str = (char*)realloc(_str, newCapacity);
// _capacity = newCapacity;
// assert(_str);
// }
// }
//
//private:
// char* _str;
// size_t _size; // 字符个数
// size_t _capacity; // 容量
//};
//
//
//
void TestString1()
{
char ptr1[] = "hello world";
char* ptr2 = "hello world";
String s1(ptr1);
String s2(s1);
String s3("hello");
s1 = s3;
s3.PushBack(' ');
s3.PushBack('o');
s3.PushBack('r');
s3.PushBack('l');
s3.PushBack('d');
s3.Insert(6, 'w');
cout<<s3.GetStr()<<endl;
String s4(" world");
s4.Insert(0, "hello");
cout<<s4.GetStr()<<endl;
s3[0] = 'x';
cout<<s3.GetStr()<<endl;
}
//
//struct AA
//{
// // 不允许进行隐式类型转换
// AA(int aa, int bb)
// :_aa(aa)
// {
// cout<<"AA()"<<endl;
// }
//
//private:
// int _aa;
//};
//
//void TestString2()
//{
// char ptr1[] = "hello world";
//
// String s1 = ("he world");
// s1.Insert(2, "llo");
// cout<<s1.GetStr()<<endl;
//
// s1.Erase(2, 3);
// cout<<s1.GetStr()<<endl;
//
// s1[0] = 'x';
// cout<<s1[3]<<endl;
// cout<<s1.GetStr()<<endl;
//
//
// String s2 = "hello";
// String s3 = " world";
//
// // 隐式转换
// int i = 1.1;
//
// String s5(s2 + s3);
// String s6 = s2 + s3;
// cout<<s5.GetStr()<<endl;
//
// String s7 = s2 + " world";
// cout<<s7.GetStr()<<endl;
//}
// 3.写时拷贝->效率、缺点:复杂,缺陷
//class String
//{
//public:
// String(const char* str)
// {
// size_t len = strlen(str);
// _str = new char[len+1];
// memcpy(_str, str, len+1);
//
// _refCount = new size_t(1);
// }
//
// String(const String& s)
// :_str(s._str)
// ,_refCount(s._refCount)
// {
// ++(*_refCount);
// }
//
// // s2 = s4
// String& operator=(const String& s)
// {
// if (this != &s)
// {
// this->Release();
//
// this->_str = s._str;
// this->_refCount = s._refCount;
// ++(*s._refCount);
// }
//
// return *this;
// }
//
// void Release()
// {
// if (--(*this->_refCount) == 0)
// {
// cout<<"delete"<<endl;
//
// delete _refCount;
// delete[] _str;
// }
// }
//
// ~String()
// {
// Release();
// }
//
// char* GetStr()
// {
// return _str;
// }
//
// char& operator[](size_t pos)
// {
// if(*_refCount > 1)
// {
// cout<<"COW"<<endl;
// String tmp(_str);
// Swap(tmp);
// }
//
// return _str[pos];
// }
//
// void Swap(String& tmp)
// {
// swap(_str, tmp._str);
// swap(_refCount, tmp._refCount);
// }
//
//private:
// char* _str;
// size_t* _refCount;
//};
//
//void TestString1()
//{
// String s1("hello");
// String s2(s1);
// String s3(s1);
// //cout<<s1.GetStr()<<endl;
// //cout<<s2.GetStr()<<endl;
// //cout<<s3.GetStr()<<endl;
//
// String s4("world");
// String s5(s4);
//
// //cout<<s4.GetStr()<<endl;
// //cout<<s5.GetStr()<<endl;
//
// s2 = s4;
//
// cout<<s2.GetStr()<<endl;
// cout<<s4.GetStr()<<endl;
//
// String s6("xxxxx");
// s6 = s4;
//}
//
写时拷贝 COW copy on write
//void TestString2()
//{
// String s1("hello");
// String s2(s1);
//
// //s1[0] = '1';
// //s2[0] = '2';
//
// cout<<s1[0]<<endl;
// cout<<s1.GetStr()<<endl;
// cout<<s2.GetStr()<<endl;
//}
class String
{
public:
String(const char* str = "")
{
size_t len = strlen(str);
len += 5;
_str = new char[len];
printf("new 0x%p\n", _str);
GetRefCount(_str) = 1;
_str += 4;
strcpy(_str, str);
}
String(const String& s)
:_str(s._str)
{
GetRefCount(_str-4)++;
}
size_t& GetRefCount(char* str)
{
return *((size_t*)str);
}
// s3 = s1 ==> s3.operator=(&s3, s1)
//String& operator=(const String& s)
//{
// if (this != &s)
// {
// Release();
// _str = s._str;
// GetRefCount(_str-4)++;
// }
// return *this;
//}
String& operator=(String s)
{
swap(_str, s._str);
return *this;
}
void Release()
{
if (--GetRefCount(_str-4) == 0)
{
printf("delete 0x%p\n", _str-4);
delete[] (_str-4);
}
}
~String()
{
Release();
}
// s1 + s2
String operator+(const String& s); //
// s1 += s2
String& operator+=(const String& s);
char& operator[](size_t index)
{
//assert(index < _size);
CopyOnWirte();
return _str[index];
}
/*void CopyOnWirte()
{
if (GetRefCount(_str-4) > 1)
{
size_t len = strlen(_str);
len += 5;
char* tmp = new char[len];
GetRefCount(tmp) = 1;
tmp += 4;
strcpy(tmp, _str);
GetRefCount(_str-4)--;
_str = tmp;
}
}*/
void CopyOnWirte()
{
if (GetRefCount(_str-4) > 1)
{
String tmp(_str);
swap(_str, tmp._str);
}
}
char* GetStr()
{
return _str;
}
private:
char* _str;
//size_t* _refCount;
};
void TestString1()
{
String s1("hello");
String s2(s1);
String s3("world");
//String s4(s3);
//s3 = s1;
//s1 += "sss";
s1[0] = 'x';
s3[0] = 'x';
cout<<s1.GetStr()<<endl;
cout<<s2.GetStr()<<endl;
cout<<s3.GetStr()<<endl;
//cout<<s4.GetStr()<<endl;
}
浅拷贝
class String
{
public:
String(const char* pStr = "")
{
_pStr = new char[my_strlen(pStr) + 1];
my_strcpy(_pStr, pStr);
}
String(const String& s)
{
_pStr = s._pStr;
}
String& operator=(const String& s)
{
if (this != &s)
{
_pStr = s._pStr;
}
return *this;
}
~String()
{
delete[] _pStr;
_pStr = NULL;
}
protected:
int my_strlen(const char* str)
{
int count = 0;
assert(str);
while (*str)
{
str++;
count++;
}
return count;
}
char* my_strcpy(char* dst, const char* src)
{
char* ret = dst;
assert(dst);
assert(src);
while (*dst++ = *src++)
{
;
}
return ret;
}
private:
char* _pStr;
};
深拷贝:
//深拷贝普通版
class String
{
public:
String(const char* pStr = "")
{
if (NULL == pStr)
{
_pStr = new char[1];
*_pStr = '\0';
}
_pStr = new char[my_strlen(pStr) + 1];
my_strcpy(_pStr, pStr);
}
String(const String& s)
{
_pStr = new char[strlen(s._pStr) + 1];
strcpy(_pStr, s._pStr);
}
String& operator=(const String& s)
{
if (this != &s)
{
char *pTemp = new char[strlen(s._pStr) + 1];
strcpy(pTemp, s._pStr);
delete[]_pStr;
_pStr = pTemp;
}
return *this;
}
~String()
{
delete[] _pStr;
_pStr = NULL;
}
protected:
int my_strlen(const char* str)
{
int count = 0;
assert(str);
while (*str)
{
str++;
count++;
}
return count;
}
char* my_strcpy(char* dst, const char* src)
{
char* ret = dst;
assert(dst);
assert(src);
while (*dst++ = *src++)
{
;
}
return ret;
}
private:
char* _pStr;
};
//深拷贝简洁版
/*
class String
{
public:
String(const char* pStr = "")
{
if (NULL == pStr)
{
_pStr = new char[1];
*_pStr = '\0';
}
_pStr = new char[my_strlen(pStr) + 1];
my_strcpy(_pStr, pStr);
}
String(const String& s)
:_pStr(NULL)
{
String tmp(s._pStr);
std::swap(_pStr, tmp._pStr);
}
String& operator=(const String& s)
{
if (this != &s)
{
String tmp(s);
std::swap(tmp._pStr, _pStr);
}
return *this;
}
~String()
{
if (_pStr)
{
delete[] _pStr;
_pStr = NULL;
}
}
protected:
int my_strlen(const char* str)
{
int count = 0;
assert(str);
while (*str)
{
str++;
count++;
}
return count;
}
char* my_strcpy(char* dst, const char* src)
{
char* ret = dst;
assert(dst);
assert(src);
while (*dst++ = *src++)
{
;
}
return ret;
}
private:
char* _pStr;
};
*/
注:深拷贝普通版:
拷贝构造:开辟新空间,进行内容的拷贝使其各自有各自的空间以至于在析构的时候各自有各自空间。
赋值运算符重载:开辟新空间,释放原空间,拷贝内容。
深拷贝简洁版:
引入交换。