一.字串函式

1.strlen

strlen函式是求字串長度的函式，里面傳的是地址，函式回傳的是‘\0’前面出現的字符的個數，是無符號整形（注意：如果回傳值是一個負數，會自動將其轉換成正數，也就是將負數的補碼直接看做原碼輸出）
strlen函式的使用

#include<stdio.h>
#include<string.h>
int main()
{
	char arr[] = "abc";
	int len = strlen(arr);
	printf("%d\n", len);
	return 0;
}

strlen函式的模擬實作

計數器方式實作：

int my_strlen(char*str)
{
	assert(str != NULL);
	int count = 0;
	while (*str != '\0')
	{
		str++;
		count++;
	}
	return count;
}
int main()
{
	char arr[] = "abc";
	int len = my_strlen(arr);
	printf("%d\n", len);
	return 0;
}

遞回方式實作：

int my_strlen(char*str)
{
    assert(str != NULL);
	if (*str != '\0')
		return 1 + my_strlen(str + 1);
	else
		return 0;
}
int main()
{
	char arr[] = "abc";
	int len = my_strlen(arr);
	printf("%d\n", len);
	return 0;
}

指標-指標方式實作：

#include<stdio.h>
#include<string.h>
#include<assert.h>
int my_strlen(const char*str)
{
	assert(str != NULL);
	const char*start = str;
	while (*str)
	{
		str++;
	}
	return str - start;
}
int main()
{
	char arr[] = "abc";
	int len = my_strlen(arr);
	printf("%d\n", len);
	return 0;
}

2.strcpy

字串拷貝函式：
1.源字串必須有’\0’，且會將’\0’拷貝到目標字串，
2.目標空間必須足夠大且可變，
strcpy函式的使用

int main()
{
	char arr1[] = "*********";
	char arr2[] = "ni hao";
	strcpy(arr1, arr2);
	printf("%s\n", arr1);
	return 0;
}

strcpy函式的模擬實作

char* my_strcpy(char* dest, const char* src)
{
	assert(dest && src);
	char*ret = dest;
	while (*dest++ = *src++)//拷貝字串，包括'\0'
	{
		;
	}
	return ret;//回傳的目標空間的起始地址
}

int main()
{
	char arr1[20] = "*************";
	char arr2[] = "hello world";

	my_strcpy(arr1, arr2);
	printf("%s\n", arr1);//
	return 0;
}

3.strcat

strcat函式（字串追加函式）：把源字串的內容追加到目標空間的后面，
1.源字串必須以’\0’結束，
2.目標空間必須足夠大且可以被修改，同時目標空間里必須也要有\0，因為要從目標空間的’\0’處開始追加，
3.不能自己給自己追加，因為會修改掉’\0’，使得字串沒有終止條件了
strcat函式的使用

int main()
{
	char arr1[20] = "hello ";//目標空間必須足夠大
	char arr2[] = "world";
	strcat(arr1, arr2);
	printf("%s\n", arr1);
	return 0;
}

strcat函式的模擬實作

char* my_strcat(char*dest, const char*src)
{
	assert(dest && src);
	char*ret = dest;
	//1. 找到目標空間的\0
	while (*dest)
	{
		dest++;
	}
	//2. 追加
	while (*dest++ = *src++)
	{
		;
	}
	return ret;
}

int main()
{
	char arr1[20] = "hello ";
	char arr2[] = "world";

	printf("%s\n", my_strcat(arr1, arr2));

	return 0;
}

4.strcmp

strcmp（字串比較函式）：
不是比較字串的長度，而是比較字串中對應字符的ASCII碼值，當有一個字串的某個字符的ASCII碼值大于另一個字串對應字符的ASCII碼值時，則該字串大于另一個字串，回傳一個大于0的數字，
strcmp函式的使用

int main()
{
	int ret = strcmp("abc", "abcdef");
	printf("%d\n", ret);
	return 0;
	//列印的結果是一個小于0的數字
}

strcmp函式的模擬實作

int my_strcmp(const char*s1, const char*s2)
{
	assert(s1 && s2);
	while (*s1 == *s2)
	{
		if (*s1 == '\0')
			return 0;
		s1++;
		s2++;
	}
	return *s1 - *s2;
}

int main()
{
	int ret = my_strcmp("abq", "abcdef");
	printf("%d\n", ret);
	return 0;
}

5.strncpy

1.和strcpy函式類似，但是strcnpy函式可以拷貝具體的字符個數，以避免strcpy拷貝字符多了而目標空間存不下系統報錯，
2.如果源字串的長度小于num，則拷貝完源字串之后，在目標的后邊追加0，直到num個，

6.strncat

和strcat函式類似，但區別在于strncat函式可以追加具體的字符個數，且追加相應的字符個數后會在后面自動補上’\0’（如果追加的長度多于一個字串的長度時，會將該字串全部追加完并且在后面補上’\0’），

7.strncmp

和strcmp函式相似，但strncmp函式可以比較具體的字符個數，

8.strstr

