//.h
#include
#include
using namespace std;
namespace myString
{
class string
{
public:
//iterator
typedef char* iterator;
iterator begin();
iterator end();
//默认构造
string(const char* str = "");
//拷贝构造
string(const string& s);
void swap(string& s1);
//赋值运算符重载
//string& operator=(const string& s);
string& operator=(myString::string s);
//析构函数
~string();
//[]重载
char& operator[](size_t pos);
//
void reserve(size_t n);
void resize(size_t n,char ch = '\0');
size_t size();
size_t capacity();
//插入
void push_back(const char ch);
void insert(size_t pos,const char ch);
void insert(size_t pos,const char* str);
void append(const char* str);
void operator+=(const char ch);
void operator+=(const char* str);
//查找
size_t find(char ch, size_t pos = 0);
size_t find(char* str, size_t pos = 0);
//转换成c字符串
const char* c_str() const;
private:
char* _str;
size_t _size;
size_t _capacity;
public:
const static size_t npos;
};
ostream& operator<<(ostream& _cout,myString::string s);
istream& operator>>(istream& _cin, myString::string s);
bool operator>(myString::string& s1, myString::string& s2);
bool operator==(myString::string& s1, myString::string& s2);
bool operator>=(myString::string& s1, myString::string& s2);
bool operator<=(myString::string& s1, myString::string& s2);
bool operator!=(myString::string& s1, myString::string& s2);
};
//string.cpp
#include"string.h"
const size_t myString::string::npos = -1;
//默认构造函数
myString::string::string(const char* str)
{
//不能使用nullptr床架对象
assert(str != nullptr);
_str = new char[strlen(str) + 1];
_size = _capacity = strlen(str);
strcpy(_str,str);
}
//拷贝构造函数-现代写法
//myString::string::string(const string& s)
//:_str(nullptr)
//, _size(0)
//, _capacity(0)
//{
// string tmp(s._str);
// swap(tmp);
//}
//拷贝构造-传统写法
myString::string::string(const string& s)
{
_str = new char[strlen(s._str) + 1];
strcpy(_str,s._str);
_size = _capacity = strlen(s._str);
}
//析构函数
myString::string::~string()
{
delete[] _str;
_size = _capacity = 0;
_str = nullptr;
}
//赋值运算符重载-传统写法
//myString::string& myString::string::operator=(const string& s)
//{
// if (this != &s)
// {
// //开辟新空间
// char* tmp = new char[strlen(s._str) + 1];
// strcpy(tmp, s._str);
// _size = _capacity = s._size;
// //释放原空间
// delete[] _str;
// _str = tmp;
// }
// return *this;
//}
//赋值运算符重载-现代写法
myString::string& myString::string::operator=(myString::string s)
{
swap(s);
return *this;
}
//[]重载
char& myString::string::operator[](size_t pos)
{
assert(pos < _size);
return _str[pos];
}
//交换两个字符串对象
void myString::string::swap(string& s1)
{
std::swap(_str, s1._str);
std::swap(_size,s1._size);
std::swap(_capacity,s1._capacity);
}
void myString::string::reserve(size_t n)
{
if (n > _capacity)
{
char* tmp = new char[n+1];
strcpy(tmp,_str);
delete[] _str;
_str = tmp;
_capacity = n;
}
}
void myString::string::resize(size_t n, char ch)
{
if (n < _size)
{
_str[_size] = '\0';
_size = n;
}
else
{
if (n > _capacity)
{
reserve(n);
}
//后边补ch
for (size_t i = _size; i < n; i++)
_str[i] = ch;
//加'\0'
_str[n] = '\0';
_size = n;
}
}
size_t myString::string::size()
{
return _size;
}
size_t myString::string::capacity()
{
return _capacity;
}
myString::string::iterator myString::string::begin()
{
return _str;
}
myString::string::iterator myString::string::end()
{
return _str + _size;
}
void myString::string::insert(size_t pos,const char ch)
{
//检查插入位置是否正确
assert(pos <= _size);
//判断是否需要扩容
if (_capacity == 0)
reserve(10);
else if (_capacity == _size)
reserve(2*_capacity);
//将size及其之后的字符后移
for (size_t i = _size; i >= pos; i--)
{
_str[i+1] = _str[i];
}
//pos位置插入字符
_str[pos] = ch;
_size++;
}
void myString::string::insert(size_t pos, const char* str)
{
int len = strlen(str);
//检查插入位置是否正确
assert(pos <= _size);
//判断是否需要扩容
if (_capacity == 0)
reserve(len);
else if (_capacity == _size)
reserve(_size+len);
//移动size之后的字符
for (size_t i = _size; i >= pos; i--)
{
_str[i+len] = _str[i];
}
//插入字符串
strncpy(_str+pos,str,len);
_size += len;
}
void myString::string::push_back(const char ch)
{
insert(_size,ch);
}
void myString::string::append(const char* str)
{
insert(_size,str);
}
void myString::string::operator+=(const char ch)
{
push_back(ch);
}
void myString::string::operator+=(const char* str)
{
append(str);
}
size_t myString::string::find(char ch, size_t pos)
{
assert(pos < _size);
for (size_t i = 0; i < _size; i++)
{
if (_str[i] == ch)
return i;
}
return npos;
}
size_t myString::string::find(char* str, size_t pos)
{
const char* ret = strstr(_str + pos, str);
if (ret == nullptr)
{
return npos;
}
else
{
return ret - _str;
}
}
const char* myString::string::c_str() const
{
return _str;
}
ostream& myString::operator<<(ostream& _cout,myString::string s)
{
for (size_t i = 0; i < s.size(); i++)
{
_cout << s[i];
}
_cout << endl;
return _cout;
}
istream& myString::operator>>(istream& _cin, myString::string s)
{
s.resize(0);
char ch;
while (1)
{
//in>>ch;
_cin.get(ch);
if (ch == ' ' || ch == '\n')
{
break;
}
else
{
s += ch;
}
}
return _cin;
}
bool myString::operator>(myString::string& s1, myString::string& s2)
{
size_t i1 = 0, i2 = 0;
while (i1 < s1.size() && i2 < s2.size())
{
if (s1[i1] > s2[i2])
{
return true;
}
else if (s1[i1] < s2[i2])
{
return false;
}
else
{
++i1;
++i2;
}
}
if (i1 < s1.size())
{
return true;
}
else if (i2 < s2.size())
{
return false;
}
else
{
return false;
}
}
bool myString::operator==(myString::string& s1, myString::string& s2)
{
size_t i1 = 0, i2 = 0;
while (i1 < s1.size() && i2 < s2.size())
{
if (s1[i1] > s2[i2])
{
return false;
}
else if (s1[i1] < s2[i2])
{
return false;
}
else
{
++i1;
++i2;
}
}
if (i1 == s1.size() && i2 == s2.size())
{
return true;
}
else
{
return false;
}
}
bool myString::operator>=(myString::string& s1, myString::string& s2)
{
if (s1 > s2 || s1 == s2)
return true;
return false;
}
bool myString::operator<=(myString::string& s1, myString::string& s2)
{
if (s1 > s2)
return false;
return true;
}
bool myString::operator!=(myString::string& s1, myString::string& s2)
{
if (s1 == s2)
return false;
return true;
}
//test.cpp
#include"string.h"
int main()
{
//测试默认构造函数
myString::string s1;
//myString::string s2 = NULL;
myString::string s3 = "hello world";
//测试拷贝构造
myString::string s4(s3);
//赋值运算符重载
myString::string s5("hello");
s5 = s4;
//[]重载
cout << s5[6] << endl;
//reserve和resize
//reserve在插入的时候会调用
myString::string s6;
s6.resize(5,'x');
//size和capacity
cout << s6.size() << " " << s6.capacity() << endl;//均为5
//iterator
myString::string::iterator it = s6.begin();
while (it < s6.end())
{
cout << *it << " ";
it++;
}
cout << endl;
//插入
myString::string s7("helloworld");
s7.insert(5,' ');
s7.push_back('!');
myString::string s8("12345678");
s8.insert(2,"hello");
s8.append("world!");
//输出
cout << s8;
cout << (s7 == s8) << endl;
myString::string s10 = "hello";
myString::string s11 = "aellobbb";
cout << (s10 > s11) << endl;
return 0;
}