40.字符类的创建(下)

一.字符串类的常见函数

1.1 重载数组访问操作符

char& operator[](int i) const;
char operator[](int i);

要注意i的范围在合理范围内

i > = 0 && i <= m_length

1.2 判断是否以指定字符串开始/结束

bool startWith(const char* s)const;
bool startWith(const String& s)const;
bool endWith(const char* s)const;
bool endWith(const String& s)const;

1.3 在指定的位置插入字符串

String& insert(int i,const char* s)
String& insert(int i,const String& s)

先申请一段内存，申请的内存长度为s与原来对象中m_str的长度值，

2.代码实现

String.h

#pragma once
#include <iostream>
using namespace std;


class String
{
protected:
	int  m_length;//字符串的长度
	char* m_str;
	void init(const char* s);
public:
	String();
	~String();
	String(char c);
	String(const char* str);
	String(const String& s);//赋值拷贝
	int length();//字符串长度
	const char* c_str() const;//字符串转换函数

	char& operator[](int i);
	char operator[](int i) const;

	bool equal(const char* l, const char* r, int len)const;
	bool startWith(const char* s)const;
	bool startWith(const String& s)const;
	bool endWith(const char* s)const;
	bool endWith(const String& s)const;


	String& insert(int i, const char* s);
	String& insert(int i, const String& s);
	//比较操作符函数重载
	bool operator == (const String& s)const;
	bool operator == (const char* s)const;
	bool operator != (const String& s)const;
	bool operator != (const char* s)const;

	bool operator > (const String& s)const;
	bool operator > (const char* s)const;
	bool operator < (const String& s)const;
	bool operator < (const char* s)const;

	bool operator >= (const String& s)const;
	bool operator >= (const char* s)const;
	bool operator <= (const String& s)const;
	bool operator <= (const char* s)const;

	//加法操作符重载
	String operator + (const String& s)const;
	String operator + (const char* s)const;
	String operator += (const String& s);
	String operator += (const char* s);

	//赋值操作符重载
	String& operator = (const String& s);
	String& operator = (const char* s);
	String& operator = (const char c);

};

String.cpp

#define  _CRT_SECURE_NO_WARNINGS

#include "String.h"
#include <iostream>
#include <cstring>
#include <cstdio>

void String::init(const char* s)
{
	m_str = _strdup(s);

	if (m_str)
	{
		m_length = strlen(m_str);
	}
	else
	{
		cout << "init failed\n" << endl;
	}
}

String::String()
{
	init("");//传入一个空字符串
}

String::String(char c)
{
	char s[] = { c,'\0' };//传入字符数组
	init(s);
}

String::String(const char* str)
{
	init(str?str:"");//这里判断一下是为了防止传入空指针
}

String::String(const String& s)//赋值拷贝
{
	init(s.m_str);
}

int String::length()
{
	return m_length;
}

const char* String::c_str()const
{
	return m_str;
}

char& String:: operator[](int i)
{
	if ((i >= 0) && (i <= m_length))
	{
		return m_str[i];
	}
	else
	{
		cout << "pos is invaild" << endl;
	}
}

char String:: operator[](int i)const
{
	return (const_cast<String&>(*this))[i];//
}

bool  String::equal(const char* l,const char* r,int len) const
{
	bool ret = true;

	for (int i = 0; i < len && ret; i++)
	{
		ret = (l[i] == r[i]);
	}

	return ret;
}

bool String::startWith(const char* s)const
{
	bool ret = (s != NULL);

	if (ret)
	{
		return ((strlen(s) < m_length) && equal(s, m_str, strlen(s)));
	}
	
	return ret;
}
bool String::startWith(const String& s)const
{
	return startWith(s.m_str);
}
bool String::endWith(const char* s)const
{
	bool ret = (s != NULL);

	if (ret)
	{
		int len = strlen(s);

		if (len < m_length)
		{
			char* str = m_str + m_length - len;
			return equal(s, str, strlen(s));
		}
		else
		{
			return  false;
		}
	}

return ret;

}

