2. 程式人生 > >基本的字串操作及其實現

基本的字串操作及其實現

阿新 • • 發佈：2019-02-07

本文主要實現基本的字串操作，這些操作大部分都有C API，本文雖然是在重複造輪子，但是，並不是無用功。這些重造的輪子增加了引數判斷，可以讓自己的程式碼更加健壯。

為了簡便且可以說明問題，本文中使用了assert，而沒有使用if判斷。是個缺陷~~~安靜 

需要包含的標頭檔案

#include <stdlib.h>
#include <stdio.h>
#include <assert.h>

字串長度

C原型：

size_t strlen(const char *s);

功能：計算字串長度

返回值：字元個數

注：計算出來的長度，不包括最後的'\0'字元

size_t mystrlen(const char *s)
{
	size_t len = 0;	
	assert(NULL != s);
	while('\0' != *s++)
		++len;
	return len;	
}

 轉換成大寫（小寫）字母

功能：將字串中的字母字元全部轉成大寫或者小寫

返回值：轉換後的字串

注：非字母字元不做任何變化；入參會被改變，改變後的值同返回值

char *mystrtolower(char *s)
{
        char *ps = s;
        assert(NULL != s);
        while('\0' != *ps)
        {
                if('A' <= *ps && 'Z' >=*ps)
                        *ps = *ps - 'A' + 'a';
                ps++;
        }
        return s;
}

char *mystrtoupper(char *s)
{
        char *ps = s;
        assert(NULL != s);
        while('\0' != *ps)
        {
                if('a' <= *ps && 'z' >=*ps)
                        *ps = *ps - 'a' + 'A';
                ps++;
        }
        return s;
}

字串賦值

C原型：

char *strcpy(char *dest, const char *src);

功能：將字串從src複製到dest

返回值：指向dest的指標

說明：dest要有足夠的空間去儲存從src複製來的字元

char *strncpy(char *dest, const char *src, size_t n);

功能：從src複製最多複製n個字元到dest

返回值：指向dest的指標

說明：如果複製的n個字元沒有以'\0'結束，dest也不會以'\0'結束

注：在下面的函式實現中，添加了'\0'結束dest，這一點與C API實現有點不同，且'\0'並不包含n個字元之中

char *mystrcpy(char *dest, const char *src)
{
	char *addr = NULL;
	if(dest == src)
		return dest;
	assert((NULL != dest) && (NULL != src));
	addr = dest;
	while('\0' != (*dest++ = *src++));
	return addr;
}

char *mystrncpy(char *dest, const char *src, size_t n)
{
	char *addr = NULL;
	assert(NULL != dest && NULL != src);
	addr = dest;
	while(n-- && '\0' != *src)
		*dest++ = *src++;
	*dest = '\0';
	return addr;
}

定位給定字元在字串中的位置

C原型：

char *strchr(const char *s, int c);

功能：定位給定字元c在字串s中首次出現的位置

返回值：指向匹配的字元的指標，如果找不到該字元，則返回NULL

char *strrchr(const char *s, int c);

功能：定位給定字元c在字串s中最後一次出現的位置

返回值：指向匹配的字元的指標，如果找不到該字元，則返回NULL

char *mystrchr(const char *s, int c)
{	
	char ch = (char)c;
	assert(NULL != s);	
	for(; ch != *s; ++s)
		if('\0' == *s)
			return NULL;
	return (char *)s;
}

char *mystrrchr(const char *s, int c)
{
	char ch = (char)c;
	const char *st = s;
	assert(NULL != s);
	while('\0' != *st)
		st++;

	for(--st; ch != *st; --st)
		if(st == s)
			return NULL;
	return (char *)st;
}

字串比較

C原型：

int strcmp(const char *s1, const char *s2);

功能：比較兩個給定的字串

返回值：s1==s2返回0；s1<s2,返回負值；s1>s2返回正值

int strncmp(const char *s1, const char *s2, size_t n);

功能：比較兩個給定的字串，最多比較前n個字元

返回值：最多前n個字元，s1==s2返回0；s1<s2,返回負值；s1>s2返回正值

