c语言实现字符串的各种操作

以下是我用c语言实现数据结构中字符串的各种操作

 
#pragma once 
 
 
#ifndef _STDLIB_H 
#define _STDLIB_H 
 
#include <stdlib.h> 
#endif 
 
#ifndef _SIXE_H 
#define _SIZE_H 
 
#define SIZE              100 
#endif 
 
#ifndef _STRING_H 
#define _STRING_H 
 
typedef struct 
{ 
    char * p_ch; 
    long Length; 
}String; 
#endif

 
#include "stdafx.h" 
 
bool Str(String &T); 
 
bool StrAssign(String &T,char * p_char); 
 
bool StrEmpty(const String &T); 
 
int GetLength(const String &T); 
 
int StrCompare(const String &S,const String &T); 
 
bool StrClear(String &T); 
 
bool StrConcat(String &T,String S1,String S2); 
 
bool SubString(const String &T,int Pos,int Len,String &S); 
 
char GetElem(const String &T,int Pos); 
 
bool Find(const String &T,const String &S); 
 
bool StrCopy(String &T,String S); 
 
int Index(const String &T,const String &S); 
 
bool StrInsert(String &T,int Pos,String S); 
 
bool StrDelete(String &T,int Pos,int Len); 
 
char * GetBuffer(const String &T);

 
#include "String.h" 
 
bool Str(String &T) 
{ 
    T.p_ch=NULL; 
    T.Length=0; 
    return true; 
} 
 
 
bool StrAssign(String &T,char * p_char) 
{ 
    int Len=0; 
    char * temp=p_char; 
    while(* temp!=‘\0‘) 
    { 
        Len++; 
        temp++; 
    } 
    if(T.Length!=0) 
        free(T.p_ch); 
    { 
        T.p_ch=(char *)malloc((Len+1)*sizeof(char)); 
        if(T.p_ch==NULL) 
            return false; 
        else 
        { 
            int i=0; 
            for(i=0;i<Len;i++) 
            { 
                T.p_ch[i]=p_char[i]; 
            } 
            T.p_ch[i]=‘\0‘; 
            T.Length=Len; 
            return true; 
        } 
    } 
} 
 
 
bool StrEmpty(const String &T) 
{ 
    if(T.Length==0) 
        return true; 
    else 
        return false; 
} 
 
 
int GetLength(const String &T) 
{ 
    return T.Length; 
} 
 
 
int StrCompare(const String &S,const String &T) 
{ 
    if(GetLength(S)==GetLength(T)) 
    { 
        int i; 
        for(i=0;i<GetLength(S)&&i<GetLength(T);i++) 
        { 
            if(S.p_ch[i]<T.p_ch[i]) 
            { 
                return -1; 
            } 
            if(S.p_ch[i]>T.p_ch[i]) 
            { 
                return 1; 
            } 
            i++; 
        } 
        return 0; 
    } 
    else 
    { 
        int i; 
        for(i=0;i<GetLength(S)&&i<GetLength(T);i++) 
        { 
            if(S.p_ch[i]<T.p_ch[i]) 
            { 
                return -1; 
            } 
            if(S.p_ch[i]>T.p_ch[i]) 
            { 
                return 1; 
            } 
            i++; 
        } 
        if(GetLength(S)>GetLength(T)) 
            return 1; 
        else 
            return -1; 
    } 
} 
 
bool StrClear(String &T) 
{ 
    if(T.Length==0) 
        return false; 
    else 
    { 
        free(T.p_ch); 
        T.p_ch=NULL; 
        T.Length=0; 
        return true; 
    } 
} 
 
 
bool StrConcat(String &T,String S1,String S2) 
{ 
    if(T.Length!=0) 
        free(T.p_ch); 
    T.p_ch=(char *)malloc((S1.Length+S2.Length+1)*sizeof(char)); 
    if(T.p_ch==NULL) 
        return false; 
    else 
    { 
        int i=0,j=0; 
        for(i=0;i<GetLength(S1);i++) 
        { 
            T.p_ch[i]=S1.p_ch[i]; 
        } 
        for(j=0;j<GetLength(S2);j++,i++) 
        { 
            T.p_ch[i]=S2.p_ch[j]; 
        } 
        T.p_ch[i]=‘\0‘; 
        T.Length=S1.Length+S2.Length; 
        return true; 
    } 
} 
 
 
bool SubString(const String &T,int Pos,int Len,String &S) 
{ 
    if(Pos+Len>T.Length) 
        return false; 
    else 
    { 
        if(S.Length!=0) 
            free(S.p_ch); 
        else 
        { 
            S.p_ch=(char *)malloc((Len+1)*sizeof(char)); 
            int i,temp=Pos+Len; 
            for(i=0;Pos<temp;i++,Pos++) 
            { 
                S.p_ch[i]=T.p_ch[Pos]; 
            } 
            S.p_ch[i]=‘\0‘; 
            S.Length=Len; 
            return true; 
        } 
    } 
} 
 
 
char GetElem(const String &T,int Pos) 
{ 
    if(Pos>=T.Length) 
        return NULL; 
    else 
    { 
        return T.p_ch[Pos]; 
    } 
} 
 
 
bool StrCopy(String &T,String S) 
{ 
    if(S.Length==0) 
        return false; 
    else 
    { 
        T.p_ch=(char *)malloc((S.Length+1)*sizeof(char)); 
        int i=0; 
        while(i<S.Length) 
        { 
            T.p_ch[i]=S.p_ch[i]; 
            i++; 
        } 
        T.p_ch[i]=‘\0‘; 
        T.Length=S.Length; 
        return true; 
    } 
} 
 
