奋斗了几个晚上了,还是通过不了,请大虾帮忙改正!!!奉贤全部身家,跪谢!请尽快答复

[ncuxieyan]

//======ADT String的表示与实现=======
#include <iostream.h>
#include <stdlib.h>
#include <stdio.h>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
typedef char Status;
typedef struct{
char *ch;
int length;
}HString;
Status InitString(HString &T){
//创建个串
T.length=0;
T.ch=NULL;
return OK;
}//InitString
Status StrAssign(HString &T,char*chars){
//生成一个其值等于串常量chars的串T
int i,j;
char *c;
if (T.ch) free(T.ch);
for(i=0,c=chars;*c;++i,++c);
if(!i){T.ch=NULL;T.length=0;}
else {
if(!(T.ch=(char*)malloc(i*sizeof(char))))
exit(OVERFLOW);
for(j=0;j<=i-1;j++)T.ch[j]=chars[j];
T.length=i;
}//else
return OK;
}//String
int StrLength(HString S){
//返回S的元素个数,称为串的长度
int L_length=0,i=0;
while(S.ch[i]){
L_length++;i++;
}//while
return L_length;
}//StrLength
int StrCompare(HString S,HString T){
//若S>T,则返回值>0;若S=T,则返回值=0;若S<T,则返回值<0
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;
}//Stringcompare
Status ClearString(HString &S){
//将S清为空
if(S.ch) {free(S.ch);S.ch=NULL;}//只清了个头指针,后面的也会释放掉??只是清空,为什么要用
S.length=0; //free释放掉,空间都没了教清空吗?应该只是每个
return OK;
}//Clearstring
Status Concat (HString &T,HString S1,HString S2){
//用T返回由S1与S2联接而成的新串
int i;
if (T.ch) free(T.ch);
if(!(T.ch=(char*)malloc((S1.length+S2.length)*sizeof(char))))
exit(OVERFLOW);
for(i=0;i<=S1.length-1;i++) T.ch[i]=S1.ch[i];
T.length=S1.length+S2.length;
for(i=S1.length;i<=T.length-1;i++)T.ch[i]=S2.ch[i];
return OK;
}//Concat
Status SubString(HString &Sub,HString S,int pos,int len){
//用Sub返回S的第pos个字符起长度为len的子串
//其中.1<=pos<=StrLength(S)且0<=len<=StrLength(S)-pos+1
int i;
if (pos<1 || pos>S.length || len<0 || len>S.length-pos+1)
return OK;
if(Sub.ch) free(Sub.ch);
if(!len){Sub.ch=NULL; Sub.length=0;}
else{
Sub.ch=(char*)malloc(len*sizeof(char));
for (i=0;i<=len-1;i++,pos++) Sub.ch[i]=S.ch[pos-1];
Sub.length=len;
}return OK;
}//SubString
void main()
{
cout<<"===================请选择你要的操作!==========================\n";
cout<<"\n";
cout<<"========1.退出程序!===========================================\n";
cout<<"========2.生成一个其值等于常量chars的串T======================\n";
cout<<"========3.返回串的元素个数,称为串的长度=======================\n";
cout<<"========4.比较输入的两个串,>,=,<的返回值分别为>0,0,<0=========\n";
cout<<"========5.将串清空,并释放其空间===============================\n";
cout<<"========6.用T返回两个串联接而成的新串=========================\n";
cout<<"========7.如果符合条件,返回串S的第pos个字符起长度为len的子串==\n";
int choice,j,len,i;
char chars,chars1,chars2;
char S[]="chars",S1[]="chars1",S2[]="chars2";
HString T,M,N,Sub;
InitString (T);
InitString (M);
InitString (N);
while(choice!=1){//这里choice没有初始值能判断吗?
cout<<"========请选择你要的操作:";
cin>>choice;
switch(choice){
case 1:
break;
case 2:
cout<<"请输入一个字符串常量!\n";
cin>>chars;
StrAssign (T,S);
cout<<"已生成一个其值等于常量chars的串T!\n";
break;
case 3:
cout<<"请输入一个字符串常量!\n";
cin>>chars;
StrAssign(T,S);
StrLength(T);
cout<<"串长度为:"<<StrLength(T)<<"\n";
break;
case 4:
cout<<"请输入两个字符串常量S1和S2!\n";
cin>>chars1;cin>>chars2;
StrAssign(M,S1);StrAssign (N,S2);
StrCompare(M,N);
cout<<"比较结果为:";
if(StrCompare(M,N)==0)cout<<"S1=S2\n";
else{
if(StrCompare(M,N)>0)cout<<"S1>S2\n";
else cout<<"S1<S2\n";
break;
}//else
case 5:
cout<<"请输入一个字符串常量!\n";
cin>>chars;
StrAssign(T,S);
ClearString(T);
cout<<"字符串已清空!\n";
break;
case 6:
cout<<"请输入两个字符串常量S1,S2!\n";
cin>>chars1;
cin>>chars2;
StrAssign(M,S1);
StrAssign(N,S2);
Concat(T,M,N);
cout<<"两个串联接成的新串为:";
for(i=0;i<=T.length-1;i++)cout<<T.ch[i]<<"\n";
break;
case 7:
cout<<"请输入一个字符串常量!\n";
cin>>chars;
StrAssign(T,S);
cout<<"请输入位置i=\n";
cin>>i;
cout<<"请输入长度len=\n";
cin>>len;
SubString(Sub,T,j,len);
break;
}//switch
}//while
}//main