int strcasecmp(const char *s1, const char *s2);

int strncasecmp(const char *s1, const char *s2, size_t n);

說明：功能同上述兩個函式，只是，這兩個函式忽略字母的大小寫

int mystrcmp(const char *s1, const char *s2)
{
	assert(NULL != s1 && NULL != s2);
	while(*s1 && *s2 && *s1 == *s2)
	{
		s1++;
		s2++;
	}
	return (*s1 - *s2);
}

int mystrncmp(const char *s1, const char *s2, size_t n)
{
	assert(NULL != s1 && NULL != s2);
	while(*s1 && *s2 && *s1 == *s2 && n--)
	{
		s1++;
		s2++;
	}
	return (*s1 - *s2);
}

int mystrcasecmp(const char *s1, const char *s2)
{
	char st1, st2;
	assert(NULL != s1 && NULL != s2);
	while(*s1 && *s2)
	{
		st1 = *s1;
		st2 = *s2;
		if('A' <= st1 && 'Z' >= st1)
			st1 = st1 - 'A' + 'a';
		if('A' <= st2 && 'Z' >= st2)
			st2 = st2 - 'A' + 'a';
		if(st1 != st2)
			break;
		s1++;
		s2++;
	}
	return (*s1 - *s2);
}

int mystrncasecmp(const char *s1, const char *s2, size_t n)
{
	char st1, st2;
	assert(NULL != s1 && NULL != s2);
	while(*s1 && *s2 && n--)
	{
		st1 = *s1;
		st2 = *s2;
		if('A' <= st1 && 'Z' >= st1)
			st1 = st1 - 'A' + 'a';
		if('A' <= st2 && 'Z' >= st2)
			st2 = st2 - 'A' + 'a';
		if(st1 != st2 || 0 == n)
			break;
		s1++;
		s2++;
	}
	return (*s1 - *s2);
}

字串拼接

C原型：

char *strcat(char *dest, const char *src);

功能：將src拼接到dest後面

返回值：指向拼接後的dest的指標

說明：dest需要有足夠的空間

char *strncat(char *dest, const char *src, size_t n);

功能：將src的最多前n個字元拼接到dest後面

返回值：指向拼接後的dest的指標

說明：dest需要有足夠的空間，由於總是以'\0'結束，所以，最多向dest寫入n+1個字元

char *mystrcat(char *dest, const char *src)
{
	char *addr = NULL;
	assert(NULL != dest && NULL != src);
	addr = dest;
	while('\0' != *dest)
		dest++;
	while('\0' != (*dest++ = *src++));
	return addr;
}

char *mystrncat(char *dest, const char *src, size_t n)
{
	char *addr = NULL;
	assert(NULL != dest && NULL != src);
	addr = dest;
	while('\0' != *dest)
		dest++;
	while(n-- && '\0' != *src)
		*dest++ = *src++;
	*dest = '\0';
	return addr;
}

查詢字串

C原型：

char *strstr(const char *haystack, const char *needle);

功能：定位給定字串needle在字串s中首次出現的位置

返回值：指向字串的起始位置的的指標，如果找不到該字串，則返回NULL

說明：在Linux libc起初版本中，needle不能為空，但從4.6.27版本開始，needle為空時，返回haystack

#define _GNU_SOURCE

char *strcasestr(const char *haystack, const char *needle);

功能：定位給定字串needle在字串s中首次出現的位置，查詢時忽略字元的大小寫

返回值：指向字串的起始位置的的指標，如果找不到該字串，則返回NULL

說明：The strcasestr() function is a non-standard extension.strcasestr不是非標準擴充套件，用到該函式時，需要定義巨集_GNU_SOURCE

char * mystrstr(const char *haystack, const char *needle)
{
        const char *s = NULL;
        const char *t = NULL;
        assert(NULL != haystack && NULL != needle);
        for(; *haystack != '\0'; haystack++)
        {
                for(s = haystack, t = needle; *t != '\0' && *s != '\0'; ++s, ++t)
                {
                        if(*t != *s)
                                break;
                }
                if('\0' == *t)
                        return (char *)haystack;
        }
        return NULL;
}

