HString

using namespace std;

#include <iostream>

#define OK 1
#define ERROR -1
#define OVERFLOW -2
#define TRUE 1
#define FALSE -1

typedef struct {
	/************************************************************************/
	/*串的堆分配存储表示					                                     */
	/*Went 2011-11-8 17:41											  */
	/************************************************************************/
	char *ch;				//若是非空串，则按串长分配存储区，否则ch为NULL
	int length;				//串长度
}HString;

int StrAssign(HString &T, const char *chars) {
	//生成一个其值等于串常量chars的串T
	int len = strlen(chars);
	int i;
	if (T.ch)	
		T.ch == NULL;			
	if (!len) {
		T.ch = NULL;
		T.length = 0;
	}
	else {
		if (!(T.ch = (char *)malloc(len * sizeof(char))))
			return OVERFLOW;
		for(i = 0; i < len; i++)
			T.ch[i] = chars[i];
		T.length = len;
	}
	return OK;
}

int StrLength(HString S) {
	//返回S的元素个数，称为串的长度
	if (!S.ch)
		return ERROR;
	return S.length;
}

int StrCompare(HString S, HString T) {
	//若S > T，则返回值 > 0；若S = T，则返回值=0；若S < T，则返回值 < 0
	if (!S.ch || !T.ch)
		return ERROR;
	int i;
	for(i = 0; i < S.length && i < T.length; i++) {
		if (S.ch[i] != T.ch[i])
			return S.ch[i] - T.ch[i];
	}
	return S.length - T.length;
}

int StrCopy(HString &T, HString S) {
	//串S存在，由串S复制得串T
	if (!S.ch)
		return ERROR;
	int i;
	if (T.ch)
		free(T.ch);			//释放T原有空间
	if (!S.length) {
		T.ch = NULL;
		T.length = 0;
	}
	else {
		if (!(T.ch = (char *)malloc(S.length * sizeof(char))))
			return OVERFLOW;
		for(i = 0; i < S.length; i++)
			T.ch[i] = S.ch[i];
		T.length = S.length;
	}
	return OK;
}

int StrEmpty(HString S) {
	//串S存在，若S为空串，返回TRUE，否则返回FALSE
	if (!S.ch)
		return ERROR;
	if (S.length)
		return FALSE;
	else
		return TRUE;
}

int ClearString(HString &S) {
	//串S存在，将S清为空串
	if (!S.ch)
		return ERROR;
	free(S.ch);
	S.ch = NULL;
	S.length = 0;
	return OK;
}

int Concat(HString &T, HString S1, HString S2) {
	//串S1，S2存在。用T返回由S1和S2连接而成的新串
	if (!S1.ch || !S2.ch)
		return ERROR;
	int i, j;
	if (T.ch)
		T.ch = NULL;				//释放旧空间
	if (!(T.ch = (char *)malloc((S1.length + S2.length) * sizeof(char))))
		return OVERFLOW;
	for(i = 0; i < S1.length; i++)
		T.ch[i] = S1.ch[i];
	T.length = S1.length + S2.length;
	for (i = S1.length, j = 0; i < T.length, j < S2.length; i++, j++)
		T.ch[i] = S2.ch[j];
	return OK;
}

int SubString(HString &Sub, HString S, int pos, int len) {
	//串S存在，1《pos《StrLength（S）且0《len《StrLength（S）-pos+1
	//用Sub返回串S的第pos个字符起长度为len的子串
	if (pos < 1 || pos > S.length || len < 0 || len > S.length - pos + 1)
		return ERROR;
	if (Sub.ch)
		Sub.ch = NULL;			//释放旧空间
	if (!len) {					//空子串
		Sub.ch = NULL;
		Sub.length = 0;
	}
	else {
		int i, j;
		Sub.ch = (char *)malloc(len * sizeof(char));
		for(i = 0, j = pos - 1; i < len, j < pos + len - 1; i++, j++)
			Sub.ch[i] = S.ch[j];
		Sub.length = len;
	}
	return OK;
}