[socrazylee]

这个小兄弟，你先站起来好吗？跪下很累得，

[darkstar21cn]

最主要的是根本没有考虑到内存分配重分配，释放问题。

[ncuxieyan]

我是没学好C,以前学只是为了考试,没想到日后还要用,总以为学C++就够了!现在刚学C++,刚好学到类这里,感觉云里雾里,不知道跟C比起来有什么优势,运用更是无从谈起!敢请教各位大哥都是做什么的？这么牛，好羡慕！不知道以后我能不能这样！我们寝室也有个牛人，写程序N块，极度羡慕外加妒忌！

[ncuxieyan]

kenyle(哎呀妈呀~这不就是传说中的B13吗～～) ：C里有C++里没有的函数吗？？？
小弟参观了下同学写的，改了一下，已能正确运行！请各位强人评价一下，我们用的确实是严蔚敏和吴伟民编的那本书，说是说用的什么类C，是不是就是C和C++杂交的啊？有些写法在以前的C里面没见过，这里特别感谢 fire314159(不说废话了)等大虾！
还想请教个问题，在这里怎么挣分呀？我就剩下几十分，快挂了


//======ADT String的表示与实现=======
#include <iostream.h>
#include <stdlib.h>
#include <stdio.h>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
typedef char Status;
typedef struct{
char *ch;
int length;
}HString;
Status InitString(HString &T){
//创建个串
T.length=0;
T.ch=NULL;
return OK;
}//InitString
Status StrAssign(HString &T,char*chars){
//生成一个其值等于串常量chars的串T
int i,j;
char *c;
if (T.ch) free(T.ch);
for(i=0,c=chars;*c;++i,++c);
if(!i){T.ch=NULL;T.length=0;}
else {
if(!(T.ch=(char*)malloc(i*sizeof(char))))
exit(OVERFLOW);
for(j=0;j<=i-1;j++)T.ch[j]=chars[j];
T.length=i;
}//else
return OK;
}//String
int StrLength(HString S){
//返回S的元素个数,称为串的长度
//int L_length=0,i=0;------->结果固定为9
//while(S.ch[i]){
//L_length++;i++;
//}//while
//return L_length;
return S.length;
}//StrLength
int StrCompare(HString S,HString T){
//若S>T,则返回值>0;若S=T,则返回值=0;若S<T,则返回值<0
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;
}//Stringcompare
Status ClearString(HString &S){
//将S清为空
if(S.ch) {free(S.ch);S.ch=NULL;}//只清了个头指针,后面的也会释放掉??只是清空,为什么要用
S.length=0; //free释放掉,空间都没了教清空吗?应该只是每个
return OK;
}//Clearstring
Status Concat (HString &T,HString S1,HString S2){
//用T返回由S1与S2联接而成的新串
int i;
if (T.ch) free(T.ch);
if(!(T.ch=(char*)malloc((S1.length+S2.length)*sizeof(char))))
exit(OVERFLOW);
for(i=0;i<=S1.length-1;i++) T.ch[i]=S1.ch[i];
T.length=S1.length+S2.length;
for(i=S1.length;i<=T.length-1;i++)T.ch[i]=S2.ch[i];
return OK;
}//Concat
Status SubString(HString &Sub,HString S,int pos,int len){
//用Sub返回S的第pos个字符起长度为len的子串
//其中.1<=pos<=StrLength(S)且0<=len<=StrLength(S)-pos+1
int i;
if (pos<1 || pos>S.length || len<0 || len>S.length-pos+1)
return ERROR;
if(Sub.ch) free(Sub.ch);
if(!len){Sub.ch=NULL; Sub.length=0;}
else{
Sub.ch=(char*)malloc(len*sizeof(char));
for (i=0;i<=len-1;i++,pos++) Sub.ch[i]=S.ch[pos-1];
Sub.length=len;
}return OK;
}//SubString
Status show(HString S){
//显示串S
for(int i=0;i<S.length;i++)
cout<<S.ch[i];
cout<<"\n";
return OK;
}//show
void main()
{
cout<<"===================请选择你要的操作!==========================\n";
cout<<"\n";
cout<<"========1.退出程序!===========================================\n";
cout<<"========2.生成一个其值等于常量S1的串T======================\n";
cout<<"========3.返回串的元素个数,称为串的长度=======================\n";
cout<<"========4.比较输入的两个串,>,=,<的返回值分别为>0,0,<0=========\n";
cout<<"========5.将串清空,并释放其空间===============================\n";
cout<<"========6.用K返回两个串联接而成的新串=========================\n";
cout<<"========7.如果符合条件,返回串S的第pos个字符起长度为len的子串==\n";
int choice,j,len,i,pos;
char chars1[10],chars2[10];
cout<<"请输入两个字符串常量S1,S2!\n";
cout<<"S1为:"<<"\n";
cin>>chars1;
cout<<"S2为:"<<"\n";
cin>>chars2;
HString T,S,Sub,K;
InitString (T);
InitString (Sub);
InitString (S);
InitString (K);
StrAssign (T,chars1);
StrAssign (S,chars2);
while(choice!=1){//这里choice没有初始值能判断吗?
cout<<"========请选择你要的操作:";
cin>>choice;
switch(choice){
case 1:
break;
case 2:
cout<<"已生成一个其值等于常量S1的串T!\n";
show(T);
break;
case 3:
cout<<"选择你选的串的长度,选1为S1,否则为S2的长度!\n";
cin>>i;
if (i==1){
StrLength(T);
cout<<"串长度为:"<<StrLength(T)<<"\n";
}//if
else {
StrLength(S);
cout<<"串长度为:"<<StrLength(S)<<"\n";
}//else
break;
case 4:
StrCompare(T,S);
cout<<"比较结果为:";
if(StrCompare(T,S)==0)cout<<"S1=S2\n";
else{
if(StrCompare(T,S)>0)cout<<"S1>S2\n";
else cout<<"S1<S2\n";
}//else
break;
case 5:
cout<<"请选择你要清空的字符串,选1为S1,否则为S2!";
cin>>j;
if(j==1){
ClearString(T);
cout<<"字符串S1已清空!\n";
}//if
else{
ClearString(S);
cout<<"字符串S2以清空!\n";
}//else
break;
case 6:
Concat(K,T,S);
cout<<"两个串联接成的新串为:";
show(K);cout<<"\n";
break;
case 7:
cout<<"请输入位置pos=\n";
cin>>pos;
cout<<"请输入长度len=\n";
cin>>len;
cout<<"选1为从S1中取,否则从S2中取!\n";
cin>>i;
if(i==1)SubString(Sub,T,pos,len);
else SubString(Sub,S,pos,len);
cout<<"返回的子串为:";show(Sub);
break;
default :
break;
}//switch
}//while
}//main