char * mystrcasestr(const char *haystack, const char *needle)
{
        const char *s = NULL;
        const char *t = NULL;
        char cs, ts;
        assert(NULL != haystack && NULL != needle);
        for(; *haystack != '\0'; haystack++)
        {
                for(s = haystack, t = needle; *t != '\0' && *s != '\0'; ++s, ++t)
                {
                        cs = *s;
                        ts = *t;
                        if('A' <= cs && 'Z' >= cs)
                                cs = cs - 'A' + 'a';
                        if('A' <= ts && 'Z' >= ts)
                                ts = ts - 'A' + 'a';
                        if(cs != ts)
                                break;
                }
                if('\0' == *t)
                        return (char *)haystack;
        }
        return NULL;
}

複製字串

C原型

char *strdup(const char *s);

功能：複製一個字串

返回值：複製後，新的字串的起始地址的指標

說明：內部以malloc分配空間，呼叫者需要呼叫free釋放，以防記憶體洩露

#define _GNU_SOURCE

char *strndup(const char *s, size_t n);

功能：複製最多n個字元到新的字串

返回值：複製後，新的字串的起始地址的指標

說明：複製後的新字串會被加上'\0'以結尾；該字元串同樣需要free釋放

注：strndp不是非標準擴充套件，用到該函式時，需要定義巨集_GNU_SOURCE

char *mystrdup(const char *s)
{
        size_t len = 0;
        const char *start = NULL;
        char *addr = NULL;
        if(NULL == s)
                return NULL;
        while(*s++ != '\0')
                len++;
        addr = (char *)malloc(len + 1);
        assert(NULL != addr);
        start = s;
        while((*addr++ = *start++) != '\0');
        return addr - (len + 1);
}

char *mystrndup(const char *s, size_t n)
{
        size_t len = 0;
        const char *start = NULL;
        char *addr = NULL;
        if(NULL == s)
                return NULL;
        while(*s++ != '\0')
                len++;
        if(len > n)
                len = n;
        addr = (char *)malloc(len + 1);
        assert(NULL != addr);
        n++;
        start = s;
        while(n-- && (*addr++ = *start++) != '\0');
        *(addr-1) = '\0';
        return addr - (len + 1);
}

多字元搜尋

C原型：

size_t strspn(const char *s, const char *accept);

功能：從引數s 字串的開頭計算連續的字元，而這些字元都完全是accept 所指字串中的字元。簡單的說，若strspn()返回的數值為n，則代表字串s 開頭連續有n 個字元都是屬於字串accept內的字元。

返回值：返回字串s開頭連續包含字串accept內的字元數目

size_t strcspn(const char *s, const char *reject); 

功能：從引數s字串的開頭計算連續的字元，而這些字元都完全不在引數reject 所指的字串中。簡單地說，若strcspn()返回的數值為n，則代表字串s開頭連續有n個字元都不含字串reject內的字元。

返回值：返回字串s開頭連續不含字串reject內的字元數目

size_t mystrspn(const char *s, const char *accept)
{
        const char *st = NULL;
        const char *at = NULL;
        assert(NULL != s && NULL != accept);
        for(st = s; *st != '\0'; st ++)
        {
                for(at = accept; *at != '\0'; at++)
                {
                        if(*st == *at)
                                break;
                }
                if(*at == '\0')
                        return st - s;
        }
        return st - s;
}

size_t mystrcspn(const char *s, const char *reject)
{
        const char *st = NULL;
        const char *at = NULL;
        assert(NULL != s && NULL != reject);
        for(st = s; *st != '\0'; st++)
                for(at = reject; *at != '\0'; at++)
                        if(*st == *at)
                                return st - s;
        return st - s;
}

搜尋多個字元中的第一個字元

C原型：

char *strpbrk(const char *s, const char *accept);

功能：找出引數s 字串中最先出現存在引數accept 字串中的任意字元

返回值：指向找到的字元的位置，找不到則返回NULL