int Index(HString S, HString T, int pos) {
	//串S和T存在，T是非空串，1《pos《StrLength（S）
	//若主串S中存在和串T值相同的子串，则返回它在珠串S中第pos个字符之后第一次出现的位置，否则返回0
	int len1, len2, i, j;
	len1 = S.length;
	len2 = T.length;
	i = pos - 1;
	j = 0;
	while(i < len1 && j < len2) {
		if (S.ch[i] == T.ch[j]) {
			i++;
			j++;
		}
		else {
			i = i - j + 1;				//对应字符不相等，重新比较
			j = 0;
		}
	}
	if (j == len2) 
		return i - len2 + 1;
	return 0;
}

int StrInsert(HString &S, int pos, HString T) {
	//串S，T存在，1《pos《StrLength（S）+ 1
	//在串S的第pos个字符之前插入串T
	if (!S.ch || !T.ch || pos < 1 || pos > S.length + 1)
		return ERROR;
	if (T.length) {
		if (!(S.ch = (char *)realloc(S.ch, (S.length + T.length) * sizeof(char))))
			return OVERFLOW;
		int i, j;
		for(i = S.length - 1; i > pos - 2; i--) 
			S.ch[i + T.length] = S.ch[i];
		for(i = pos - 1, j = 0; i < pos + T.length - 1, j < T.length; i++, j++)
			S.ch[i] = T.ch[j];
		S.length += T.length;
	}
	return OK;
}

int StrDelete(HString &S, int pos, int len) {
	//串S存在，1《pos《StrLength（S） - len + 1
	//从串S中删除第pos个字符起长度为len的子串
	if (!S.ch || pos < 1 || pos > S.length || len < 0 || len > S.length - pos + 1)
		return ERROR;
	int i;
	for(i = pos - 1; i < S.length - len; i++)
		S.ch[i] = S.ch[i + len];
	S.length -= len;
	S.ch = (char *)realloc(S.ch, S.length * sizeof(char));
	return OK;
}

int Replace(HString &S, HString T, HString V) {
	//串S，T，V存在。T是非空串
	//用V替换主串S中出现在所有与T相等的不重叠的子串
	if (!S.ch || !T.ch || !V.ch || !T.length)
		return ERROR;
	int i = 1;
	while(i) {
		i = Index(S, T, i);
		if (i) {
			StrDelete(S, i, T.length);
			StrInsert(S, i, V);
			i += V.length;
		}
	}
	return OK;
}

int main() {
	char *chars1 = "hello\n";
	char *chars2 = "he";
	char *chars3 = "123";
	HString s, v, t, sub;
	int i;
	StrAssign(t, chars1);
	StrAssign(s, chars2);
	StrAssign(v, chars3);
	/*for(i = 0; i < t.length; i++)
		cout << t.ch[i];
	cout << StrLength(t) << endl;
	StrAssign(s, chars2);
	cout << StrCompare(s, t) << endl;*/
	//StrCopy(s, t);
	//ClearString(s);
	/*for(i = 0; i < s.length; i++)
		cout << s.ch[i];
	Concat(v, s, t);
	for(i = 0; i < v.length; i++)
		cout << v.ch[i];
	SubString(sub, s, 3, 3);
	for(i = 0; i < sub.length; i++)
		cout << sub.ch[i];
	StrAssign(v, chars3);*/
	/*StrInsert(t, 1, v);
	for(i = 0; i < t.length; i++)
		cout << t.ch[i];
	cout << t.length << endl;*/
	/*StrDelete(t, 2, 3);
	for(i = 0; i < t.length; i++)
		cout << t.ch[i];
	cout << t.length << endl;*/
	Replace(t, s, v);
	for(i = 0; i < t.length; i++)
		cout << t.ch[i];
	system("pause");
}