[ncuxieyan]

不好意思，不贴上去就乱七八糟的！！！请各位耐心点

[kenyle]

给你几点意见，Ｃ＋＋是面象对象的，所以不要在用结构化的设计思想来写程序。
同时用Ｃ＋＋的时候，没有需要，尽量不要把Ｃ的函数也代进来用！
用一下类，将功能封装一下。

[fire314159]

很明显，楼主程序中用c写的那些是出自严奶奶的<数据结构>.
c++的就不知道出自那些高人了。


太长，只说c部分。
楼主主要没有搞懂指针和动态分配函数。

例如---
Status ClearString(HString &S){
//将S清为空
if(S.ch) {free(S.ch);S.ch=NULL;}//只清了个头指针,后面的也会释放掉??只是清空,为什么要用
S.length=0; //free释放掉,空间都没了教清空吗?应该只是每个
return OK;
}//Clearstring


s.ch只是一个占4个字节空间的指针，里面存的是动态分配的堆的地址。（这里堆的定义是严慧敏书中的定义）
free(s.ch)只是释放了堆的空间，而指针自己本身呢？没有丝毫改变，那四个字节空间依然存着堆的地址，但堆那些空间都还给系统了，只是你还知道他在哪里而已。
之所以为什么不直接s.ch=NULL.是因为你不知道s.ch原来指向的空间有没有释放，如果它原来指向一个很大的空间，而你不释放它。直接把S.ch=NULL。固然后面的操作没问题（如插入合并串），但原来那个空间就变成没用空间浪费内存了。这样的操作一多，内存甚至不够用。