bool StrInsert(String &T,int Pos,String S) 
{ 
    if(S.Length==0||Pos>=T.Length) 
        return false; 
    else 
    { 
        int i,j; 
        String temp; 
        Str(temp); 
        StrCopy(temp,T); 
        free(T.p_ch); 
        T.p_ch=(char *)malloc((temp.Length+S.Length+1)*sizeof(char)); 
        if(T.p_ch==NULL) 
            return false; 
        else 
        { 
            for(i=0;i<=Pos;i++) 
            { 
                T.p_ch[i]=temp.p_ch[i]; 
            } 
            Pos++; 
            for(j=0;j<S.Length;j++) 
            { 
                T.p_ch[i]=S.p_ch[j]; 
                i++; 
            } 
            while(Pos<temp.Length) 
            { 
                T.p_ch[i]=temp.p_ch[Pos]; 
                i++; 
                Pos++; 
            } 
            T.p_ch[i]=‘\0‘; 
            T.Length=temp.Length+S.Length; 
            free(temp.p_ch); 
            return true; 
        } 
    } 
} 
 
 
bool StrDelete(String &T,int Pos,int Len) 
{ 
    if(Pos+Len>T.Length) 
        return false; 
    else 
    { 
        String temp; 
        StrCopy(temp,T); 
        free(T.p_ch); 
        int i,j; 
        T.p_ch=(char *)malloc((temp.Length-Len+1)*sizeof(char)); 
        if(T.p_ch==NULL) 
            return false; 
        else 
        { 
            for(i=0;i<Pos;i++) 
            { 
                T.p_ch[i]=temp.p_ch[i]; 
            } 
            for(j=Pos+Len;j<temp.Length;j++,i++) 
            { 
                T.p_ch[i]=temp.p_ch[j]; 
            } 
            T.p_ch[i]=‘\0‘; 
            T.Length=temp.Length-Len; 
            free(temp.p_ch); 
        } 
    } 
} 
 
 
char * GetBuffer(const String &T) 
{ 
    return T.p_ch; 
} 
 
 
 
bool Find(const String &T,const String &S) 
{ 
    int posT=0,posS=0; 
    int lengthT=T.Length,lengthS=S.Length; 
    while(posT<lengthT&&posS<lengthS) 
    { 
        if(S.p_ch[posS]==T.p_ch[posT]) 
        { 
            posT++; 
            posS++; 
        } 
        else 
        { 
            if(posS==0) 
            { 
                posT++; 
            } 
            else 
            { 
                if(S.p_ch[0]==T.p_ch[posS]) 
                { 
                    posS=1; 
                    posT++; 
                } 
                else 
                { 
                    posS=0; 
                    posT++; 
                } 
            } 
        } 
    } 
    if(posS==lengthS) 
    { 
        return true; 
    } 
    else 
    { 
        return false; 
    } 
} 
 
 
int Index(const String &T,const String &S) 
{ 
    int posT=0,posS=0; 
    int lengthT=T.Length,lengthS=S.Length; 
    while(posT<lengthT&&posS<lengthS) 
    { 
        if(S.p_ch[posS]==T.p_ch[posT]) 
        { 
            posT++; 
            posS++; 
        } 
        else 
        { 
            if(posS==0) 
            { 
                posT++; 
            } 
            else 
            { 
                if(S.p_ch[0]==T.p_ch[posS]) 
                { 
                    posS=1; 
                    posT++; 
                } 
                else 
                { 
                    posS=0; 
                    posT++; 
                } 
            } 
        } 
    } 
    if(posS==lengthS) 
    { 
        return posT-S.Length; 
    } 
    else 
    { 
        return -1; 
    } 
}

