字串操作函式和記憶體函式詳解

字串操作函式的實作

1.strlen函式
函式功能：
計算指定的字串string的長度，
應用

int main()
{
	char* str = "abcdef";
	printf("%d\n",strlen(str));
	return 0;
}

模擬實作strlen函式
1.計數器實作

#include<stdio.h>
#include<assert.h>
int my_strlen(const char*str)//字串長度是不變的，用const修飾
{
    assert(str!=NULL);//assert斷言
	int ret = 0;
	while (*str!='\0')
	{
		ret++;
		str++;
	}
	return ret;
}
int main()
{
	char* str = "abcdef";
	printf("%d\n",my_strlen(str));
	return 0;
}

2.遞回實作

#include<Stdio.h>
int my_strlen(const char* str)
{
	assert(str != NULL);
	if (*str != '\0')
		return 1 + my_strlen(str + 1);
	else
		return 0;
}
int main()
{
	char* str = "hello bite";
	int len = my_strlen(str);
	printf("%d\n", len);
	return 0;
}

3.指標-指標實作
指標-指標的結果是中間元素的個數.

#include<stdio.h>
int my_strlen(const char* str)
{
	assert(str != NULL);
	const char*start = str;//存放起始位置
	while (*str != '\0')
	{
		str++;
	}
	return str - start;
}
int main()
{
	char* str = "abcdef";
	printf("%d\n",my_strlen(str));
	return 0;
}

2.strcpy函式
函式功能：把含有’\0’結束符的字串復制到另一個字串中，
函式原型

	char *strcpy( char *Destination, const char *Source );

模擬實作strcpy函式

char* my_strcpy(char*arr1, const char*arr2)
{
	assert(arr1&&arr2);
	char*ret = arr1;
	while (*arr1++ = *arr2++)
	{
		;
	}
	return ret;
}
int main()
{
	char arr1[20] = "****************";
	char arr2[] = "hello bit";
	char* ret=my_strcpy(arr1, arr2);
	printf("%s\n", ret);
	return 0;
}

3.strcat函式
功能：追加字串
注意：追加的空間足夠大并且可修改
應用：

#include<stdio.h>
int main()
{
	char arr1[20] = "hello";
	char arr2[] = "world";
	strcat(arr1, arr2);
	printf("%s\n", arr1);
	return 0;
}

模擬實作strcat函式

