C語言中常見的字符函數和字符串函數

1.求字符串的長度

strlen函數：
1.函數介紹
size_t strlen (const char * str);

• 字符串已經’\0’作爲結束標誌，strlen函數返回的是在字符串中’\0’前面出現的字符個數（不包含’0’）；
• 參數指向的字符串必須要以’\0’結束
• 注意函數的返回值爲size_t，是無符號的
• 模擬實現

//strlen函數的模擬實現
#include<iostream>
//方法1：計數器實現的方式
int my_strlen1(const char * str)
{
	int count = 0;
	while(*str)
	{
		count++;
		str++;
	}
	return count;
}
//遞歸--不創建臨時的計數器
int my_strlen2(const char * str)
{
	if(*str == '\0')
		return 0;
	else
		return 1 + my_strlen(str + 1);
}
//指針 - 指針的方式
int my_strlen3(char * str)
{
	char * p = str;
	while(*p != '\0')
	{
		p++;
	}
	return str - s;
}
int main()
{
	return 0;
}

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

1.strcpy字符串拷貝

size_t strlen(const char * str);

• 原字符串必須以’\0’結束。
• 會將原字符串中的’\0’拷貝到目標字符串中
• 目標空間必須足夠大，以確保能放下字符串
• 目標空間必須可變
• 模擬實現

//字符串拷貝的時候會覆蓋原來的字符串
#include<iostream>
char * my_strcpy(char * dest, const char * src)
{
	if(dest == nullptr || src == nullptr)
		return nullptr;
	char * ret = dest;
	while((*dest)++ = (*src++))
	{
		;
	}
	return ret;
}
int main()
{
	char arr1[10] = "abcdef";
	char arr2[10] = "253";
	printf("%s\n",my_strcpy(arr2,arr1));
	return 0;
}

2.strcat字符串連接

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

• 原字符串必須以’\0’結束
• 目標空間必須有足夠大的空間，能容納下原字符串的內容
• 目標空間必須可修改
• 模擬實現

#include<iostream>
char * my_strcpy(char * dest, const char * src)
{
	if(dest == nullptr || src == nullptr)
		return nullptr;
	char * ret = dest;
	while(*dest)
	{
		dest++;
	}
	while(*(dest++) = *(src++))
	{
		;
	}
	return ret;
}
int main()
{
	char arr1[10] = "abcdef";
	char arr2[10] = "253";
	printf("%s\n",my_strcpy(arr1,arr2));
	return 0;
}

3.strcmp比較兩個字符串的大小

int strcmp ( char * destination , const char * source);

• 第一個字符串大於第二個字符串，則返回大於0的數字
• 第一個字符串等於第二個字符串，則返回0
• 第一個字符串小於第二個字符串，則返回大於0的數字

int my_strcmp(const char * str1 , const char * str2)
{
	if(str1 == nullptr || str2 == nullptr)
		return -2;
	while(*str1 == *str2)
	{
		if(*str1 == '\0')
		{
			return 0;
		}
		str1++;
		str2++;
	}
	int ret = *str1 - *str2;
	if ( ret < 0 )  
	      ret = -1 ;
	else if ( ret > 0 )
	      ret = 1 ;
	return ret;
}
int main()
{
	int ret = my_strcmp("abca","abc");
	printf("%d",ret); 
	system("pause");
	return 0;
}

三.長度受限制的字符串函數

1.strncpy

char * strncpy(char * destination , const char * source , size_t num);

• 拷貝num個字符從源字符串到目標字符串
• 如果原字符串的長度小於num，則拷貝完源字符串之後，在目標的後面追加上0，直到num個。

char * my_strncpy(char * dest , char * src , int count)
{
	char * ret = dest;
	while(count && (*dest++ = *src++))
	{
		count--;
	}
	if(count)
	{
		while(count)
		{
			*dest == '\0';
		}
	}
	return ret;
}
int main()
{
	char arr[20] = "abcdefg";
	std::cout << my_stncpy(arr,"hello", 3);
	system("pause");
	return 0;
}

2.strnat

char * strncat ( char * destination, const char * source, size_t num );

