字符串函數

長度不受限制的字符串函數

strlen

size_t strlen ( const char * str )

求字符串長度：

字符串以'\0' 作為結束標志，strlen函數返回的是在字符串中 '\0' 前面出現的字符個數(不包含 '\0' )

參數指向的字符串必須要以 '\0' 結束

注意函數的返回值為size_t，是無符號的

例子如下：計算Hello World! 的字符數

strcpy

char* strcpy(char * destination, const char * source )

用法：將 source 指向的 C 字符串復制到 destination 指向的數組中，包括終止空字符（并在該點停止）

注意:

源字符串必須以 '\0' 結束。

會將源字符串中的 '\0' 拷貝到目標空間。

目標空間必須足夠大，以確保能存放源字符串。

目標空間必須可變

strcpy的實現：

char * strcpy(char *dest, const char*src)
{ 
 char *ret = dest;//記錄下字符串dest的起始地址
 assert(dest != NULL);
 assert(src != NULL);
 while((*dest++ = *src++))//copy
 {
  ;
 }
 return ret;//返回起始地址
}

strcat

char * strcat ( char * destination, const char * source )

用法：將源字符串的副本附加到目標字符串。也就是將src字符串接在dest的字符串后面，并且src字符串的第一個字符覆蓋dest的最后一個字符（\0），并且在接好的字符串后加上'\0'

注意：

源字符串必須以 '\0' 結束。

目標空間必須有足夠的大，能容納下源字符串的內容。

目標空間必須可修改。

strcat的實現：

char * strcat(char *dest, const char*src)
{
 char *ret = dest;
 assert(dest != NULL);
 assert(src != NULL);
//找到目標空間
 while(*dest)
 {
  dest++;
 }
//拷貝
 while((*dest++ = *src++))
 {
  ;
 }
 return ret;
}

strcmp

int strcmp ( const char * str1, const char * str2 )

用法：此函數開始比較每個字符串的第一個字符。如果它們等于每個其他，它會繼續以下對，直到字符不同或終止達到空字符。

注意：

第一個字符串大于第二個字符串，則返回大于0的數字

第一個字符串等于第二個字符串，則返回0

第一個字符串小于第二個字符串，則返回小于0的數字

strcmp的實現：

?int strcmp(const char* st1, const char* st2)
{
	int ret = 0;
	while (*st1 == *st2)
	{
		st1++;
		st2++;
		if(*st1 == *st2 && *st1 == '\0')
			return ret;//相等的時候返回0
	}
	return *st1 - *st2;

長度受限制的字符串函數介紹

strncpy

拷貝num個字符從源字符串到目標空間。

如果源字符串的長度小于num，則拷貝完源字符串之后，在目標的后邊追加0，直到num個。

strncat

將源的前 num 個字符附加到目標，加上一個終止空字符。

如果 source 中 C 字符串的長度小于 num，則只有到終止符的內容空字符被復制

strncmp

比較到出現另個字符不一樣或者一個字符串結束或者num個字符全部比較完。

字符串查找以及錯誤報告

strstr

char * strstr ( const char *str1, const char * str2)

返回指向 str1 中第一次出現 str2 的指針，如果 str2 不屬于字符串str1就返回空指針

strstr的實現：

char* strstr(const char* st1, const char* st2)
{
	//st1,st2標注起始位置
	char* s1 = st1;
	char* s2 = st2;
	char* cur = s1;
	while (*cur)
	{
		s1 = cur;
		while (*s1 == *s2 && *s1 && *s2)
		{
			s1++;
			s2++;
		}
		if (*s2 == '\0')
		{
			return cur;
		}
		cur++;
	}
	return NULL;//找不到
}

strtok

用法：根據給出的字符將字符串分隔開

char * strtok ( char * str, const char * sep )

sep參數是個字符串，定義了用作分隔符的字符集合

第一個參數指定一個字符串，它包含了0個或者多個由sep字符串中一個或者多個分隔符分割的標

記strtok函數找到str中的下一個標記，并將其用 \0 結尾，返回一個指向這個標記的指針。（注：

strtok函數會改變被操作的字符串，所以在使用strtok函數切分的字符串一般都是臨時拷貝的內容

并且可修改。）

strtok函數的第一個參數不為 NULL ，函數將找到str中第一個標記，strtok函數將保存它在字符串

中的位置。

strtok函數的第一個參數為 NULL ，函數將在同一個字符串中被保存的位置開始，查找下一個標

記。

如果字符串中不存在更多的標記，則返回 NULL 指針

這里演示一下：

strerror

char * strerror ( int errnum )

返回錯誤碼，所對應的錯誤信息

這里頭文件為#include<errno.h>

演示如下；

內存操作函數

memcpy

void * memcpy ( void * destination, const void * source, size_t num )

用法：函數memcpy從source的位置開始向后復制num個字節的數據到destination的內存位置。

這個函數在遇到 '\0' 的時候并不會停下來。

如果source和destination有任何的重疊，復制的結果都是未定義的。

memcpy的實現：

?void* memcpy(void* dest, const void* src, size_t sz)
{
	assert(dest && src);
	void* ret = dest;
	int count = sz;
	while (count--)
	{
		*(char*)dest = *(char*)src;//拷貝
		dest = (char*)dest + 1;
		src = (char*)src + 1;
	}
	return ret;
}

memmove

void * memmove ( void * destination, const void * source, size_t num )

用法：和memcpy的用法差不多，和memcpy的差別就是memmove函數處理的源內存塊和目標內存塊是可以重疊的。

如果源空間和目標空間出現重疊，就得使用memmove函數處理

memmove的實現：

void* memmove(void* dest, const void* src, size_t sz)
{
	assert(dest && src);//斷言
	int* ret = dest;
	int count = sz;
	if (*(char*)dest > *(char*)src && *(char*)dest < *(char*)src + count)
	{
		//后->前
		while (count--)
		{
			*((char*)dest + count) = *(char*)src + count;
		}
	}
	else
	{
		//前->后
		while (count--)
		{
			*(char*)dest = *(char*)src;
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}
	}
	return ret;
}

memcmp

int memcmp ( const void * ptr1,const void * ptr2,size_t num )

用法：比較從ptr1和ptr2指針開始的num個字節

返回值：