char *mystrpbrk(const char *s, const char *accept)
{
        const char *st = NULL,*at = NULL;
        assert(NULL != s && NULL != accept);
        for(st = s; *st != '\0'; st++)
                for(at = accept; *at != '\0'; at++)
                        if(*st == *at)
                                return (char *)st;
        return NULL;
}

根據分隔符提取字串

C原型：

char *strtok(char *str, const char *delim);

功能：strtok()用來將字串分割成一個個片段。引數s指向欲分割的字串，引數delim則為分割字串中包含的所有字元。當strtok()在引數s的字串中發現引數delim中包含的分割字元時,則會將該字元改為\0 字元。在第一次呼叫時，strtok()必需給予引數s字串，往後的呼叫則將引數s設定成NULL。

返回值：每次呼叫成功則返回指向被分割出片段的指標，如果不再含有delim，則返回NULL

說明：strtok用static變數儲存上次的分割位置，所以，不是執行緒安全的。

注：strtok函式會破壞被分解字串的完整，呼叫前和呼叫後的s已經不一樣了。

char *strtok_r(char *str, const char *delim, char **saveptr);

功能：同strtok，只是該函式是執行緒安全的。

說明：用*saveptr來儲存上次的分割位置，代替了strtok的靜態變數缺陷

char *strsep(char **stringp, const char *delim);

功能：同strtok

說明：如果*stringgp為NULL，則直接返回NULL；而strtok不允許str為NULL

注：strtok的替代函式，它可以接受空串；但strtok具有更好的可移植性

char *mystrtok(char *str, const char *delim)
{
        assert(delim != NULL);
        static char *last;
        char *s = NULL;
        const char *t = NULL;
        if ( NULL == str  && NULL == (str = last))
                return NULL;
        for( s = str ; *s != '\0'; s++)
                for(t = delim; *t != '\0'; t++)
                        if(*s == *t)
                        {
                                last = s + 1;
                                if (s - str == 0)
                                {
                                        str = last;
                                        break;
                                }
                                *(str + (s - str)) = '\0';
                                return str;
                        }
        return NULL;
}

char *mystrtok_r(char *s, const char *delim, char **save_ptr) {
        char *token;
        if (NULL == s)
                s = *save_ptr;
        s += mystrspn(s, delim);
        if (*s == '\0')
                return NULL;
        token = s;
        s = mystrpbrk(token, delim);
        if (NULL == s)
                *save_ptr = mystrchr(token, '\0');
        else {
                *s = '\0';
                *save_ptr = s + 1;
        }
        return token;
}

char *mystrtok2(char *str, const char *delim)
{
        static char * save;
        return mystrtok_r(str, delim,&save);
}

char *mystrsep(char **stringp, const char *delim)
{
        char *sbp = *stringp, *end;
        if(NULL == sbp)
                return NULL;
        end = mystrpbrk(sbp, delim);
        if(NULL != end)
                *end++ = '\0';
        *stringp = end;
        return sbp;
}

由於分割字串不太好理解，附上測試程式：

另外，為了執行下面的測試程式，需要自己新增上所需要的本博文上述實現的函式。

#include <string.h>

void systok()
{
	char str[] ="This is a sample string,just testing.";
	char * pch;
	printf ("Splitting string \"%s\" in tokens:\n",str);
	pch = strtok (str," ");
	while (pch != NULL)
	{
		printf ("%s\n",pch);
		pch = strtok (NULL, " ,.");
	}
}

void mytok()
{
	char str[] ="This is a sample string,just testing.";
	char * pch;
	printf ("Splitting string \"%s\" in tokens:\n",str);
	pch = mystrtok (str," ");
	while (pch != NULL)
	{
		printf ("%s\n",pch);
		pch = mystrtok (NULL, " ,.");
	}
}