[jalang]

楼上说的很不错.最好写完类之后.再留下些文档之类的东西.这样便于以后使用.

[owsxo]

你写的太乱了，你是不是刚学c语言啊，建议你还是用tc算了，c++不是那么写程序的
你要做什么功能的程序呀，兄弟帮你搞定算了，你的代码太乱了，看的头晕

[fire314159]

你写的太乱了，你是不是刚学c语言啊，建议你还是用tc算了，c++不是那么写程序的
你要做什么功能的程序呀，兄弟帮你搞定算了，你的代码太乱了，看的头晕


---------
这位兄弟的自信很好，但不是好的学习态度。谁都会有不懂的时候。

[esor]

很久没有看到这样的代码了。

[zhaoyongtao]

帮你顶

[yangfasheng]

Mark! 在时间来看,

[pc2s]

我草草地看了一下，发现程序里面几个问题。
1、既然上面StrAssign时的字符串没有'\0'的结束符，那么这个函数就不能这么写。应该直接返回S.length
int StrLength(HString S){
int L_length=0,i=0;
while(S.ch[i]){
L_length++;i++;
}//while
return L_length;
}//StrLength

2、下面这段代码，不是错误，只是回答你的问题。free清除了s.ch指向的内存空间。并非清除指针。
Status ClearString(HString &S){
if(S.ch) {free(S.ch);S.ch=NULL;}
S.length=0;
return OK;
}//Clearstring

3、这段代码，你的提示信息是“输入一个字符串”，可是chars却只是一个字符？肯定是有问题的（下同）
case 2:
cout<<"\n";
cin>>chars;
StrAssign (T,S);
cout<<"\n";
break;

其他的我没细看，也没调试运行。

[挺拔的劲松]

字符串操作演示系统
问题描述】
用户自己实现串类型，并写一个串的基本操作的演示系统。在该演示系统中能提供命令行的输入，并能对输入的命令行进行简单的编译并作相应的出错处理，最后根据命令动词功能来执行命令行。命令定义如下：

1.赋值：assign 串名1 串名2　

例如输入命令 assign ss tt

操作的结果是将串tt赋值给了ss串

2.新建：creat 串名 字符串常量

例如输入命令 creat ss 'abcdefg '

操作的结果是将字符串常量赋值给串ss，注意：字符串常量两边用单引号括起来，不能省略。

3.判等： equal 串名1 串名2

例如输入命令 equal ss tt

操作的结果是根据两串比较的结果输出相应的信息

4.求串长：length 串名

操作的结果是返回字符串长度

5.字符串连接： concat 串名1 串名2 新串名

例如输入命令 concat ss tt v

操作的结果是将串ss和串tt连接起来(ss在前，tt在后)形成一个新串，并输出新串

6.求子串： substr 串名 起始位置子串长度 新子串名

