#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<assert.h>
#include<stdlib.h>
#include<string.h>
using namespace std;
class String{
private:
size_t _size;
size_t _capacity;
char* _data;
static const size_t npos;
public:
typedef char* iterator;
typedef const char* const_iterator;
iterator begin(){
return _data;
}
const_iterator begin() const{
return _data;
}
iterator end(){
return _data + _size;
}
const_iterator end ()const{
//无法仅按返回值作为函数重载,const可以
return _data + _size;
}
String(const char* str = '\0')
:_size(strlen(str))
, _capacity(_size)
, _data(new char[strlen(str)+1])
{
strcpy(_data, str);
}
void Swap(String& str){
swap(_data, str._data);
swap(_size, str._size);
swap(_capacity, str._capacity);
}
String(const String& str)
:_size(0)
,_capacity(0)
, _data(nullptr)
{
String tmp(str._data);
Swap(tmp);
}
~String(){
if (_data){
delete[] _data;
}
_data = nullptr;
_capacity = _size = 0;
}
bool String::operator==(const String& str){
if (_data == str._data&&_size == str._size&&_capacity == str._capacity)
return true;
return false;
}
String& String::operator=(const String& str){
//形参也不能是const
if (*this == str){
return *this;
}
String tmp(str);
Swap(tmp);
return *this;
}
char& String::operator[](size_t a){
assert(a > _size);
return _data[a];
}
const char& String::operator[](size_t a)const{
assert(a > _size);
return _data[a];
}
void reserse(size_t ch){
if (_capacity < ch){
char* newp = new char[ch+1];//这里有个+1没写 ch表示有效字符的最大个数不包括\0
//拷贝
strcpy(newp, _data);
delete[] _data;
_data = newp;
_capacity = ch;
}
}
void resize(size_t ch, const char& a = '\0'){
if (_capacity < ch)
reserse(ch);
if (_size < ch)
memset(_data + _size, a, sizeof(char)*(ch - _size));
_size = ch;
//忘记\0
_data[_size] = '\0';
}
void pushback(const char&a = '\0'){
if (_size == _capacity){
//三目运算符顺序
size_t newcapacity=_capacity == 0 ? 15 : 2 * _capacity;
reserse(newcapacity);
}
_data[_size++] = a;
_data[_size] = '\0';
}
void append(const char* str){
if (_capacity < (strlen(str) + _size)){
reserse(strlen(str) + _size);
}
memcpy(_data + _size, str,sizeof(char)*strlen(str));
//忘记更新size
_size += strlen(str);
_data[_size] = '\0';
}
String& String::operator+=(const String& str){
append(str._data);
return *this;
}
String& String::operator+=(const char* str){
append(str);
return *this;
}
String& String::operator+=(const char& str){
pushback(str);
return *this;
}
void insert(size_t pos, const char& ch){
assert(pos <= _size);//可以等于,忘写了
if (_size == _capacity){
size_t newc = _capacity == 0 ? 1 : 2 * _capacity;
reserse(newc);
}
/*size_t idx = _size;
while (idx>pos-1){
_data[idx+1] = _data[idx];
--idx;
}*/
size_t idx = _size + 1;
while (idx>pos){
_data[idx] = _data[idx - 1];
idx--;
}
_data[pos] = ch;
++_size;
}
void insert(size_t pos, const char* ch){
assert(pos <= _size);
size_t len = strlen(ch);
if (len + _size > _capacity){
reserse(len + _size);
}
size_t idx = _size + len;
while (idx>pos-1){
_data[idx] = _data[idx-len];//不能写size
idx--;
}
memcpy(_data + pos, ch, sizeof(char)*len);//不能strcpy-->\0
_size += len;
}
void earse(size_t pos, size_t len = npos){
assert(pos<=_size);
if (pos+len>=_size||len==npos){
_size = pos;
_data[_size] = '\0';
}
else{
size_t idx = pos + len;
while (idx <= _size){
_data[idx - len] = _data[idx];
++idx;
}
_size -= len;
}
}
size_t find(const char* ch, size_t pos = 0){
assert(pos < _size);
char* strpos = strstr(_data + pos, ch);
if (strpos){
return strpos - _data;
}
return npos;
}
String substr(size_t pos, size_t len = npos){
//创建子串
assert(pos < _size);
if (pos + len >= _size || len == npos){
return String(_data + pos);//pos是一个数字,指针加数字是指针
}
else{
char* newc = new char[len + 1];
memcpy(newc, _data + pos, sizeof(char)*len);
newc[len] = '\0';
delete[] newc;
return String(newc);
}
}
size_t size()const{
return _size;
}
size_t capacity()const{
return _capacity;
}
const char* cstr() const{
return _data;
}
};
const size_t String::npos = -1;
String operator+(const String& a, const String& b){
//不能加string::
String str(a); //拷贝构造需要const,否则报错
//因为const可以接受const和非const,非const只能接受const
str += b;
return str;
}
String operator+(const String& a, const char* b){
String str(a);
str += b;
return str;
}
String operator+(const String& a, const char& b){
String str(a);
str += b;
return str;
}
bool operator<(const String& str1, const String& str2){
int a = strcmp(str1.cstr(), str2.cstr());//1>2--大于0 否则小于0
if (a<0){
return true;
}
return false;
}
bool operator==(const String& str1, const String& str2){
int a = strcmp(str1.cstr(), str2.cstr());
if (a==0){
return true;
}
return false;
}
bool operator!=(const String& str1, const String& str2){
return !(operator== (str1, str2));
}
ostream& operator<<(ostream& out ,String& str){
for (const auto ch : str){
cout << ch;
}
return out;
}
//相比于输出流简单地输出,输入流相当于尾插string
istream& operator>>(istream& in, String& str){
char ch;
while ((ch = cin.get()) != EOF){
if (ch == ' ' || ch == '\0')
break;
str += ch;
}
return cin;
}
void printffor(const String& str){
//形参也不能是const
//形参const走的就是const的迭代器
for (const char& a : str){
//const_it
cout << a;
}
cout << endl;
}
void printffor2(const String& str){
String::const_iterator it = str.begin();
while (it != str.end()){
cout << *it << " ";
++it;
}
cout << endl;
}
//void test(){
// String str1 = "hello";
// String str2 = "nihao";
// String str3 = "nihao";
// bool a, b;
// a = (str1 == str2);
// b = (str3 == str2);
// cout << a << endl;
// cout << b << endl;
//}
int main(){
//test();
system("pause");
return 0;
}
【C++】模拟实现string类
猜你喜欢
转载自blog.csdn.net/zhaocx111222333/article/details/115232393
今日推荐
周排行