C++仿写String部分基础功能

C语言的字符串是以’\0‘结尾的字符集合

C++定义标准库string类，string封装用于单字字节字符和字符串的类型。

string常见的成员方法

构造函数：string s(int  n,char c);创建一个字符串s并初始化n个c字符

遍历访问：可以通过s[i]或at(i)访问string类内元素，区别：at访问会检查越界问题

容量大小操作：

s.capacity():返回s字符串容量。无参数

s.size():返回当前字符串大小。无参数

s.length():返回当前字符串长度。无参数，（s.length()与s.size()一样）

s.resize(int len,int c):重置当前字符串的大小为len，不足的部分用字符c填充

赋值操作：

“=”直接赋值

s.assign(const char* c)：直接赋值一个字符串常量

s.assign(const char* c,star,end)：将字符串c从star到end部分字符串赋给s

字符串拼接

“+”号直接拼接

s.append(const char* c)把字符串c拼接到s

字符串比较

“>”、“<”、“==”、“!=”、按照ASCII码

替换

s[i]=a;

s.replace(1,10,const char* c)替换s的1到10位，用c替换

插入

s.insert(int pos,int const char* c) 、pos位，不包括pos之前插入c

删除

s.erase(i,n); 删除i位置开始的n个字符（包括i）

s.clear();情空字符串，大小也清零，字符串对象还在。

子串

s.substr(pos,n);返回pos开始的n个字符，包括pos

字符串交换

s.swap(c)

一般来说string相当于一个保存字符的序列容器，除了有字符串的一些常用操作以外，还包含了所有序列容器的操作。字符串常用操作包括：增、删、改、查、比较、链接、输入、输出等。

string成员类型：

 string成员函数：

string元素访问：char*、const char*访问

#include<string>
#include<iostream>
using namespace std;
int main()
{
	string s1 = "hello adc";
	char* str1 = (char*)s1.data();	
	const char* str2 = s1.data();
	const char* cstr = s1.c_str();
	*str1 = 'x';
	cout << s1 << endl;
	cout << str1 << endl;
	cout << str2 << endl;
	return 0;
}

 string的构造方法和拷贝构造

#include<iostream>
#include<stdio.h>
using namespace std;

int main()
{
	string s1;                        //默认构造空string
	string s2(10, 'a');               //构造10个‘a’
	string s3("s3_hello");            //
	string s4("s4_hello", 5);         //以"s4_hello"字符串的前5个字符构造s4
	string s5("s5_hello", 3, 5);      //以"s5_hello"字符串的3位置开始前5个字符串构造s5
	string s6(s3);                    //拷贝构造
	string s7(s3, 3);                 //拷贝构造函数从3位置开始构造s7
	string s8(s3, 3, 5);              //拷贝构造函数从3位置开始5个字符构造s8
	string s9 = "hello string";       
	cout << s1 << endl;
	cout << s2 << endl;
	cout << s3 << endl;
	cout << s4 << endl;
	cout << s5 << endl;
	cout << s6 << endl;
	cout << s7 << endl;
	cout << s8 << endl;
	cout << s9 << endl;
	return 0;
}

仿写增、删、改、查

mstring.h

#ifndef MSTRING_H
#define MSTRING_H
#include<iostream>
using namespace std;

#define DEFEALT_LEN 10


class Mstring
{
public:
	Mstring(const char* str = NULL);//构造函数
	Mstring(const Mstring& src);//拷贝构造
	Mstring& operator=(const Mstring& src);//赋值
	~Mstring();//析构函数

	void push_back(char c);//尾插
	void pop_back();//尾删
	char back()const;    //返回最后
	char front()const;    //返回开始
	bool empty()const;    //判空
	int size()const;    //大小

	Mstring operator+(const Mstring& str)const;
	char& operator[](int pos); 
	char operator[](int pos)const;

	friend ostream& operator<<(ostream& out, const Mstring& src);
	friend istream& operator>>(istream& in, Mstring& src);
private:
	bool full()const;//判满
	void revert();//还原
    
	char* _str;
	int _len;        //当前空间总长度
	int _val_len;    //已经占用的长度，试即数据数量
};

#endif#pragma once

 mstring.cpp

#include"mstring.h"
using namespace std;

Mstring::Mstring(const char* str)
{
	if (NULL == str)
	{
		_len = 0;
		_val_len = 0;
		_str = new char[_len];
		memset(_str, 0, _len);
	}
	_val_len = strlen(str);
	_len = _val_len + 1;
	_str = new char[_len];
	memset(_str, 0, _len);
	for (int i = 0; i < _val_len; ++i)
	{
		_str[i] = str[i];
	}
}

Mstring::Mstring(const Mstring& src) 
{
	_val_len = strlen(src._str);
	_len = _val_len + 1;
	_len = _val_len + 1;
	_str = new char[_len];
	memset(_str, 0, _len);
	for (int i = 0; i < _val_len; ++i)
	{
		_str[i] = src[i];
	}
}
Mstring& Mstring:: operator=(const Mstring& src)
{
	if (&src == this)
	{
		return *this;
	}
	delete[] _str;
	_val_len = src._val_len;
	_len = src._len;
	_str = new char[_len];
	memset(_str, 0, _len);
	for (int i = 0; i < _val_len; i++)
	{
		_str[i] = src._str[i];
	}
	return *this;
}
Mstring::~Mstring()//析构
{
	delete[]_str;
}
void Mstring::push_back(char c)//尾插
{
	if (full())
	{
		revert();
	}
	_str[_val_len] = c;
	_val_len++;
}
void Mstring::pop_back()//尾删
{
	if (empty())
	{
		return;
	}
	_val_len--;
}
char Mstring::back()const
{
	if (empty())
	{
		return 0;
	}
	return _str[_val_len];
}
char Mstring::front()const
{
	if (empty())
	{
		return 0;
	}
	return _str[0];
}
bool Mstring::empty()const
{
	return _val_len == 0;
}


int Mstring::size()const
{
	return _val_len;
}

Mstring Mstring::operator+(const Mstring& str)const
{
	char* p;
	int len = _val_len + str._val_len + 1;
	p = new char[len];
	memset(p, 0, len);
	int i = 0;
	for (; i < _val_len; ++i)
	{
		p[i] = _str[i];
	}
	for (int j = 0; j < str._val_len; ++j,++i)
	{
		p[i] = str._str[j];
	}
	return p;
}
char& Mstring::operator[](int pos)
{
	return _str[pos];
}
char Mstring::operator[](int pos)const
{
	return _str[pos];
}

bool Mstring::full()const
{
	return _val_len == _len - 1;
}

void Mstring::revert()
{
	_len = _len << 1;

	char* p = new char[_len];
	memset(p, 0, _len);

	for (int i = 0; i < _val_len; i++)
	{
		p[i] = _str[i];
	}

	delete[]_str;
	_str = p;
}


ostream& operator<<(ostream& out, const Mstring& src)
{
	for (int i = 0; i < src._len; ++i)
	{
		out << src[i];
	}
	out << endl;
	return out;
}
istream& operator>>(istream& in, Mstring& src)
{
	char tmp[256];
	in >> tmp;
	src = tmp;
	return in;
}
int main()
{
	Mstring s1="a";
	Mstring s2="bcd";
	Mstring s3 = s1 + s2;
	
	cout << s1 << endl;
	cout << s2 << endl;
	cout << s3 << endl;
	return 0;
}