例如输入命令 substr ss 1 3 t

操作的结果是将串ss从起始位置1开始的3 个字符存入到串t中

7.子串定位： index 串名1 串名2 起始位置

例如输入命令 index ss t 1

操作的结果是返回串t在串ss从第1个字符后的字符序列中第一次出现的位置

8.退出： quit　

功能：结束演示系统运行

【数据描述】

1.定义串的数据类型为指向字符的指针

typedef char *STRING;/*定义新的字符串类型，即指向字符的指针*/

2.在本程序中支持串名操作，因此需将各字符串所对应的串名和首地址都存放在一个串头表中

struct strheadlist

{STRING strhead[100]; /*字符串首地址*/

STRING strname[100]; /*字符串的串名*/

int curnum; /*当前串头表中串的数目*/

}

3.对于提示符下输入的每一行命令，在进行分析以后，需要保留分析的结果(参数最多有6个)

struct result

{int num; /*命令行中参数的个数(含命令动词)*/

int nametype[6]; /*命令行中各参数的类型*/

STRING str[6]; /*命令行中各参数都以字符串的形式返回*/

}

注：参数类型以整型表示，如为1，则表示参数为命令动词；

如为2，则表示参数为字符串

如为3，则表示参数为整数

如为4，则表示参数为串名

可以仿照DOS操作系统来进行设计，提供命令行提示符，并能输入相应命令，并将命令行拆分为不同的几个部分（类似统计单词个数），再根据编译的结果进行相应的处理。

[挺拔的劲松]

【C源程序】　

#include "stdlib.h"

#include "stdio.h"

typedef char *STRING; /*定义新的字符串类型，即指向字符的指针*/

struct strheadlist

{STRING strhead[100];

STRING strname[100];

int curnum;

}; /*定义指向字符串的字针数组，并存放各字符串的串名（串名也用字符串来表示），及当前堆中串的数目*/

struct result

{int num;

int nametype[6];

STRING str[6];

}; /*定义命令行编译以后形成的命令及参数等数据*/

int strtoint(STRING s);

void creat(STRING s,STRING ss);

void assign(STRING s,STRING t);

int equal(STRING s,STRING t);

int length(STRING s);

void concat(STRING s,STRING t,STRING v);

void substr(STRING s,int start,int len,STRING v);

int index(STRING s,STRING t,int start);

struct result cmdsyna(int row);

int lookup(STRING s);

struct strheadlist head;

char cmd[40][80];

main()