bool String::endWith(const String& s)const
{
	return endWith(s.m_str);
}

String& String::insert(int i, const char* s)
{	
	if (s != NULL || s[0] != '\0')
	{
		if (i >= 0 && i <= m_length)
		{
			int len = strlen(s);
			char* str = reinterpret_cast<char*>(malloc(len + m_length + 1));

			strncpy(str, m_str, i);
			strncpy(str + i, s, len);
			strncpy(str + i + len, m_str + i,m_length- i);

			str[m_length + len] = '\0';

			free(m_str);
			m_str = str;
			m_length = m_length + len;
		}
		else
		{
			cout << "invaild pos" << endl;
		}
	} 
	else
	{
		cout << "s is null or empty" << endl;
	}

	return *this;
}

String& String::insert(int i, const String& s)
{
	return (*this).insert(i, s.m_str);
}

bool String :: operator ==  (const String& s) const
{
	return (strcmp(m_str, s.m_str)==0);
}

bool String::operator==(const char* s)const
{
	return ((strcmp(m_str, s ? s : "")) == 0);
}

bool String :: operator !=  (const String& s) const
{
	return !(*this == s);
}

bool String::operator != (const char* s)const
{
	return !(*this == s);
}

bool String ::operator > (const String& s)const
{
	return (strcmp(m_str, s.m_str) > 0);
}

bool String ::operator > (const char* s)const
{
	return ((strcmp(m_str, s ? s : "")) > 0);
}

bool String ::operator < (const String& s)const
{
	return (strcmp(m_str, s.m_str) < 0);
}

bool String ::operator < (const char* s)const
{
	return ((strcmp(m_str, s ? s : "")) < 0);
}

bool String ::operator >= (const String& s)const
{
	return (strcmp(m_str, s.m_str) >= 0);
}

bool String ::operator >= (const char* s)const
{
	return ((strcmp(m_str, s ? s : "")) >= 0);
}

bool String ::operator <= (const String& s)const
{
	return (strcmp(m_str, s.m_str) <= 0);
}

bool String ::operator <= (const char* s)const
{
	return ((strcmp(m_str, s ? s : "")) <= 0);
}

String String :: operator + (const String& s)const
{
	return (*this + s.m_str);
}

String String :: operator + (const char* s)const
{
	int len;
	String ret;
	len = m_length + strlen(s ? s : "");
	char *str = reinterpret_cast<char*>(malloc(len + 1));

	if (str)
	{
		strcpy(str,m_str);
		strcat(str,s);

		free(ret.m_str);

		ret.m_str = str;
		ret.m_length = len;
	}
	else
	{
		cout << "no mem to malloc" << endl;
	}

	return ret;
}

String String :: operator += (const String& s)
{
	return (*this = *this + s.m_str);
}

String String :: operator += (const char* s)
{
	return (*this = *this + s);
}

String& String ::operator = (const String& s)
{
	return (*this = s.m_str);//调用下面的赋值操作符重载
}

String& String ::operator = (const char* s)
{
	if (m_str != s)
	{
		char* str = _strdup(s ? s : "");

		if (str)
		{
			free(m_str);
			m_str = str;

			m_length = strlen(str);
		}
		else
		{
			cout << "no mem to malloc" << endl;
		}

	}
	else
	{
		cout << "str is equal to m_str" << endl;
	}

	return *this;
}

String& String ::operator = (const char c)
{
	char s[] = { c,'\0' };
	return (*this = s);
}

String :: ~String ()
{
	free(m_str);
}



int main()
{
	String s = "D.T.Software";

	cout << s.startWith("D.T.") << endl;
	cout << s.endWith("Software") << endl;

	for (int i = 0; i < s.length(); i++)
	{
		cout << s[i] << endl;
	}

	String s1 = "";
	s1.insert(0, "D.T.");
	s1.insert(4, "Software");

	cout << s1.c_str() << endl;


	return 0;
}

结果：