时间： 2024-10-19 05:54:04

c语言实现字符串的各种操作的相关文章

C语言对字符串的一些操作

1. 字符串中移除一个字符 1 void removeChar(char *str, char c) 2 { 3 char *s = str; 4 int j, k; 5 6 for(j=k=0; s[j]!='\0'; j++) { 7 if(s[j]!=c) 8 s[k++]=s[j]; 9 } 10 11 s[k]= '\0'; 12 } 2. 字符串转为16进制整数 1 unsigned int StrToHex(char *pszSrc, int nLen) 2 { 3 char h1

c语言中字符串操作的工具类

1.编写头文件 #define _CRT_SECURE_NO_WARNINGS //#pragmawarning(disable:4996) #include <stdio.h> #include <stdlib.h> #include <string.h> struct CString { char *p; //保存字符串首地址 int reallength; //实际长度 }; typedef struct CString mystring;//

D语言中字符串的操作

字符串的操作在软件开发中是特别重要的一个事情,因为基本上的编程都会使用到字符串,字符串操作的好坏决定着一个语言的好与差.在我做过的一个项目中曾经就出现过字符串操作性能问题. D语言字符串有 string,wstring,dstring三种类型,在D语言中字符串是使用字符数组定义的,三种类型分别对应char,wchar,dchar.char只有一个字节,wchar为双字节,dchar为三字节.对字符串的操作也相当于是对数组的操作,这跟其它语言不一样,C++中字符串是以string类来进行封装,它的

C语言常见字符串操作函数总结

1. bcmp 原型:extern int bcmp(const void *s1, const void *s2, int n); 用法:#include <string.h> 功能:比较字符串s1和s2的前n个字节是否相等说明:相等返回0,否则返回非0值 2. bcopy 原型:extern void bcopy(const void *src, const void *dest, int n); 用法:#include <string.h> 功能:将字符串src的前n个字节

C语言对字符串进行转义excape操作的代码

把做工程过程比较重要的一些内容片段做个珍藏,下面内容内容是关于C语言对字符串进行转义excape操作的内容,希望对大伙有些帮助. { int i = 0, j; while( i < data_len ){ if( '%' != data[i]){ strncat(buf, data+i, 1); i++; continue; } j = 0; while( NULL != transfer_table[j][1] ){ if( 0 == strncasecmp(data+i+1, transf

归纳整理Linux下C语言常用的库函数----内存及字符串控制及操作

在没有IDE的时候,记住一些常用的库函数的函数名.参数.基本用法及注意事项是很有必要的. 参照Linux_C_HS.chm的目录,我大致将常用的函数分为一下几类: 1. 内存及字符串控制及操作 2. 字符串转换 3. 字符测试 4. 文件操作 5. 时间日期 6. 常用数学函数 7. 文件内容操作 8. 文件权限控制 9. 进程操作 10. 线程操作 11. Socket操作 12. 信号处理 13. 数据结构及算法以下是对第一项内存及字符串控制及操作的归纳整理. 已经不赞成使用的函数归类

JS中字符串的相关操作

(转自:http://www.cnblogs.com/zhaoxinxin/articles/1402733.html) 一.字符串的创建创建一个字符串有几种方法. 最简单的是用引号将一组字符包含起来,可以将其赋值给一个字符串变量. var myStr = "Hello, String!"; 可以用双引号或单引号将字符串包含,但要注意,作为界定字符串的一对引号必须是相同的,不能混用. 像var myString = "Fluffy is a pretty cat.'; 这样

C#语言之字符串和正则表达式

本文将完成以下两个目标: 一.创建字符串: 二.正则表达式: 首先,我先来介绍一下System.String类: System.String是一个类,专门用于存储字符串,允许对字符串进行许多操作. 使用运算符重载可以连接字符串: string str1 = "hello"; //return "hello" str1 +=",C#"; //return "hello,C#" string str2 = str1+"!

C语言对mysql数据库的操作

原文:C语言对mysql数据库的操作这已经是一相当老的话题.不过今天我才首次使用,把今天的一些体会写下来,也许能给一些新手带来一定的帮助,更重要的是供自己今后忘记的怎么使用而进行查阅的! 我们言归正传 1．头文件: #include <stdio.h> #include <stdlib.h> #include <mysql/mysql.h> //这个是必需要包含的,下面对mysql的所有操作函数,都出自这里 2.定义一个MYSQL变量: MYSQL mysql: 这里