• 把src所指字符串的前n個字符添加到dest結尾處（覆蓋dest結尾處的’\0’）並添加’\0’

char * my_strncat(char * dest , const char * src , int count)
{
	char * ret = dest;
	while(*dest != '\0')
	{
		dest++;
	}
	while(count-- && (*dest++ = *src++))
	{
		;
	}
	return ret;
}
int main()
{
	char str[20] = "hello ";
	std::cout << my_strncat(str,"world 1234" , 5);
	system("pause");
	return 0;
}

3.strncmp

int strncmp ( const char * str1, const char * str2, size_t num );

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

int my_strncmp(const char* dest , const char * src ,int count)
{
	if(dest == nullptr || src == nullptr)
		return -2;
	while(count-- && (*dest == *src))
	{
		if(*dest == '\0')
		{
			return 0;
		}
		dest++;
		src++;
	}
	int ret = *dest - *src;
	if (ret < 0)
		ret = -1;
	else if (ret > 0)
		ret = 1;
	return ret;
}
int main()
{
	char str[20] = "abcdefg";
	std::cout << my_strcnmp(str,"hello",5);
	system("pause");
	
}

四.字符串查找

1.strstr查找字符串

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

char * my_strstr(const char* str1,const char * str2)
{
	if(str1 == nullptr || str2 == nullptr)
		return nullptr;
	const char * s1 = str1;
	const char * s2 = str2;
	const char * cp = s1;
	while(cp)
	{
		s1 = cp;
		s2 = str2;
		while(*s1 && *s2 && *s1 == *s2)
		{
			s1++;
			s2++;
		}
		if(*s2 == '\0')
			return (char *)cp;
		
		cp++;
	}
	return nullptr;
}

int main()
{
	char * str1 = "ccdaaac";
	char * str2 = "aac";
	std::cout << my_strstr(str1,str2) << std::endl;
	system("pause");
	return 0;
}

2.strtok分解字符串

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

• sep參數是一個字符串，定義了用做分隔符的函數集合。
• 第一個參數指定一個字符串，它包含了0個或者多個由sep字符串中一個或者多個分割符分割的標記。
• strtok哈桑農戶找到str中的下一個標記，並將其用’\0’結尾，返回一個指向這個標記的指針。
• strtok函數的第一個參數不爲Null，哈桑農戶將找到str中的第一個標記，strtok函數將保存它在字符串中的位置
• strtok函數的第一個參數爲Null，函數將在同一個字符串中被保存的位置開始，查找下一個標記。
• 如果字符串不存在更多的標記，則返回空指針。

五.內存操作函數

1.memcpy

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

• 函數memcpy從source的位置開始向後複製num個字節的數據到destination的內存位置。
• 這個函數在遇到’\0’的時候並不會停下來。
• 如果source和destination有任何的重疊，複製的結果都是未定義的

void * my_memcpy(void * dest, const void * src, size_t count)
{
	void * ret = dest;
	while (count--)
	{
		*(char *)dest = *(char *)src;
		dest = (char *)dest + 1;
		src = (char *)src + 1;
	}
	return ret;
}
int main()
{
	int str1[] = { 1, 2, 3, 4, 5, 6 };
	int str2[20] = { 0 };
	std::cout << my_memcpy(str2, str1, 12);
	system("pause");
	return 0;
}

2.memove

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

• 和memcpy（）的差別就是memmove函數處理的源內存塊和目標內存塊是可以重疊的
• 如果源空間和目標空間出現重疊，就得使用memmove函數處理

void* my_memmove(void* dest,void* src,int count)
{
	if(dest == nullptr || src == nullptr)
		return;
	void* ret = dest;
    if(dest<src)
    {
		while(count--)
	   {
		   *((char*) dest) =*((char*) src);
		   dest = (char*)dest + 1;
		   src = (char*)src + 1;
	    }
	}
	else
	{
		while(count--)
		{
			*((char*) dest+count) = *((char*) src+count);
		}
	}
	return ret;
}
int main()
{
	int arr1[] = {1,2,3,4,5,6,7};
	my_memmove(arr1,arr1+2,16);
	system("pause");
	return 0;
}