void systok_r()
{
	int in=0,j;
	char buffer[]="Fred male 25,John male 62,Anna female 16";
	char *p[20];
	char *buf=buffer;
	char *outer_ptr=NULL;
	char *inner_ptr=NULL;
	while((p[in] = strtok_r(buf, ",", &outer_ptr))!=NULL) 
	{
		buf=p[in];
		while((p[in]=strtok_r(buf, " ", &inner_ptr))!=NULL) 
		{
			in++;
			buf=NULL;
		}
		buf=NULL;
	}
	printf("Here we have %d strings\n",in);
	for (j=0; j<in; j++)
	{	
		printf("%s\n",p[j]);
	}
}

void mytok_r()
{
	int in=0,j;
	char buffer[]="Fred male 25,John male 62,Anna female 16";
	char *p[20];
	char *buf=buffer;
	char *outer_ptr=NULL;
	char *inner_ptr=NULL;
	while((p[in] = mystrtok_r(buf, ",", &outer_ptr))!=NULL)
	{
		buf=p[in];
		while((p[in]=mystrtok_r(buf, " ", &inner_ptr))!=NULL)
		{
			in++;
			buf=NULL;
		}
		buf=NULL;
	}
	printf("Here we have %d strings\n",in);
	for (j=0; j<in; j++)
	{
		printf("%s\n",p[j]);
	}
}

int main()
{
	systok();
	printf("=============================================\n");
	mytok();
	printf("=============================================\n");
	systok_r();
	printf("=============================================\n");
	mytok_r();
}

相關推薦

基本的字串操作及其實現

本文主要實現基本的字串操作，這些操作大部分都有C API，本文雖然是在重複造輪子，但是，並不是無用功。這些重造的輪子增加了引數判斷，可以讓自己的程式碼更加健壯。 為了簡便且可以說明問題，本文中使用了assert，而沒有使用if判斷。是個缺陷~~~  需要包含的標頭檔案 #i

連結串列，順序表的基本操作及其實現的棧與佇列

1，順序表 在c裡面，這一部分也就是靜態表和動態表的實現，插入，刪除有丁點意思。 靜態表靠陣列和長度實現（注意長度這一點，因為它反映了當前表內容長度，十分重要） 動態表依靠申請連續空間實現（結構體內部包括首地址，當前規模以及長度） 插入： int *p; p=&

字串操作函式實現

1、Strcat函式 char *strcat(char *strDest, const char *strScr) //將源字串加const，表明其為輸入引數 { char * address = strDest; //該語句若

基本字串壓縮Java實現

利用字元重複出現的次數，編寫一個方法，實現基本的字串壓縮功能。比如，字串“aabcccccaaa”經壓縮會變成“a2b1c5a3”。若壓縮後的字串沒有變短，則返回原先的字串。 給定一個str

【學習筆記】堆的定義及其建立、排序等基本操作的實現

目錄 堆的定義： 堆的基本操作的程式碼實現： 詳情請參見《演算法筆記》P335，此處只做簡單的學習筆記記錄。   堆的定義： 堆是一棵完全二叉樹，樹中的每個結點的值都不小於（或不大於）其左右孩子結點。 堆一般用於優先佇列的實現（目前不是很懂），故預設

單鏈表及其基本操作的實現

請在以下給出的部分源程式基礎上補全程式碼，完成單鏈表的C語言程式。然後再主函式通過呼叫單鏈表的操作中完成一下任務：首先定義一個單鏈表例項（變數），並初始化，採用尾插法向其中錄入10個整數（ElemType為int型別）；然後，在第5個結點處插入一個新結點（值為5），再把第8

T：B數的表示及其基本操作的實現（C++）

習題內容： 1．掌握B樹的存貯結構。 2．實現B樹中關鍵字值的插入及刪除操作。   B樹的定義： B樹也稱B-樹，它是一顆多路平衡查詢樹。我們描述一顆B樹時需要指定它的階數，階數表示了一個結點最多有多少個孩子結點，一般用字母M表示階數。當M取2時，就是我們常見的二叉搜尋

順序表基本操作的實現

oid new for fine h+ 基本 delet 輸出 turn 順序表基本操作的實現，主要包括順序表的初始化、建立、輸出、插入、刪除、位置查詢、數據查詢。 #include<iostream.h>#define MAXSIZE 100typedef i