{

struct result comm;

int row=0,i;

char c;

int equ;

head.curnum=0;

while(1) /*重复输入并处理相应命令*/

{

printf("CMD>");

for (i=0;(c=getchar())!='\n ';i++) cmd[row][i]=c;

cmd[row][i]= '\0 ';

comm=cmdsyna(row);/*对各命令动词进行判数并作参数分析*/

if (strcmp(comm.str[0],"creat")==0)　　/*字符串创建*/

{if (comm.num!=2) printf("Parameters is wrong!\n");

else if (lookup(comm.str[1])!=-1) printf("String %s cannot be creat!\n");

else {if (comm.nametype[1]==4 && comm.nametype[2]==2)

creat(comm.str[1],comm.str[2]);

}

}

else if (strcmp(comm.str[0],"assign")==0)　　/*字符串赋值*/

{if (comm.num!=2) printf("Parameters is wrong!\n");

else assign(comm.str[1],comm.str[2]);

}

else if (strcmp(comm.str[0],"equal")==0)　　/*字符串判等*/

{if (comm.num!=2) printf("Parameters is wrong!\n");

else

{if (lookup(comm.str[1])==-1||lookup(comm.str[2])==-1)

printf("String %s or %s is not found!\n",comm.str[1],comm. str[2]);

else {if (equal(head.strhead[lookup(comm.str[1])],

head.strhead[lookup(comm.str[2])])==1) printf("Equal!!!\n");

else printf("Not equal!!!\n");

}

}

}

else if (strcmp(comm.str[0],"length")==0)　/*字符串求长*/

{if (comm.num!=1) printf("Parameters is wrong!\n");

else {if (lookup(comm.str[1])==-1)

printf("The string %s connot be found!\n");

else printf("String %s :%s length is %d\n",comm.str[1],

head.strhead [lookup(comm.str[1])],length(head.strhead[lookup(comm.str[1])]));

}

}

else if (strcmp(comm.str[0],"concat")==0)　/*字符串连接并形成新的字符串*/

{if (comm.num!=3) printf("Parameters is wrong!\n");

else

{ if (lookup(comm.str[1])==-1||lookup(comm.str[2])==-1)

printf("The string %s or %s is not found!\n", comm.str[1],comm.str[2]);

else if (lookup(comm.str[3])!=-1) printf("String %s connot be creat!\n", comm.str[3]);

else concat(head.strhead[lookup(comm.str[1])],

head.strhead[lookup(comm.str[2])],comm.str[3]);

}

}

else if (strcmp(comm.str[0],"substr")==0)　/*取字符串子串，并形成新的字符串*/

{if (comm.num!=4) printf("Parameters wrong!\n");

else

{if (lookup(comm.str[1])==-1)

printf("String %s is not found!\n",comm.str[1]);

else

{if (lookup(comm.str[4])!=-1)

printf("String %s connot be creat!\n",comm.str[4]);

else

{int start,len;

start=strtoint(comm.str[2]);

len=strtoint(comm.str[3]); substr(head.strhead[lookup(comm.str[1])],start,

len,comm.str[4]);

}

}

}

}

else if (strcmp(comm.str[0],"index")==0)　　　/*字符串定位*/

{if (comm.num!=3) printf("Parameters wrong!\n");

else

{if (lookup(comm.str[1])==-1||lookup(comm.str[2])==-1)

printf("String %s or %s is not found!\n",

comm.str[1],comm.str[2]);

else

{int start,flag=-1;

start=strtoint(comm.str[3]); flag=index(head.strhead[lookup(comm.str[1])],head.strhead[lookup(comm.str[2])],start);

if (flag==-1) printf("String %s start %d ,

String %s is not index!!!\n",comm.str[1],start,comm.str[2]);

else printf("String %s start %d ,String %s is index %d!!!\n",

comm.str[1],start,comm.str[2],flag);

}

}

}

else if (strcmp(comm.str[0],"quit")==0)　/*退出演示系统*/

{printf("Bye Bye!\n");

break;

}

else

printf("Bad filename or no command!\n");　/*错误命令动词提示*/

row++;

}

}

int strtoint(STRING s)　/*将字符串转换成整数常量*/

{

int i=0;

int total=0;

while(s[i]!= '\0 ')

{total=total*10+s[i]-48;

i++;

}

return(total);

}

[jordan023]

各位大虾，请教你们一个小问题！
如何将CTime通过_variant_t 写到SQL中的datetime类型的字段中?
谢谢了 在线等！

[挺拔的劲松]

/*接上源程序~~~*/

int lookup(STRING s)　

/*查找串表中是否存在串名所对应的字符串，如存在则返回所对应的位置，否则返回-1*/

{int i;

int look=-1;

for (i=0;i<head.curnum;i++)

if (strcmp(head.strname[i],s)==0)

{look=i;

break;

}

if (look==head.curnum) look=-1;

return(look);

}

struct result cmdsyna(int row) /*对输入的命令行进行编译*/

{int i;

struct result res;

char c;

int word=0,start;

res.num=-1;

for(i=0;(c=cmd[row][i])!= '\0 ';i++)

{ if(c== ' ')

{word=0;

cmd[row][i]= '\0 ';

}

else

if (word==0)

/*出现了一个新的参数，将分离出的各参数以及命令动词放置于参数表中*/

{res.num++;

start=i;word=1;

res.str[res.num]=&cmd[row][start];

if (res.num==0) res.nametype[res.num]=1;

else

if (cmd[row][start]==39)

{cmd[row][start]= '\0 ';

res.str[res.num]=&cmd[row][start+1];

res.nametype[res.num]=2;

}

else

{if (cmd[row][start]>= '0 '&&cmd[row][start]<= '9 ')

res.nametype[res.num]=3;

else res.nametype[res.num]=4;

}

}

else

{if (res.nametype[res.num]==2 && c==39) cmd[row][i]= '\0 ';　

/*处理参数中字符串常量*/

if (res.nametype[res.num]==3 &&(c<'0'||c>'9')) cmd[row][i]= '\0';

/*处理参数中整数常量*/

}

}

return(res);

}

int index(STRING s,STRING t,int start)

/*从串S起始置START开始查找串T，如找到，则返回第一次出现的位置，否则返回-1*/

{

int i,j;

if ((start<0)||(start+length(t)>length(s))||(length(t)==0))

return(-1);

else

{i=start;

j=0;

while (i<length(s)&&j<length(t))

{

if (s[i]==t[j])

{i++;j++;}

else

{i=i-j+1;j=0;}

}

}

if (j==length(t))

return(i-length(t));

else

return(-1);

}

void substr(STRING s,int start,int len,STRING v)

/*为新串开辟新的空间，并将从串S中START起始位置起取LEN长度的子串存放起来，把新串的串名和首地址存放于串表中*/

{int i;

char ch[80];

if (start<0&&start>=length(s))

printf("Cannot be substr!!!\n");

else

{if (len>=1&&len<=length(s)-start)

{ head.strname[head.curnum]=v;

head.strhead[head.curnum]=ch;

for(i=0;i<len;i++)

ch[i]=s[start+i];

ch[i]= '\0';

head.curnum++;

printf("The string %s :%s\n",v,ch);

}

else

printf("Cannot be substr!!!\n");

}

}

void concat(STRING s,STRING t,STRING v)

/*为新串开辟新的空间，并将两串连接起来存放起来，并输出连接后的字符串，将新串的串名和首地址存放到串表中*/

{

int i,j;

char ch[80];

head.strname[head.curnum]=v;

head.strhead[head.curnum]=ch;

for (i=0;s[i]!= '\0';i++)

ch[i]=s[i];

for (j=i,i=0;t[i]!= '\0';i++,j++)

ch[j]=t[i];

ch[j]= '\0';

head.curnum++;

printf("The string %s :%s\n",v,ch);

}

int length(STRING s)

{

return(strlen(s));

}

int equal(STRING s,STRING t)

/*比较两串是否相等，如相等则返加整数1，否则返回0*/

{

if (strcmp(s,t)==0) return 1;

else return 0;

}

void assign(STRING s,STRING t)

/*将字符串T所指向的字符串的首地址和新串S的名称存入于串表相应的位置上，并输出赋值后的字符串*/

{

int look1,look2;

if ((look1=lookup(t))==-1)

printf("The string %s is not found!\n",t);

else {if ((look2=lookup(s))==-1)

{head.strhead[head.curnum]=head.strhead[look1];

head.strname[head.curnum]=s;

head.curnum++;

}

else

{head.strhead[look2]=head.strhead[look1];}

printf("The string %s : %s\n",s,head.strhead[look2]);}

}

void creat(STRING s,STRING ss)

/*将字符串常量的首地址和串的名称存放于串表相应的位置上，并输出新建后的字符串*/

{

head.strhead[head.curnum]=ss;

head.strname[head.curnum]=s;

head.curnum++;

printf("The string %s :%s\n",s,ss);

}

【测试数据】可以自定义一些测试数据，如：

1. CMD>creat ss 'abcdef' ↙

2. CMD>assign tt ss↙

3. CMD>length ss↙

4. CMD>concat abc 'abc' tt↙

5. CMD>index ss tt 0↙

6. CMD>quit↙

【说明】

1.由于C语言数组下标是以0开始，所以在本程序中使所用到的数组都是以下标0开始；

2.本程序在存放字符串时采用类似堆的存储结构，先定义了一个二维数组来读取每一行命令，在对每一行命令进行分析以后，将各参数以字符串的形式返回，先进行第一个参数(命令动词)的比较处理，再进行其作参数的处理，最后执行相应的串操作。

[LoveCreatesBeauty]

回复人： ncuxieyan(想知道) ( ) 信誉：100 2004-10-20 22:30:00 得分: 0


不好意思，不贴上去就乱七八糟的！！！请各位耐心点


////////////////

VC6:

Tools / Options / Tabs / Insert spaces

[xcyxl]

顶