strstr函式，作用為在一個字串中尋找另外一個字串第一次出現的位置，回傳的是地址，如果找不到的話，則會回傳空指標，
strstr函式的使用

int main()
{
	char arr1[] = "abcdefgbcd";
	char arr2[] = "bcd";
	char*ret = strstr(arr1, arr2);
	if (ret != NULL)
		printf("%s\n", ret);
	else
		printf("找不到\n");
	return 0;
}

strstr函式的模擬實作

char* my_strstr(const char*s1, const char*s2)
{
	assert(s1 && s2);
	const char *cp = s1;

	if (*s2 == '\0')
		return (char*)s1;

	while (*cp)
	{
		const char *p1 = cp;
		const char *p2 = s2;//給p1，p2都加上const讓兩邊型別保持一致
		while ((*p1!='\0') && (*p2!='\0') &&  (*p1 == *p2))
		{
			p1++;
			p2++;
		}
		if (*p2 == '\0')
		{
			return (char*)cp;
		}
		cp++;
	}
	return NULL;
}
	
int main()
{
	char arr1[] = "abcdef";
	char arr2[] = "defq";

	char*ret = my_strstr(arr1, arr2);//在arr1中查找arr2字串第一次出現的位置
	if (ret != NULL)
		printf("%s\n", ret);
	else
		printf("找不到子串\n");

	return 0;
}

9.strtok

1.strtok函式會在字串中尋找標記（分隔符），并將這個標記改成’\0’，然后回傳起始位置，
2.strtok函式會改變被操作的字串，所以在使用strtok函式切分的字串一般都是臨時拷貝的內容并且可修改，
3.strtok函式的第一個引數不為 NULL ，函式將找到str中第一個標記，strtok函式將保存它在字串中的位置，
strtok函式的第一個引數為 NULL ，函式將在同一個字串中被保存的位置開始，查找下一個標記，
如果字串中不存在更多的標記，則回傳 NULL 指標，
4.從尋找第二個標記開始呼叫strtok函式時傳的第一個引數應該為空指標，

int main()
{
	char arr[] = "abc@1234.vip.haha";//@. 分割符
	char arr2[30] = { 0 };
	strcpy(arr2, arr);
	char*p = ".@";
	char *ret = NULL;
	for (ret = strtok(arr2, p); ret != NULL; ret = strtok(NULL, p))
	{
		printf("%s\n", ret);
	}
	return 0;
}

10.strerror

strerror（錯誤報告函式），當庫函式使用時發生錯誤時，回傳錯誤碼，把錯誤碼轉換成對應的錯誤資訊，回傳錯誤資訊對應字串的起始地址，

char *strerror( int errnum );

二.字符函式

字符轉換函式
int tolower ( int c )：轉換為小寫
int toupper ( int c )：轉換為大寫

三.記憶體操作函式

記憶體操作函式可以用于操作陣列

1.memcpy

1.函式memcpy從source的位置開始向后復制num個位元組的資料到destination的記憶體位置，
2.這個函式在遇到 ‘\0’ 的時候并不會停下來，
3.如果source和destination有任何的重疊，復制的結果都是未定義的，
4.

void *memcpy( void *dest, const void *src, size_t count );

此函式在實作的時候，不知道未來會被用來拷貝什么型別的資料，所以此函式回傳型別為void;第三個引數為要拷貝的位元組個數，
5.用于拷貝兩個不相關的記憶體（沒有重疊），
memcpy函式的使用

int main()
{
	int arr1[] = { 1, 2, 3, 4, 5, 6 };
	int arr2[10] = { 0 };
	memcpy(arr2, arr1, 16);
	return 0;
}

運行效果：

memcpy函式的模擬實作

void* my_memcpy(void*dest, const void*src, size_t count)
{
	void*ret = dest;
	assert(dest && src);

	while (count--)
	{
		*(char*)dest = *(char*)src;
		++(char*)dest;//((char*)dest)++;
		++(char*)src;//((char*)src)++;
	}
	return ret;
}

2.memmove

memmove函式和memcpy函式類似，引數完全相同，但區別在于memmove函式可以進行重疊拷貝，
例：
memmove函式的模擬實作

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

注意：
標準規定memcpy函式只要能夠實作不重疊拷貝就行，但在有些編譯器下memcpy函式也可以實作重疊拷貝，即便如此，也建議大家以后在重疊拷貝時用memmove函式，以免在部分編譯器環境下達不到預期效果，

3.memcmp

int memcmp( const void *buf1, const void *buf2, size_t count );

memcmp（記憶體比較函式）：用于比較buf1和buf2的前count個位元組，具體的回傳值如下：
和strcmp的區別：strcmp比較的是字串，strcmp在比較程序中需要注意是否遇到了’\0’，而memcmp比較的是記憶體塊，可以指定比較的位元組數，

4.memset

memset函式用于將指定的某一塊記憶體中的后n個位元組的內容全部設定為指定的字符，

void *memset( void *dest, int c, size_t count );