c课程设计报告字符串操作Word文件下载.docx
《c课程设计报告字符串操作Word文件下载.docx》由会员分享，可在线阅读，更多相关《c课程设计报告字符串操作Word文件下载.docx（29页珍藏版）》请在冰豆网上搜索。
inlineFStringoperator-（constFStringsAppend）;
inlineFStringoperator-=（char*val）;
//新增函数，重载-=运算符
inlineFStringoperator-=（FStringval）;
由于程序中的处理函数使用了字符数组sAns，它占用了大量的存储空间，为了避免使用预先定义的长度很大的数组，增加了新的析构函数~FString（）{}释放了字符串对象所占用的空间，删除了动态分配的存储空间。
新增了构造函数，用于字符串常量初始化字符串对象。
三：
调试过程。
在调试过程中遇到一个困扰我很久的问题，一直有一个localfunctiondefinitionsareillegal。
就是一类问题始终出现，刚开始我觉得可能是有分号输入错误，然后我就查找了一下全部的分号。
查找的结果是没有错误。
于是，我就排除了这方面的原因。
然后我开始分部分查找错误，编译。
局限到具体的小部分时候，就可以很好的排查了！
结果在小的方面出错了，少了对应的一个大括号。
四：
输入输出数据
输入：
第一组：
godlikekill
输出：
1.字符串加法godlikekill
2.字符串减法godlike
3.字符串不比较大小‘godlike’<
‘kill’
4.对字符串的具体操作1）.删除字符串首部相同字符godlike
2）.删除字符串尾部相同字符godlike
3）.删除字符串的所有重复字符godlike
4）.字符串的插入操作插入位置3插入字符串ree结果goreedlike
5）.字符串的替换操作用kill替换like结果godkill
输入：
第二组：
uuseelook
输出：
1.字符串加法‘uuseelook’
2.字符串减法uusee、
3.字符串不比较大小‘uusee’>
‘look’
4.对字符串的具体操作1）.删除字符串首部相同字符see
2）.删除字符串尾部相同字符uusee
3）.删除字符串的所有重复字符use
4）.字符串的插入操作位置2插入串lio结果：
uliousee
5）.字符串的替换操作用r替换s结果uuree
第三组：
perfectgood
1.字符串加法perfectgood
2.字符串减法perfect
3.字符串不比较大小‘perfect’>
‘good’
4.对字符串的具体操作1）.删除字符串首部相同字符perfect2）.删除字符串尾部相同字符perfect
3）.删除字符串的所有重复字符perfect
4）.字符串的插入操作插入位置2插入字符串more结果：
pmoreerfect
5）.字符串的替换操作用t替换f
结果：
pertect
五：
课程设计总结
在这个月的编程中，起初我发现这个题目很难，看不太懂那些东西！
然后我就找到书上面对应的部分看了看，我发现什么难的程序只要你花费的时间够多的话，到最后你就会发现其实真正不是很难。
只要你用心真的去做。
还有另外一点，一个好的编程习惯会对你改错或者是检查的时候带来很大的帮助。
比如说那个各种嵌套的函数时,要用到的大括号，最好都写在每行的最前面，也好对应看括号的个数是否对应.当然这只是举个例子。
我觉得学好一个软件还是很有用处的。
六：
附件
#include<
iostream.h>
stdio.h>
stdlib.h>
string.h>
windows.h>
stdarg.h>
//定义参数个数可变的函数时用到
#defineMAX_FSTRING_LENGTH250//用作数组长度
//VariantClass
classFString{//字符串类定义
private:
char*sString;
//Stringdatamustbefirst（tolooklikestring）
intnlength;
public:
//Constructor
FString（）;
//缺省构造函数
FString（char*str）;
//新增构造函数，用字符串常量初始化字符串对象
FString（FString&
）;
//新增拷贝构造函数，用类的对象初始化
~FString（）{}//新增析构函数，释放字符串对象所占用的空间
//PublicMethods
voidDelRepeat（）;
FStringAddStart（FStringstr,intstart）;
FStringMid（constintnStart,constintnLength）;
/*从字串对象中第nStart个字符开始取出nLength个字符*/
FStringLeft（constintnLength）;
//从字串对象左边取出nLength个字符
FStringRight（constintnLength）;
//从字串对象右边取出nLength个字符
intInStr（constintnStart,constchar*sSearch,constboolbCaseSensitive=true）;
/*从nStart个字符处开始，在字串对象中寻找子串sSearch,参数bCaseSensitive为0表示忽略大小写*/
intInStrRev（constintnStart,constchar*sSearch,constboolbCaseSensitive=true）;
/*寻找子串的倒置串在住串中的位置*/
FStringRTrim（constcharsChar='
'
//串尾整理，即去掉串尾与sChar相同的字符
FStringLTrim（constcharsChar='
//串首整理，即去掉串首与sChar相同的字符
FStringTrim（constcharsChar='
//串首串尾整理
FStringReplace（constchar*sSearch,constchar*sReplace）;
/*用子串*sReplace去替换主串中所有的子串*sSearch*/
FStringFormat（constchar*sFormat,...）;
//按指定格式输出字符串
intLength（）;
//VariousOperators
inlineoperatorchar*（）;
//转换函数
inlineFStringoperator+（constchar*sAppend）;
//重载加法运算符
inlineFStringoperator+（constFStringsAppend）;
//重载加法运算法
//重载减法运算法
inlinecharoperator[]（constintnIndex）;
//重载[]运算法
inlineFStringoperator+=（char*val）;
//重载+=运算符
inlineFStringoperator+=（FStringval）;
//重载-=运算符
//ComparisonOperators
inlineintoperator<
（constchar*val）;
//重载关系<
运算符
=（constchar*val）;
=运算符
inlineintoperator>
//重载关系>
inlineintoperator!
//重载关系!
inlineintoperator==（constchar*val）;
//重载关系==运算符
（constFStringval）;
=（constFStringval）;
inlineintoperator==（constFStringval）;
//AssignmentOperators
FStringoperator=（constchar*val）;
//重载赋值运算符=
FStringoperator=（constFStringval）;
//重载对象赋值运算符=
};
//----------FStringClass,GregDeHaas-27March2002-------------
//Thisisasimplestringclassthatcancomeinuseful
//I'
vekeptthenamingconventionssimilartoVBforsimplicity
//--------------------------------------------------------------------
//下面是GFHString.h中说明的各函数的具体定义
//Constructor
FString:
:
FString（）{
sString=0;
nlength=0;
}
FString（char*str）{
if（str）{
nlength=strlen（str）;
sString=newchar[nlength+1];
strcpy（sString,str）;
else{
sString=0;
nlength=0;
}
FString（FString&
str）{
nlength=str.nlength;
if（str.sString）{
strcpy（sString,str.sString）;
else
//Comparisons
intFString:
operator<
（constchar*val）{return（strcmp（sString,val）<
0）;
=（constchar*val）{return（strcmp（sString,val）<
=0）;
operator>
（constchar*val）{return（strcmp（sString,val）>
=（constchar*val）{return（strcmp（sString,val）>
operator!
=（constchar*val）{return（strcmp（sString,val）!
operator==（constchar*val）{return（strcmp（sString,val）==0）;
（constFStringval）{return（strcmp（sString,val.sString）<
=（constFStringval）{return（strcmp（sString,val.sString）<
（constFStringval）{return（strcmp（sString,val.sString）>
=（constFStringval）{return（strcmp（sString,val.sString）>
=（constFStringval）{return（strcmp（sString,val.sString）!
operator==（constFStringval）{return（strcmp（sString,val.sString）==0）;
//Otheroperators
FStringFString:
operator+=（char*val）{
FStringt=sString,t1;
t1.nlength=t.nlength+strlen（val）;
t1.sString=newchar[t1.nlength+1];
strcpy（t1.sString,sString）;
strcat（t1.sString,val）;
sString=_strdup（t1.sString）;
return（*this）;
operator+=（FStringval）{
t1.nlength=t.nlength+val.nlength;
strcat（t1.sString,val.sString）;
operator-=（char*val）{//新增函数，重载减法运算符
FStringt=sString;
char*p1,*p2;
if（p2=strstr（sString,val））{
p1=p2+strlen（val）;
while（*p2++=*p1++）;
returnt;
operator-=（FStringval）{//新增函数，重载减法运算符
FStringm=sString;
char*q1,*q2;
if（q2=strstr（sString,val.sString））{
q1=q2+val.nlength;
while（*q2++=*q1++）;
returnm;
charFString:
operator[]（constintnIndex）{//数组下标运算符重载
if（nIndex<
=0）return（0）;
if（nIndex>
（int）strlen（sString））return（0）;
//判断下标是否越界
return（sString[nIndex-1]）;
operatorchar*（）{return（_strdup（sString））;
operator+（constchar*sAppend）{
t.nlength=nlength+strlen（sAppend）;
t.sString=newchar[t.nlength+1];
strcpy（t.sString,sString）;
strcat（t.sString,sAppend）;
operator+（constFStringsAppend）{
FStringt;
t.nlength=nlength+sAppend.nlength;
strcat（t.sString,sAppend.sString）;
operator-（constchar*sAppend）{//新增函数，重载减法运算符
if（p2=strstr（sString,sAppend））{
p1=p2+strlen（sAppend）;
operator-（constFStringsAppend）{//新增函数，重载减法运算符
if（p2=strstr（sString,sAppend.sString））{
p1=p2+strlen（sAppend.sString）;
operator=（constchar*val）{
if（sString）delete[]sString;
nlength=strlen（val）;
sString=newchar[nlength+1];
strcpy（sString,val）;
operator=（FStringval）{
sString=_strdup（val.sString）;
AddStart（FStringstr,intstart）{//新增成员函数，将字符串str插入到原字符串中从第start字符开始的位置上
charq[MAX_FSTRING_LENGTH]="
"
;
strncpy（q,sString,start-1）;
strcat（q,str.sString）;
strcat（q,sString+start-1）;
sString=_strdup（q）;
voidFString:
DelRepeat（）{//新增成员函数，删除原字符串中相邻的重复字符
intn;
charsAns[MAX_FSTRING_LENGTH]="
n=strlen（sString）;
for（inti=0;
i<
n;
i++）{
if（sString[i+1]==sString[i]）
{
for（intj=i;
j<
j++）sString[j]=sString[j+1];
DelRepeat（）;
}
strcpy（sAns,sString）;
sString=_strdup（sAns）;
//cout<
<
sString<
'
\n'
Trim（charsChar）//串首串尾整理
{
return（this->
RTrim（sChar）.LTrim（））;
//注意此处的用法！
RTrim（charsChar）//串尾整理，即去掉串尾与sChar相同的字符
{
longnLen=strlen（sString）;
FStringsAns2;
intcnt=nLen-1;
sAns2=sString;
//Validate
if（nLen==0）return（sAns2）;
//Determine#ofchars
while（sString[cnt]==sChar&
&
cnt>
=0）cnt--;
if（cnt>
=（nLen-1））returnsAns2;
//Getcharacters
char*sAns=newchar[cnt+1];
strncpy（
升级会员 