#include<stdio.h>
#include<assert.h>
 char *my_strcat(char*dest, const char*src)
{   //1.找到目標空間的\0
	//2.追加
	assert(dest&&src);
	char*ret = dest;
	while (*dest)
	{
		dest++;
	}
	while (*dest++ = *src++)
	{
		;
	}
	return ret;
}
int main()
{
	char arr1[20] = "hello";
	char arr2[] = "world";
	

4.strcmp函式
功能：字串的比較，
注意：比較的是對應位置字符的ASCII碼值而不是長度，
模擬實作strcmp函式

int my_strcmp(const char*s1, const char*s2)
{
	assert(s1&&s2);
	while (*s1==*s2)
	{
		if (*s1 == '\0')
		{
			return 0;
		}
		s1++;
		s2++;
	}
	if (*s1 > *s2)
	{
		return 1;
	}
	else
	{
		return -1;
	}
}
int main()
{
	char *p = "abcdef";
	int ret = my_strcmp("abq", "abcdef");
	printf("%d\n", ret);
	return 0;
}

5.strstr
功能：在一個字串中找子字串，
應用：

int main()
{
	char arr1[] = "abcdefghi";
	char arr2[] = "bcd";
	char *ret=strstr(arr1, arr2);//在arr1中找arr2字串第一次出現的位置
	if (ret != NULL)
	{
		printf("%s\n", ret);
	}
	else
		printf("找不到字串\n");
	return 0;
}

模擬實作strstr函式

char *my_strstr(const char*s1, const char*s2)
{
	char*cp = s1;
	while (*cp)
	{
		char*p1 = cp;
		char*p2 = s2;
		while ((*p1!='\0')&&(*p1 == *p2)&&(*p1==*p2))
		{
			p1++;
			p2++;
		}
		if (*p2 == '\0')
		{
			return (char*)cp;
		}
		cp++;
	}
	return NULL;
}

6.strtok

char *strtok( char *strToken, const char *strDelimit );

1）sep引數是個字串，定義了用作分隔符的字符集合
（2）第一個引數指定一個字串，它包含了0個或者多個由sep字串中一個或者多個分隔符分割的標記，
（3）strtok函式找到str中的下一個標記，并將其用 \0 結尾，回傳一個指向這個標記的指標，（注：strtok函式會改變被操作的字串，所以在使用strtok函式切分的字串一般都是臨時拷貝的內容并且可修改，）
（4）strtok函式的第一個引數不為 NULL ，函式將找到str中第一個標記，strtok函式將保存它在字串中的位置，
（5）strtok函式的第一個引數為 NULL ，函式將在同一個字串中被保存的位置開始，查找下一個標記，
（6）如果字串中不存在更多的標記，則回傳 NULL 指標，
7.strerror

char *strerror( int errnum );

功能：
strerror函式將errnum映射到錯誤訊息字串，并回傳指向該字串的指標
應用：

#include<errno.h>
int main()
{
	FILE*pf=fopen("test.txt","r");//file open
	if (pf == NULL)
	{
		printf("%s\n", strerror(errno));
	}
	return 0;
}

字符分類函式

記憶體操作函式

1.memcpy

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

功能:

memcpy函式將src的count位元組復制到dest，如果源和目標重疊，此函式不能確保在覆寫之前復制重疊區域中的原始源位元組，使用memmove處理重疊區域，
應用：

#include<stdio.h>
int main()
{
	int arr1[] = { 1, 2, 3, 4, 5, 6 };
	int arr2[20] = { 0 };
	memcpy(arr2, arr1, 16);
	return 0;
}

模擬實作memcpy函式

#include<stdio.h>
#include<assert.h>
void my_memecpy(void*dest, const void *src, size_t count)
{
	void *ret = dest;
	assert(dest&&src);
	while (count--)
	{
		*(char*)dest = *(char*)src;
		++(char*)dest;
		++(char*)src;
	}
	return ret;
}
int main()
{
	int arr1[] = { 1, 2, 3, 4, 5, 6 };
	int arr2[20] = { 0 };
	my_memcpy(arr2, arr1, 16);
	return 0;
}

2.memmove函式

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

功能:

memmove函式將count位元組的字符從src復制到dest，如果源區域和目標區域的某些區域重疊，memmove將確保在覆寫之前復制重疊區域中的原始源位元組，
應用：

void test3()
{
	int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	memeove(arr + 2, arr, 16);
}
int main()
{
	test3();
	return 0;
}

模擬實作memmove

#include <stdio.h>
#include <string.h>
#include<assert.h>
void* my_memmove(void* dest, const void* src, size_t count)
{
	assert(dest && src);
	void* start = dest;
	if (dest < src)
	{
		// 從前向后拷貝
		while (count--)
		{
			*(char*)dest = *(char*)src;
			++(char*)dest;
			++(char*)src;
		}
	}
	else
	{
		// 從后向前拷貝
		while (count--)
		{
			*((char*)dest + count) = *((char*)src + count);
		}
	}
	return start;
}
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10};
	my_memmove(arr + 2,arr,16);
}

3.memset函式
memset是初始化函式，作用是將某一塊記憶體中的內容全部設定為指定的值， 這個函式通常為新申請的記憶體做初始化作業，
應用：

int main()
{
    int arr[10]={0};
    memset(arr,1,40);
    return 0;
}

4.memcmp函式
功能：是把存盤區 str1 和存盤區 str2 的前 n 個位元組進行比較，
如果回傳值 < 0，則表示 str1 小于 str2，
如果回傳值 > 0，則表示 str2 小于 str1，
如果回傳值 = 0，則表示 str1 等于 str2，
應用：

int main()
{
	int arr1[] = { 1, 2, 3, 4, 5 };
	int arr2[] = { 1, 2, 5, 6, 7 };
	int ret=memcmp(arr1, arr2, 8);
	return 0;
}