線性表基本操作的實現（合並）

typedef real 不變 names base ++ 元素 一個 修改元素 //實現順序表的建立、初始化、插入、刪除、修改、普通合並、有序合並 #include<iostream> #include<stdio.h> #include<

LRU基本介紹及其實現方式

fifo隊列 ride ati implement 建立 復雜 介紹 .get util 原文地址： http://note.youdao.com/noteshare?id=1abbeb1deee85f0203001e9bc34f65b4 參考 LRU算法 dubbo-c

線性表順序存儲結構的基本操作的實現

spa 基本操作 clu include 移動 麻煩 線性表 del ++ 線性表順序存儲結構的優點 易於隨機存取任意一個元素 線性表順序存儲結構的缺點 插入和刪除需要移動大量的元素，很麻煩 代碼實現 #include<bits/stdc++.h> using

利用切片操作，實現一個trim()函式，去除字串首尾的空格，注意不要呼叫str的strip()方法：# 測試: if trim('hello ') != 'hello': print('測試失敗!') elif trim(' hello'

def trim(s): k = 0 '''while迴圈判斷輸入字串是否為空值''' while k < len(s): if s[k] == ' ': #如果是空字元則記錄字元的個數 k = k + 1 #k自增來記錄數值

連結串列及其操作的實現

#include <iostream> #include <cstdio> #include <stdlib.h> using namespace std; typedef char ElemType; typedef struct LNode {

動態順序表的基本操作的實現

順序表是用一段實體地址連續的儲存單元依次儲存資料元素的線性結構，一般情況下采用陣列儲存。在陣列上完成資料的增刪查改。 順序表一般可以分為： 靜態順序表：使用定長陣列儲存。 動態順序表：使用動態開闢的陣列儲存。 SeqList.h #ifndef __SeqLi

【學習筆記】平衡二叉樹（AVL樹）簡介及其查詢、插入、建立操作的實現

  目錄 平衡二叉樹簡介： 各種操作實現程式碼：   詳細內容請參見《演算法筆記》P319 初始AVL樹，一知半解，目前不是很懂要如何應用，特記錄下重要內容，以供今後review。   平衡二叉樹簡介： 平衡二叉樹由兩位前

循環隊列基本操作的實現

over def iostream *** 當前 打印 ini char 1-1 2018-11-13-17:53:44 1.可增長循環隊列 　　　　隊列是一種特殊的線性表，是一種先進先出（FIFO）的數據結構。它只允許在表的前端（front）進行刪除操作，而在表的後端

線索二叉樹和二叉樹基本操作的實現

2018-11-18-18:25:23 一：二叉樹 1.二叉樹的性質 　　①：在二叉樹的第i層上至多有pow(2,i-1)個結點(i>=1)。 　　②：深度為k的二叉樹至多有pow(2,k)-1個結點(k>=1)。 　　③：對任何一顆二叉樹T,如果其終端結點的個數為n0，度為2的結點數為

利用切片操作，實現一個trim()函式，去除字串首尾的空格，注意不要呼叫str的strip()方法：

1，首先判斷字串是否是空，如果是直接返回字串； 2，迴圈判斷字串從第一個開始是否是空格，如果是則去掉空格，每次去掉空格後判斷剩下的是否是空，如果是返回字串 3，迴圈判斷字串從最後一個開始往前是否是空格，如果是則去掉空格，每次去掉空格後判斷剩下的是否是空，如果是返回字串 4，空格都去掉後返

js中的string型別與number型別的轉換以及字串的基本常見操作

<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta name="viewport" content="width=device-width, i

棧和佇列的基本操作的實現

1. 實驗目的 熟練掌握棧和佇列的抽象資料型別，能在相應的應用問題中正確選用它們，熟練掌握棧和佇列的實現方法（順序和鏈式），兩種儲存結構和基本操作的實現演算法，注意空和滿的判斷條件及它們的描述方法，掌握迴圈佇列與其它順序結構實現上的不同及解決辦法，熟悉各種佇列的基本操作在迴圈佇列上的實現