一般来说，为了防止与标准库中的string冲突，我们都会开一个命名空间。
构造函数，如果用最基本的构造函数，会怎么样
class string
{
public:
string()
:_str(nullptr)
{}
string(char* s)
:_str(s)
{
}
这样子初始化的常量字符串，不能被修改，被存放再代码段，且扩容也不好处理。因此构造时候，不能直接传，要用new来动态开辟空间储存，因此其实string的底层是数组。
string(const char* s = "")
:_str(new char[strlen(s) + 1])
{
strcpy(_str, s);
}
而析构则使用相对应的函数
~string()
{
delete[] _str;
_str = nullptr;
}
当无参数时候，是空字符串，这样strlen就会为0，不然如果是空指针，则会出现空指针的解引用。
拷贝构造：
因为底层是一个字符指针，所以指针的拷贝，不能用浅拷贝，需用深拷贝。
string(const string& s)
:_str(new char [strlen(s._str)+1])
{
strcpy(_str,s._str);
}
这里便是深拷贝的写法，这里，主要利用的是，在类域中，可以直接访问对象的私有变量，即拷贝构造函数中，可以直接访问另一个引用同类对象的私有成员。
同样的operator=也需要深拷贝。
string& operator=(const string& s)
{
if (&s != this)
{
char* tmp = new char[strlen(s._str) + 1];
strcpy(tmp, s._str);
delete[] _str;
_str = tmp;
}
return *this;
}
而深拷贝也具有现代写法，是先构造一个相同对象，然后交换，宛如狸猫换太子。
string(const string& s)
:_str(nullptr)
{
string tmp(s._str);
swap(_str,_tmp._str);
}
string& operator=(string s)
{
swap(_str,s._str);
return *this;
}
赋值的现代写法，巧妙利用拷贝构造，直接换指针，这样不会影响原来的对象，因为那是形参。
当然这只是简单的string，只是实现了，基础的默认成员函数。
namespace whc
{
class string
{
public:
typedef char* iterator;
iterator begin()
{
return _str;
}
iterator end()
{
return _str + _size;
}
string(const char* s = "")
:_str(new char[strlen(s) + 1])//因为有\0占一个位置
,_size(strlen(s))
,_capacity(strlen(s))
{
strcpy(_str, s);
}
~string()
{
_size = _capacity = 0;
delete[] _str;
_str = nullptr;
}
string(const string& s)
:_str(new char[strlen(s._str)+1])
,_size(s._size)
,_capacity(s._capacity)
{
strcpy(_str, s._str);
}
string& operator=(const string& s)
{
_size = s._size;
_capacity = s._capacity;
if (&s != this)
{
char* tmp = new char[s._capacity + 1];
strcpy(tmp, s._str);
delete[] _str;
_str = tmp;
}
return *this;
}
size_t size() const
{
return _size;
}
size_t capacity() const
{
return _capacity;
}
char operator[](size_t i) const
{
assert(i < _size);
return _str[i];
}
const char* c_str() const
{
return _str;
}
void reserve(size_t n)
{
if (n > _capacity)
{
char* newcapa = new char[n + 1];
strcpy(newcapa, _str);
delete[] _str;
_str = newcapa;
_capacity = n;
}
}
void rsize(size_t n, char ch = '\0')
{
if (n < _size)
{
_str[n] = '\0';
_size = n;
}
else
{
if (n > _capacity)
{
reserve(n);
}
for (size_t i = _size; i < n; i++)
{
_str[i] = ch;
}
_size = n;
_str[_size] = '\0';
}
}
//这里也可以和insert复用
void push_back(const char ch)
{
if (_size == _capacity)
{
size_t newcapacity = _capacity == 0 ? 2 : _capacity * 2;
reserve(newcapacity);
}
_str[_size] = ch;
_size++;
_str[_size] = '\0';
}
//这里也可以和insert复用
void append(const char* s)
{
size_t len = strlen(s);
if (_size + len > _capacity)
{
reserve(_size + len);
}
strcpy(_str + _size, s);
_size += len;
}
void append(const string& s)
{
size_t len = s.size();
if (_size + len > _capacity)
{
reserve(_size + len);
}
strcpy(_str + _size, s._str);
_size += len;
}
string& operator+=(const char ch)
{
push_back(ch);
return *this;
}
string& operator+=(const char* s)
{
append(s);
return *this;
}
string& operator+=(const string& s)
{
append(s);
return *this;
}
string& insert(size_t pos, char ch)
{
assert(pos < _size);
if (_size == _capacity)
{
size_t newcapa = _capacity == 0 ? 2 : _capacity * 2;
reserve(newcapa);
}
int end = _size;
while (end >= (int)pos)
{
_str[end + 1] = _str[end];
end--;
}
_str[pos] = ch;
_size++;
return *this;
}
string& insert(size_t pos, const char* s)
{
assert(pos < _size);
size_t len = strlen(s);
if (_size + len > _capacity)
{
reserve(_size + len);
}
int end = _size;
while (end >=(int)pos)//如果int小于0则与无符号比较会变成无符号。
{
_str[end + len] = _str[end];
end--;
}
//第一种方式
/*for (size_t i = 0; i < len; i++)
{
_str[pos++] = s[i];
}*/
//第二种方式
strncpy(_str + pos, s, len);
_size += len;
return *this;
}
string& erase(size_t pos, size_t len = npos)
{
assert(pos < _size);
if (len >= _size - pos)
{
_str[pos] = '\0';
_size = pos;
}
else
{
size_t i = pos + len;
while (i <= _size)
{
_str[pos++] = _str[i++];
}
_size -= len;
}
return *this;
}
size_t find(char ch , size_t pos = 0)
{
for (size_t i = pos; i < _size; i++)
{
if (_str[i] == ch)
{
return i;
}
}
return npos;
}
size_t find(const char* s, size_t pos = 0)
{
char* p = strstr(_str, s);
if (p == nullptr)
{
return npos;
}
return p - _str;
}
bool operator==(const string& s)
{
if (strcmp(_str, s._str) == 0)
{
return true;
}
return false;
}
bool operator<(const string& s)
{
if (strcmp(_str, s._str) < 0)
return true;
return false;
}
bool operator<=(const string& s)
{
return *this < s || *this == s;
}
bool operator>(const string& s)
{
return !(*this <= s);
}
bool operator>=(const string& s)
{
return !(*this < s);
}
bool operator!=(const string& s)
{
return !(*this == s);
}
private:
char* _str;
size_t _size;
size_t _capacity;
static size_t npos;
};
size_t string:: npos = -1;
ostream& operator<<(ostream& out, string& s)
{
for (size_t i = 0; i < s.size(); i++)
{
out << s[i];
}
return out;
}
istream& operator>>(istream& in, string& s)
{
while (1)
{
char ch;
ch = in.get();
if (ch == ' ' || ch == '\n')
{
break;
}
else
{
s += ch;
}
}
return in;
}
void test()
{
string s("hello");
string s1;
string s2(s);
string s3 = s;
string s4("world");
cin >> s1;
cout << s1 << endl;
}
}
以上则是相对完整的string实现，这里我们也可以进一步理解迭代器，string的迭代器是一个指针，利用指针进行遍历，而范围for则是依赖迭代器而形成的。
这里还有深拷贝现代写法的完整形式。
string(const string& s)
:_str(nullptr)
,_size(0)
,_capacity(0)
{
string tmp(s._str);
swap(tmp);
}
string& operator=(string s)
{
swap(s);
return *this;
}
void swap(string& s)
{
::swap(_str,s._str);
::swap(_size,s._size);
::swap(_capacity,s._capacity);
}
因为swap函数其作用域中，所以加域作用符来表明引用的是全局域的swap函数。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
