字符串+內(nèi)存函數(shù)（C語(yǔ)言）-創(chuàng)新互聯(lián)

目錄

10年專注成都網(wǎng)站制作，成都企業(yè)網(wǎng)站建設(shè)，個(gè)人網(wǎng)站制作服務(wù)，為大家分享網(wǎng)站制作知識(shí)、方案，網(wǎng)站設(shè)計(jì)流程、步驟,成功服務(wù)上千家企業(yè)。為您提供網(wǎng)站建設(shè),網(wǎng)站制作,網(wǎng)頁(yè)設(shè)計(jì)及定制高端網(wǎng)站建設(shè)服務(wù),專注于成都企業(yè)網(wǎng)站建設(shè),高端網(wǎng)頁(yè)制作,對(duì)成都會(huì)所設(shè)計(jì)等多個(gè)領(lǐng)域，擁有多年建站經(jīng)驗(yàn)。

函數(shù)介紹：

字符串函數(shù)：

strlen

一道迷惑筆試題：

strcpy

strcat

strcmp

strncpy

strncat

strncmp

strstr

strtok

strerror

字符分類函數(shù)：

iscntrl?

isspace

isdigit

isxdigit

islower

isupper

isalpha

isalnum

ispunct

isgraph

isprint

tolower

toupper

內(nèi)存函數(shù)：

memcpy

memmove

memcmp

memset

庫(kù)函數(shù)的模擬實(shí)現(xiàn)

模擬實(shí)現(xiàn)strlen

模擬實(shí)現(xiàn)strcpy

模擬實(shí)現(xiàn)strcat

模擬實(shí)現(xiàn)strstr

模擬實(shí)現(xiàn)strcmp

模擬實(shí)現(xiàn)memcpy

模擬實(shí)現(xiàn)memmove

---

對(duì)C語(yǔ)言中的幾個(gè)常用的庫(kù)函數(shù)進(jìn)行解釋說(shuō)明

并徹底了解如何使用

了解原理，并進(jìn)行模擬實(shí)現(xiàn)

函數(shù)介紹： 字符串函數(shù)：

strlen

計(jì)算字符串長(zhǎng)度函數(shù)

函數(shù)原型：size_t? strlen(const char* str)

返回值：size_t? ?就是??unsigned int 無(wú)符號(hào)整型

?返回的是'\0‘之前字符的個(gè)數(shù)?

參數(shù)：const char* str??

?是一個(gè)char*的指針 且用const修飾

?const修飾的是*str

表示指針指向的內(nèi)容是不可被修改的

函數(shù)作用：計(jì)算的是字符串長(zhǎng)度

計(jì)算'\0'之前字符的個(gè)數(shù)

函數(shù)的用途：看以下代碼：

#include#includeint main()
{
	//創(chuàng)建一個(gè)數(shù)組 用來(lái)封裝字符串
	char str[] = "abcdefghjk";
	
	//調(diào)用strlen函數(shù),用一個(gè)size_t 無(wú)符號(hào)整型來(lái)接收
	//將str數(shù)組名表示首元素地址，也就是字符串的首地址傳過(guò)去
	size_t len = strlen(str);

	//打印，從傳過(guò)去的位置開始，遇到'\0'之前，字符的個(gè)數(shù)
	printf("%u\n", len);

	return 0;
}

一道迷惑筆試題：

#include#includeint main()
{
	const char* str1 = "abcdef";
	const char* str2 = "bbb";

	if (strlen(str2) - strlen(str1) >0)
	{
		printf("str2>str1\n");
	}
	else
	{
		printf("srt1>str2\n");
	}

//在判斷的時(shí)候，strlen(str2)的值為3
//strlen(str1)的值為6
//而 3 和 6 都是size_t類型
//3-6 的實(shí)際結(jié)果為：-3
// -3 ：
// 原碼：10000000 00000000 00000000 00000011
// 反碼：11111111 11111111 11111111 11111100
// 補(bǔ)碼：11111111 11111111 11111111 11111101
// 
//但因?yàn)槭菬o(wú)符號(hào)整型，將-3的補(bǔ)碼實(shí)際解讀的時(shí)候
//是按照無(wú)符號(hào)數(shù)來(lái)解讀的，因?yàn)檎龜?shù)的 原碼，反碼，補(bǔ)碼相同
//所以將-3的補(bǔ)碼當(dāng)做原碼解讀，是一個(gè)很大的數(shù)
//該數(shù)必定大于0 所以必定指向if里面的語(yǔ)句

	return 0;
}

解析：

答案：str2>str1

在判斷的時(shí)候，strlen(str2)的值為3
strlen(str1)的值為6
而 3 和 6 都是size_t類型
3-6 的實(shí)際結(jié)果為：-3
-3 ：
原碼：10000000 00000000 00000000 00000011
反碼：11111111 11111111 11111111 11111100
補(bǔ)碼：11111111 11111111 11111111 11111101

但因?yàn)槭菬o(wú)符號(hào)整型，將-3的補(bǔ)碼實(shí)際解讀的時(shí)候
是按照無(wú)符號(hào)數(shù)來(lái)解讀的，因?yàn)檎龜?shù)的 原碼，反碼，補(bǔ)碼相同
所以將-3的補(bǔ)碼當(dāng)做原碼解讀，是一個(gè)很大的數(shù)
該數(shù)必定大于0 所以必定指向if里面的語(yǔ)句

strcpy

字符串拷貝函數(shù)

函數(shù)原型：char * strcpy ( char * destination, const char * source );

參數(shù)：char * destination, const char * source

將source指向的字符串復(fù)制到destination指向的數(shù)組中

包括終止字符'\0’也要賦值過(guò)去

返回值：char*??

返回的是sourec指向的那一片空間的地址

函數(shù)作用：將源頭src指向字符串的內(nèi)容賦值到目的地dest指向字符串中

?在賦值的時(shí)候會(huì)將字符'\0’也賦值過(guò)去

???????為避免溢出，destination指向的數(shù)組的大小應(yīng)足夠長(zhǎng)

以包含與source相同的字符串（包括終止空字符），

并且不應(yīng)與source在內(nèi)存中重疊。

函數(shù)的使用：看以下代碼：

#include#includeint main()
{
	//將str2的內(nèi)容拷貝到str1中
   //拷貝的時(shí)候會(huì)將'\0'也拷貝過(guò)去
  //str1的空間要足夠大要裝的下str2的內(nèi)容！
	char str1[20] = "zzzzzzzzzzzzzz";
	char str2[] = "abcde";
	strcpy(str1, str2);
	printf("%s\n", str1);

	//將s2的內(nèi)容拷貝到s1中
	//拷貝的時(shí)候會(huì)將'\0'也拷貝過(guò)去
	//s1的空間要足夠大要裝的大s2的內(nèi)容
	char s1[] = "xxxxxxxxxx";
	char s2[] = "fghijk";
	strcpy(s1, s2);
	printf("%s\n", s1);

	//將p2指向的常量字符串的內(nèi)容拷貝到p2中
	//拷貝的時(shí)候會(huì)將'\0'也拷貝過(guò)去
	//p1的空間要足夠大要裝的大p2的內(nèi)容
	char p1[20] = "yyyyyyyyyyyyyyyyyy";
	char* p2 = "lmnopq";
	strcpy(p1, p2);
	printf("%s\n", p1);

	return 0;
}

strcat

字符串追加函數(shù)

函數(shù)原型：char * strcat ( char * destination, const char * source );

返回值：char*

返回的是追加完成之后

destination的首地址

參數(shù)：char * destination, const char * source

?destination是目的地字符串的首地址

?source 是源頭字符串的首地址

函數(shù)作用：

將source指向的字符串內(nèi)容

追加到destination指向的字符串后面

追加時(shí)：destination中的'\0'被source的第一個(gè)字符覆蓋

destination指向的空間要足夠大

要容納下追加之后的新字符串

函數(shù)用途：看以下代碼? ? ? ?

#include#includeint main()
{
	//將str2的內(nèi)容追加到str1的后面
	//在追加的時(shí)候str1最后的‘\0’字符被str2的第一個(gè)字符覆蓋
	//然后進(jìn)行追加，追加時(shí)會(huì)將str2的'\0'也追加進(jìn)去
	//str1的空間要足夠大，要能容納下追加后的新字符串
	char str1[50] = "abcdefg";
	char str2[] = "hijklmn";
	strcat(str1, str2);
	printf("%s\n", str1);

	//將p2指向的常量字符串內(nèi)容追加到p1的后面
	//追加時(shí)p1的'\0'字符被p2的首字符覆蓋
	//追加時(shí)會(huì)將p2的'\0'也追加進(jìn)去
	//p1的空間要足夠大，能容納下追加后的新字符串
	char p1[20] = "abc";
	char* p2 = "defgk";
	strcat(p1, p2);
	printf("%s\n", p1);

	return 0;
}

?

strcmp

字符串比較函數(shù)

函數(shù)原型：int strcmp ( const char * str1, const char * str2 );

返回值：int

???返回的是一個(gè)有符號(hào)整型數(shù)

?可返回負(fù)數(shù)，0，正數(shù)

參數(shù)：const char * str1, const char * str2

?str1指向一個(gè)字符串，

?str1里面存放的是字符串的首地址

?用const修飾說(shuō)明字符串的內(nèi)容不可被修改

?str2也指向一個(gè)字符串，

?str2里面存放的是字符串的首地址

?用const修飾說(shuō)明字符串的內(nèi)容不可被修改

?

函數(shù)的作用：

?????str1字符串與str2字符串從首字符的位置開始

?????一個(gè)字符一個(gè)字符對(duì)應(yīng)向后一一比較，

?????在比較字符的時(shí)候比較的是其ASCII碼值，

?????若對(duì)應(yīng)比較兩個(gè)字符相等則一直向后比較，

?????直到碰到字符不等的情況就停止比較，

?????然后返回這兩個(gè)不等字符的比較結(jié)果，

?????當(dāng)str1的字符大于str2的字符 則返回大于0的數(shù)字，

?????若兩個(gè)字符串比較完了，各字符都相同，

?????且長(zhǎng)度相等的情況下，則這兩個(gè)字符串相等

?????str1等于str2時(shí)返回0，

?????str1的字符小于str2的字符時(shí) 返回小于0的數(shù)

函數(shù)用途：如下代碼：

#include#includeint main()
{
	//字符串比較
	//str1 與 str2 進(jìn)行比較
	//從首字符開始向后一一比較
	//在比較的時(shí)候比較的是字符的ASCII碼值
	//若對(duì)應(yīng)的字符相等，則繼續(xù)向后比較
	//若不等，則停止比較，返回他們的比較結(jié)果
	//若兩個(gè)字符串比較完都相等，且長(zhǎng)度一樣長(zhǎng)，說(shuō)明str2和str2相等
	//返回值：
	//第一個(gè)字符串大于第二個(gè)字符串，則返回大于0的數(shù)字
	//第一個(gè)字符串等于第二個(gè)字符串，則返回0
	//第一個(gè)字符串小于第二個(gè)字符串，則返回小于0的數(shù)字

	char str1[] = "abcde";
	char str2[] = "abcfk";
	int n = strcmp(str1, str2);
	if (n == 0)
	{
		printf("str1 == str2");
	}
	else if (n >0)
	{
		printf("str1 >str2");
	}
	else
	{
		printf("str1< str2");
	}

	return 0;
}

strncpy

字符串拷貝函數(shù)（指定字節(jié)數(shù)拷貝）

函數(shù)原型：char * strncpy ( char * destination, const char * source, size_t num );

返回值：char *

?返回的是一個(gè)char* 的指針

?返回的是拷貝完成后的destination指向的空間

參數(shù)：char * destination, const char * source, size_t num

?目的地字符串：

?destination 是指向一個(gè)字符串空間的指針

?源頭字符串：

?soure是一個(gè)指向一個(gè)字符串空間的指針

?const修飾說(shuō)明soure指向的字符串不可被修改

?num是一個(gè)sizt_t 無(wú)符號(hào)整型的數(shù)字

函數(shù)的作用：

?????將soure指向的字符串中num個(gè)字節(jié)的內(nèi)容

?????復(fù)制到destination指向的字符串空間

?????如果source指向的字符串的長(zhǎng)度小于num，

?????則拷貝完源字符串之后，在目標(biāo)的后邊追加0，

?????直到追加夠num個(gè)結(jié)束

?????destination 指向的空間要足夠大

?????至少能容納下拷貝后新的字符串

函數(shù)用途：如下代碼：

#include#includeint main()
{
	//拷貝num個(gè)字符從源字符串到目標(biāo)空間。
	//如果源字符串的長(zhǎng)度小于num，則拷貝完源字符串之后，
	//在目標(biāo)的后邊追加0，直到num個(gè)

	char str1[] = "yyyyyyyyyyyyyyyyyyy";
	char str2[] = "hello";
	strncpy(str1, str2, 5);
	printf("%s\n", str1);

	//當(dāng)s2的長(zhǎng)度

strncat

字符串追加函數(shù)（指定字節(jié)數(shù)追加）

函數(shù)原型：char * strncat?( char * destination, const char * source, size_t num );

返回值：char *

??返回的是一個(gè)char*的指針

返回追加完成之后destination指向的空間

參數(shù)：char * destination, const char * source, size_t num

?目的地字符串：

?destination 是指向一個(gè)字符串空間的指針

?源頭字符串：

?soure是一個(gè)指向一個(gè)字符串空間的指指針

?const修飾 說(shuō)明soure指向的字符串不可被修改

?num是一個(gè)sizt_t 無(wú)符號(hào)整型的數(shù)字

函數(shù)的作用：

?????將soure指向的字符串中num個(gè)字節(jié)的內(nèi)容

? 追加到destination指向的字符串空間

?????destination指向字符串的最后的'\0'字符

?????會(huì)被soure指向的字符串的首字符所覆蓋

?????如果source指向的字符串的長(zhǎng)度大于num，

?????則追加完num個(gè)字符之后，在后邊自動(dòng)加上'\0'

?????如果source指向的字符串的長(zhǎng)度小于num，

? 則只追加完source指向的字符串內(nèi)容(包含'\0’)

?????就結(jié)束結(jié)束追加

?????destination 指向的空間要足夠大

?????至少能容納下追加后新的字符串

函數(shù)用途：如下代碼：

#include#includeint main()
{
	//str2 大于 num 的情況
   //會(huì)自動(dòng)在末尾加上'\0'
	//在追加的時(shí)候，str1的'\0'會(huì)被str2的首字符所覆蓋
	char str1[50] = "uvwxy";
	char str2[] = "abcdefg";
	strncat(str1, str2, 5);
	printf("%s\n", str1);

	//str2 小于 num 的情況
	//只追加完str2包含'\0’字符就結(jié)束追加
	//在追加的時(shí)候，s1的'\0'會(huì)被s2的首字符所覆蓋
	char s1[50] = "wasche";
	char s2[] = "hello world";
	strncat(s1, s2, 13);
	printf("%s\n", s1);

	return 0;
}

strncmp

字符串比較函數(shù)（指定字節(jié)數(shù)比較）

函數(shù)原型：int strncmp ( const char * str1, const char * str2, size_t num );

返回值：int

???返回的是一個(gè)有符號(hào)整型數(shù)

?可返回負(fù)數(shù)，0，正數(shù)

參數(shù)：const char * str1, const char * str2, size_t num

?str1指向一個(gè)字符串，

?str1里面存放的是字符串的首地址

?用const修飾說(shuō)明字符串的內(nèi)容不可被修改

?str2也指向一個(gè)字符串，

?str2里面存放的是字符串的首地址

?用const修飾說(shuō)明字符串的內(nèi)容不可被修改

?num是一個(gè)無(wú)符號(hào)整數(shù)，表示字節(jié)數(shù)

函數(shù)的作用：

? 對(duì)str1和str2字符串，指定num個(gè)字節(jié)進(jìn)行比較

?????str1字符串與str2字符串從首字符的位置開始

? 比較到num個(gè)字節(jié)結(jié)束

?????一個(gè)字符一個(gè)字符對(duì)應(yīng)向后一一比較，

?????在比較字符的時(shí)候比較的是其ASCII碼值，

?????若對(duì)應(yīng)比較兩個(gè)字符相等則一直向后比較，

?????直到碰到字符不等的情況就停止比較，

?????然后返回這兩個(gè)不等字符的比較結(jié)果，

?????當(dāng)str1的字符大于str2的字符 則返回大于0的數(shù)字，

?????若兩個(gè)字符串比較num個(gè)字節(jié)之后，

?????各字符都相同，則這兩個(gè)字符串相等

?????str1等于str2時(shí)返回0，

?????str1的字符小于str2的字符時(shí) 返回小于0的數(shù)

?????若字符串的長(zhǎng)度小于num，則比較完字符'\0'就結(jié)束比較

函數(shù)用途：如下代碼：

#include#includeint main()
{
	char str1[] = "abcdefghijklm";
	char str2[] = "abcdefgxyz";
	//比較前六個(gè)字符是否相等
	int n = strncmp(str1, str2, 6);
	if (n == 0)
	{
		printf("str1 == str2\n");
	}
	else if (n >0)
	{
		printf("str1 >str2\n");
	}
	else
	{
		printf("str1< str2\n");
	}


	//比較前8個(gè)字符是否相等
	n = strncmp(str1, str2, 8);
	if (n == 0)
	{
		printf("str1 == str2\n");
	}
	else if (n >0)
	{
		printf("str1 >str2\n");
	}
	else
	{
		printf("str1< str2\n");
	}

	//比較前11個(gè)字符是否相等
	n = strncmp(str1, str2, 11);
	if (n == 0)
	{
		printf("str1 == str2\n");
	}
	else if (n >0)
	{
		printf("str1 >str2\n");
	}
	else
	{
		printf("str1< str2\n");
	}

	return 0;
}

strstr

字符串找子串函數(shù)

函數(shù)原型：char * strstr ( const char *str1, const char * str2);

返回值：char *

返回一個(gè)字符指針

?返回找到子串的首字符的地址

找不到返回NULL

參數(shù)：const char *str1, const char * str2

?str1指向一個(gè)字符串，

?str1里面存放的是字符串的首地址

?用const修飾說(shuō)明字符串的內(nèi)容不可被修改

?str2也指向一個(gè)字符串，

?str2里面存放的是字符串的首地址

?用const修飾說(shuō)明字符串的內(nèi)容不可被修改

函數(shù)的作用：

? 尋找在str1指向的常量字符串里

?????是否包含str2指向的字符串

?????若包含則返回str2第一次出現(xiàn)的地址

?????若不包含則返回NULL

函數(shù)用途：如下代碼：

#include#includeint main()
{
	//查找str2是否是str1的子串
	//若是則返回str2第一次出現(xiàn)的位置
	//若不是則返回NULL
	char str1[] = "abcdefgjklcdefgmn";
	char str2[] = "cdef";
	char* p = strstr(str1, str2);
	if (p == NULL)
	{
		printf("str2 不是 str1 的子串\n");
	}
	else
	{
		printf("str2 是 str1 的子串\n");
		//用%s打印的時(shí)候會(huì)從str2在str1中第一次出現(xiàn)的位置開始，直到遇到'\0'結(jié)束
		printf("%s\n", p);
	}

	return 0;
}

strtok

字符串分割函數(shù)

函數(shù)原型：char * strtok ( char * str, const char * sep );

返回值：char *

??返回一個(gè)字符指針

??返回用分割符號(hào)分割后字符串的首地址

參數(shù)：char * str, const char * sep

str是一個(gè)指向要被分割的字符串的空間

sep指向的是分割符號(hào)的字符串空間

用const修飾說(shuō)明sep指向的內(nèi)容不可被修改

函數(shù)的作用：

sep里面?zhèn)鬟^(guò)來(lái)的是分隔符的字符串

在第一次調(diào)用的時(shí)候

str里面?zhèn)鬟^(guò)來(lái)的是要被分割字符串的首地址

在查找分隔符的時(shí)候會(huì)將分隔符的位置改為'\0'

在第二次調(diào)用的時(shí)候

str里面?zhèn)魅胍粋€(gè)空指針，

此時(shí)查找分隔符的位置會(huì)在第一次分隔符的下一個(gè)字符開始查找

會(huì)找到下一個(gè)分隔符，再將分隔符的位置改為'\0‘

以此類推有幾個(gè)分隔符就查找?guī)状?/p>

sep參數(shù)是個(gè)字符串，定義了用作分隔符的字符集合
第一個(gè)參數(shù)指定一個(gè)字符串，

它包含了0個(gè)或者多個(gè)由sep字符串中一個(gè)或者多個(gè)分隔符分割的標(biāo)記。
strtok函數(shù)找到str中的下一個(gè)標(biāo)記，

并將其用 \0 結(jié)尾，

返回一個(gè)指向這個(gè)標(biāo)記的指針。

（注：
??? strtok函數(shù)會(huì)改變被操作的字符串，

????????? ?所以在使用strtok函數(shù)切分的字符串

????????一般都是臨時(shí)拷貝的內(nèi)容并且可修改。）
strtok函數(shù)的第一個(gè)參數(shù)不為 NULL ，

函數(shù)將找到str中第一個(gè)標(biāo)記，

strtok函數(shù)將保存它在字符串中的位置。
strtok函數(shù)的第一個(gè)參數(shù)為 NULL ，

函數(shù)將在同一個(gè)字符串中被保存的位置開始，

查找下一個(gè)標(biāo)記。
如果字符串中不存在更多的標(biāo)記，則返回 NULL 指針

函數(shù)用途：如下代碼：

#include#includeint main()
{
	char str[] = "hello@world&string#strtok";//被分割的字符串
	char ep[] = "@&#";//分隔符字符串

	//第一次調(diào)用 會(huì)將找到的分割符的位置改為'\0'
	char* p = strtok(str, ep);
	printf("%s\n", p);

	//第二次調(diào)用傳入空指針 會(huì)將找到的分割符的位置改為'\0'
	p = strtok(NULL, ep);
	printf("%s\n", p);

	//第三次調(diào)用也傳入空指針 會(huì)將找到的分割符的位置改為'\0'
	p = strtok(NULL, ep);
	printf("%s\n", p);

	//第四次調(diào)用也傳入NULL 會(huì)將找到的分割符的位置改為'\0'
	p = strtok(NULL, ep);
	printf("%s\n", p);


	上述我們打印分割的字符串總共調(diào)用了四次
	代碼寫的有點(diǎn)繁瑣，我們可以用一個(gè)for循環(huán)直接調(diào)用打印
	//char* ret = NULL;
	//for (ret = strtok(str, ep);ret!=NULL; ret = strtok(NULL, ep))
	//{
	//	printf("%s\n", ret);
	//}

	return 0;
}

strerror

獲取錯(cuò)誤信息函數(shù)

函數(shù)原型：char * strerror ( int errnum );

返回值：char *

? 返回一個(gè)字符指針

??返回的是錯(cuò)誤信息是字符串

參數(shù)：int errnum

參數(shù)是一個(gè)整數(shù)

傳入的是一個(gè)錯(cuò)誤碼

函數(shù)的作用：

? 返回一個(gè)字符串，而這個(gè)字符串

? 就是一串錯(cuò)誤信息

? 而參數(shù)是一個(gè)整數(shù)，是一個(gè)錯(cuò)誤碼

? 每一個(gè)錯(cuò)誤碼都有一個(gè)對(duì)應(yīng)的錯(cuò)誤信息

函數(shù)用途：如下代碼：

#include#include#includeint main()
{
	//隨便傳入一個(gè)錯(cuò)誤碼，打印出其錯(cuò)誤信息
	printf("%s\n", strerror(12));

	//具體應(yīng)用
	//FILE是一個(gè)文件指針，fopen是打開文件
	//在當(dāng)前目錄下打開text.txt文件進(jìn)行讀操作
	//若打開失敗返回NULL
	FILE* pf = fopen("text.txt", "r");
	if (pf == NULL)
	{
		printf("打開失敗錯(cuò)誤信息為：%s",strerror(errno));
	}
	else
	{
		printf("打開成功\n");
	}

	return 0;
}

字符分類函數(shù)：

頭文件包含：#include

iscntrl?

字符控制函數(shù)

函數(shù)原型：int iscntrl ( int c );

函數(shù)的作用：

? 傳入一個(gè)字符，

判斷是否是控制字符

若是則返回非0數(shù)(也就是ture)

若不是則返回0(也就是false)

函數(shù)用途：

#include#includeint main()
{
	char c = 0;
	scanf("%c", &c);
	int ret = iscntrl(c);
	if (ret == 0)
	{
		printf("%c不是控制字符\n", c);
	}
	else
	{
		printf("%c 是控制字符\n", c);
	}

	return 0;
}

isspace

空白字符：‘空格’，‘\f’換頁(yè)，'\n'換行，

?????'\r'回車，制表符‘\t’，垂直制表符'\v'

函數(shù)原型：int isspace ( int c );

函數(shù)作用：

? 傳入一個(gè)字符，

判斷是否是空白字符

若是則返回非0數(shù)(也就是ture)

若不是則返回0(也就是false)

函數(shù)用途：

#include#includeint main()
{
	//空白字符：‘空格’，‘\f’換頁(yè)，'\n'換行，'\r'回車，制表符‘\t’，垂直制表符'\v'
	char c = '\n';
	int ret = iscntrl(c);
	if (ret == 0)
	{
		printf("%c不是空白字符\n", c);
	}
	else
	{
		printf("%c 是空白字符\n", c);
	}

	return 0;
}

isdigit

十進(jìn)制數(shù)字0~9

函數(shù)原型：int isdigit ( int c );

函數(shù)作用：

? 傳入一個(gè)字符，

判斷是否是0~9的字符

若是則返回非0數(shù)(也就是ture)

若不是則返回0(也就是false)

函數(shù)用途：

#include#includeint main()
{
	char c = 0;
	scanf("%c", &c);
	int ret = isdigit(c);
	if (ret == 0)
	{
		printf("%c不是0~9字符\n", c);
	}
	else
	{
		printf("%c 是0~9字符\n", c);
	}

	return 0;
}

isxdigit

十六進(jìn)制數(shù)字，包括所有十進(jìn)制數(shù)字，小寫字母a~f，大寫字母A~F

函數(shù)原型：int isdigit ( int c );

函數(shù)作用：

? 傳入一個(gè)字符，

判斷是否是十六進(jìn)制數(shù)

小寫字母a~f，大寫字母A~F的字符

若是則返回非0數(shù)(也就是ture)

若不是則返回0(也就是false)

函數(shù)用途：

#include#includeint main()
{
	char c = 0;
	scanf("%c", &c);
	int ret = isxdigit(c);
	if (ret == 0)
	{
		printf("%c NO is 十六進(jìn)制\n", c);
	}
	else
	{
		printf("%c YES 十六進(jìn)制\n", c);
	}

	return 0;
}

islower

小寫字母：a~z

函數(shù)原型：int islower?( int c );

函數(shù)作用：

? 傳入一個(gè)字符，

判斷是否是小寫字母：a~z

若是則返回非0數(shù)(也就是ture)

若不是則返回0(也就是false)

函數(shù)用途：

#include#includeint main()
{
	char c = 0;
	scanf("%c", &c);
	int ret = islower(c);
	if (ret == 0)
	{
		printf("%c NO is 小寫字母\n", c);
	}
	else
	{
		printf("%c YES 小寫字母\n", c);
	}

	return 0;
}

isupper

大寫字母A~Z

函數(shù)原型：int isupper?( int c );

函數(shù)作用：

? 傳入一個(gè)字符，

判斷是否是大寫字母：A~Z

若是則返回非0數(shù)(也就是ture)

若不是則返回0(也就是false)

函數(shù)用途：

#include#includeint main()
{
	char c = 0;
	scanf("%c", &c);
	int ret = isupper(c);
	if (ret == 0)
	{
		printf("%c NO is 大寫字母\n", c);
	}
	else
	{
		printf("%c YES 大寫字母\n", c);
	}

	return 0;
}

isalpha

字母a~z或者A~Z

函數(shù)原型：int isalpha?( int c );

函數(shù)作用：

? 傳入一個(gè)字符，

判斷是否是大寫或者小寫字母

若是則返回非0數(shù)(也就是ture)

若不是則返回0(也就是false)

函數(shù)用途：

#include#includeint main()
{
	char c = 0;
	scanf("%c", &c);
	int ret = isalpha(c);
	if (ret == 0)
	{
		printf("%c NO is 字母\n", c);
	}
	else
	{
		printf("%c YES 字母\n", c);
	}

	return 0;
}

isalnum

字母或者數(shù)字，A~Z ，a~z，0~9

函數(shù)原型：int isalnum?( int c );

函數(shù)作用：

? 傳入一個(gè)字符，

判斷是否是

大寫或者小寫字母或者是數(shù)字字符

若是則返回非0數(shù)(也就是ture)

若不是則返回0(也就是false)

函數(shù)用途：

#include#includeint main()
{
	char c = 0;
	scanf("%c", &c);
	int ret = isalnum(c);
	if (ret == 0)
	{
		printf("%c NO is 字母或數(shù)字\n", c);
	}
	else
	{
		printf("%c YES 字母或數(shù)字\n", c);
	}

	return 0;
}

ispunct

標(biāo)點(diǎn)符號(hào)，任何不屬于數(shù)字或者字母的圖形字符(可打印)

函數(shù)原型：int ispunct?( int c );

函數(shù)作用：

? 傳入一個(gè)字符，

判斷是否是

? 不屬于數(shù)字或者字母的圖形字符

若是則返回非0數(shù)(也就是ture)

若不是則返回0(也就是false)

函數(shù)用途：

#include#includeint main()
{
	char c = 0;
	scanf("%c", &c);
	int ret = ispunct(c);
	if (ret == 0)
	{
		printf("%c NO is 它屬于數(shù)字或字母\n", c);
	}
	else
	{
		printf("%c YES  它不屬于字母或數(shù)字\n", c);
	}

	return 0;
}

isgraph

任何圖形字符

函數(shù)原型：int isgraph?( int c );

函數(shù)作用：

? 傳入一個(gè)字符，

判斷是否是圖形字符

若是則返回非0數(shù)(也就是ture)

若不是則返回0(也就是false)

函數(shù)用途：

#include#includeint main()
{
	char c = 0;
	scanf("%c", &c);
	int ret = isgraph(c);
	if (ret == 0)
	{
		printf("%c NO is 它不是圖形字符\n", c);
	}
	else
	{
		printf("%c YES  它是圖形字符\n", c);
	}

	return 0;
}

isprint

任何可打印字符，包括圖形字符和空白字符

函數(shù)原型：int isprint?( int c );

函數(shù)作用：

? 傳入一個(gè)字符，

判斷是否是可打印的字符

? 包含圖形字符和空白字符

若是則返回非0數(shù)(也就是ture)

若不是則返回0(也就是false)

函數(shù)用途：

#include#includeint main()
{
	char c = 0;
	scanf("%c", &c);
	int ret = isprint(c);
	if (ret == 0)
	{
		printf("%c NO is 它不是可打印的字符\n", c);
	}
	else
	{
		printf("%c YES  它是可打印的字符\n", c);
	}

	return 0;
}

tolower

字母大寫轉(zhuǎn)小寫

函數(shù)原型：int tolower?( int c );

函數(shù)作用：

? 傳入一個(gè)字符，

判斷是否是大寫字母A~Z

? 若是將其轉(zhuǎn)為對(duì)應(yīng)小寫字母

函數(shù)用途：

#include#include#includeint main()
{
	//將字符串的大寫字母全部轉(zhuǎn)為小寫字母
	char str[] = "abcDEfGjK";
	int i = 0;
	for (i = 0; i< strlen(str); i++)
	{
		if (isupper(str[i])!=0)//判斷是否是大寫字母
		{
			str[i] = tolower(str[i]);//大寫轉(zhuǎn)小寫
		}
	}
	printf("%s\n", str);

	return 0;
}

toupper

字母小寫轉(zhuǎn)大寫

函數(shù)原型：int toupper?( int c );

函數(shù)作用：

? 傳入一個(gè)字符，

判斷是否是小寫字母a~z

? 若是將其轉(zhuǎn)為對(duì)應(yīng)大寫字母

函數(shù)用途：

#include#include#includeint main()
{
	//將字符串的小寫字母全部轉(zhuǎn)為大寫字母
	char str[] = "abcDEfGjK";
	int i = 0;
	for (i = 0; i< strlen(str); i++)
	{
		if (islower(str[i])!=0)//判斷是否是小寫字母
		{
			str[i] = toupper(str[i]);//小寫轉(zhuǎn)大寫
		}
	}
	printf("%s\n", str);

	return 0;
}

內(nèi)存函數(shù)：

memcpy

內(nèi)存拷貝函數(shù)

函數(shù)原型：void * memcpy ( void * destination, const void * source, size_t num );

返回值：void?*

? 返回值是一個(gè)任意類型的指針

?返回拷貝好的內(nèi)存空間的起始地址

參數(shù)：void * destination, const void * source, size_t num

目的地：

destination是一個(gè)任意類型的指針

源頭：

source是一個(gè)任意類型的指針

? 用const修飾，

說(shuō)明source指向的內(nèi)存空間的內(nèi)容不可修改

字節(jié)數(shù)：

num是一個(gè)無(wú)符號(hào)整型

函數(shù)的作用：

將source 指向的空間

里面的num個(gè)字節(jié)的數(shù)據(jù)

復(fù)制到destination指向的空間中

返回值，返回的是：

拷貝好之后 destination指向的空間的地址

? destination指向的內(nèi)存空間要足夠大

? 至少能容納下拷貝之后的數(shù)據(jù)

? 這個(gè)函數(shù)遇到'\0'時(shí)根本就不會(huì)停下來(lái)

? 直到拷貝夠num字節(jié)數(shù)就停止

? memcpy函數(shù)不能勝任重疊拷貝

? 自己拷貝自己

函數(shù)用途：如下代碼：

#include#include// 定義結(jié)構(gòu)體
struct {
	char name[40];
	int age;
} person, person_copy;
//創(chuàng)建結(jié)構(gòu)體全局變量 person,和 per_copy

int main()
{
	char myname[] = "Pierre de Fermat";
	//創(chuàng)建一個(gè)字符串
	
	//將myname整個(gè)字符串的內(nèi)容，拷貝到結(jié)構(gòu)體變量person 的成員變量 name 空間中
	memcpy(person.name, myname, strlen(myname) + 1);
	//再給變量person的成員變量 age 賦值為46
	person.age = 46;

	//將變量person 的空間的內(nèi)容，全部拷貝 到變量 person_copy的空間中
	memcpy(&person_copy, &person, sizeof(person));
	//將變量 person_copy 空間中的內(nèi)容打印出來(lái) 
	printf("person_copy: %s, %d \n", person_copy.name, person_copy.age);

	return 0;
}

memmove

內(nèi)存拷貝函數(shù)(指定字節(jié)數(shù))

函數(shù)原型：void * memmove ( void * destination, const void * source, size_t num );

返回值：void?*

? 返回值是一個(gè)任意類型的指針

?返回拷貝好的內(nèi)存空間的起始地址

參數(shù)：void * destination, const void * source, size_t num

目的地：

destination是一個(gè)任意類型的指針

源頭：

source是一個(gè)任意類型的指針

? 用const修飾，

說(shuō)明source指向的內(nèi)存空間的內(nèi)容不可修改

字節(jié)數(shù)：

num是一個(gè)無(wú)符號(hào)整型

函數(shù)的作用：

將source 指向的空間

里面的num個(gè)字節(jié)的數(shù)據(jù)

復(fù)制到destination指向的空間中

返回值，返回的是：

拷貝好之后 destination指向的空間的地址

? destination指向的內(nèi)存空間要足夠大

? 至少能容納下拷貝之后的數(shù)據(jù)

? 這個(gè)函數(shù)遇到'\0'時(shí)根本就不會(huì)停下來(lái)

? 直到拷貝夠num字節(jié)數(shù)就停止

? memmove函數(shù)可以勝任重疊拷貝

? 自己可以拷貝自己

函數(shù)用途：如下代碼：

#include#includeint main()
{
	//創(chuàng)建字符串?dāng)?shù)組并初始化
	char str[] = "memmove can be very useful......";

	//str+20 取到的是字符u的地址
	//str+15 取到的是字符v的地址
	//從v字符還是往后拷貝11個(gè)字節(jié)的數(shù)據(jù)到 str+20的位置
	//自己拷貝自己 重疊拷貝
	memmove(str + 20, str + 15, 11);

	//打印重疊拷貝后的str
	puts(str);

	return 0;
}

memcmp

內(nèi)存比較函數(shù)

函數(shù)原型：int memcmp ( const void * ptr1,const void * ptr2,size_t num );

返回值：int

返回一個(gè)有符號(hào)整數(shù)

返回小于0的數(shù)

返回等于0的數(shù)

返回大于0的數(shù)

參數(shù)：const void * ptr1,const void * ptr2,size_t num

目的地：

ptr1指向任意類型的一塊內(nèi)存空間

用const修飾

說(shuō)明ptr1指向的空間的內(nèi)容不可被修改

源頭：

ptr2指向任意類型的一塊內(nèi)存空間

用const修飾

說(shuō)明ptr2指向的空間的內(nèi)容不可被修改

num是一個(gè)無(wú)符號(hào)整型

表示字節(jié)個(gè)數(shù)

函數(shù)作用：

從ptr1和ptr2分別指向空間首地址開始

一個(gè)字節(jié)一個(gè)字節(jié)，一一對(duì)應(yīng)進(jìn)行比較

比較num個(gè)字節(jié)，

當(dāng)ptr1大于ptr2返回大于0的數(shù)

當(dāng)ptr1等于ptr2返回?cái)?shù)字0

當(dāng)ptr1小于ptr2返回小于0的數(shù)

函數(shù)用途：如下代碼：

#include#includeint main()
{
	//創(chuàng)建兩個(gè)字符串
	char buffer1[] = "DWgaOtP12df0";
	char buffer2[] = "DWGAOTP12DF0";

	//將buffer1 跟 buffer2 的 前sizeof(buffer1) 個(gè)字節(jié) 進(jìn)行比較
	//一個(gè)字節(jié) 一個(gè)字節(jié) 往后一一比較 要是相同往后繼續(xù)比較
	//只要遇到不等的字節(jié) 就停止比較，返回這兩個(gè)字節(jié)比較的結(jié)果
	//buffer1 大于 buffer2 返回大于0的數(shù)字
	//buffer1 等于 buffer2 返回?cái)?shù)字0
	//buffer1 小于 buffer2 返回小于0的數(shù)
	int n = 0;
	n = memcmp(buffer1, buffer2, sizeof(buffer1));

	if (n >0) 
		printf("'%s' is greater than '%s'.\n", buffer1, buffer2);
	else if (n< 0) 
		printf("'%s' is less than '%s'.\n", buffer1, buffer2);
	else
		printf("'%s' is the same as '%s'.\n", buffer1, buffer2);

	return 0;
}

memset

內(nèi)存填充函數(shù)

函數(shù)原型：void * memset ( void * ptr, int value, size_t num );

返回值：void *

?返回任意類型的指針

?返回被修改后的內(nèi)存空間的地址

參數(shù)：void * ptr, int value, size_t num

ptr是一個(gè)任意類型的指針

指向一片任意類型的空間

value是一個(gè)有符號(hào)整型

表示要修改的值

num是一個(gè)無(wú)符號(hào)整型

表示要修改的字節(jié)數(shù)

函數(shù)作用：

將ptr指向的內(nèi)存塊

? 前num個(gè)字節(jié)的內(nèi)容設(shè)置為value

? 從ptr的位置開始向后num個(gè)字節(jié)

? 的內(nèi)容修改成value

函數(shù)用途：如下代碼

#include#includeint main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	//數(shù)組名表示數(shù)組首元素地址
	//將arr指向的內(nèi)存塊的前20個(gè)字節(jié),每個(gè)字節(jié)的內(nèi)容都設(shè)置為0
	memset(arr, 0, 20);
	int i = 0;
	for (i = 0; i< sz; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");

	char str[] = "xxxxxxxxx";
	//將str指向的內(nèi)存塊的前5個(gè)字節(jié)，每個(gè)字節(jié)的內(nèi)容都設(shè)置為'a’
	memset(str, 'a', 5);
	printf("%s\n", str);

	return 0;
}

庫(kù)函數(shù)的模擬實(shí)現(xiàn)

模擬實(shí)現(xiàn)strlen

函數(shù)原型：size_t strlen(const char* str);

原理：strlen函數(shù)是計(jì)算字符串的長(zhǎng)度

?也就是計(jì)算'\0'之前的字符的個(gè)數(shù)

模擬實(shí)現(xiàn)：

實(shí)現(xiàn)1：

#includesize_t my_strlen(const char* str)
{
	size_t count = 0;
	while (*str != '\0')
	{
		count++;
		str++;
	}
	return count;
}
int main()
{
	char str[] = "abcdefgh";
	size_t len = my_strlen(str);
	printf("%d\n", len);

	return 0;
}

實(shí)現(xiàn)2：

#include//遞歸方式實(shí)現(xiàn)
size_t my_strlen(const char* str)
{
	if (*str != '\0')
	{
		return 1 + my_strlen(str+1);
	}
	return 0;
}

int main()
{
	char str[] = "abcdefgh";
	size_t len = my_strlen(str);
	printf("%d\n", len);

	return 0;
}

實(shí)現(xiàn)3：

#includesize_t my_strlen(const char* str)
{
	char* p = str;
	while (*str++);
	return str - p - 1;
}
int main()
{
	char str[] = "abcdefgh";
	size_t len = my_strlen(str);
	printf("%d\n", len);

	return 0;
}

模擬實(shí)現(xiàn)strcpy

函數(shù)原型：char * strcpy ( char * destination, const char * source );

原理：strcpy就是將source指向空間的內(nèi)容

?復(fù)制到destination指向的空間里

?在復(fù)制的同時(shí)會(huì)將source的'\0'也復(fù)制過(guò)去

?復(fù)制完成后將str1返回

模擬實(shí)現(xiàn)：

#include#include 

//模擬實(shí)現(xiàn)strcpy
char* my_strcpy(char* str1, const char* str2)
{
	assert(str1 && str2);
	char* p = str1;
	while (*str1++ = *str2++);

	return p;
}

int main()
{
	char str1[50] = "xxxxxxxxxxxxxxxxxxxx";
	char str2[] = "abcdefg";
	
	//將str2的內(nèi)容賦值到str1中
	//str1的空間要足夠大
	my_strcpy(str1, str2);
	printf("%s\n", str1);

	return 0;
}

模擬實(shí)現(xiàn)strcat

函數(shù)原型：char * strcat ( char * destination, const char * source );

原理：將source指向的字符串的內(nèi)容

?追加到destination指向的字符串的后面

?追加的時(shí)候destination字符串的'\0'字符

?會(huì)被source字符串的首字符覆蓋

?且會(huì)將source字符串的'\0'也追加上來(lái)

?且返回追加完成后的destination

模擬實(shí)現(xiàn)；

#include#include 

//模擬實(shí)現(xiàn) strcat
char* my_strcat(char* dest, const char* src)
{
	assert(dest && src);
	char* p = dest;
	while (*dest)
	{
		dest++;
	}
	while ((*dest++ = *src++));

	return p;
}

int main()
{
	char str1[50] = "abcdef";
	char str2[] = "ghijklmn";

	//將str2字符串的內(nèi)容追加到str1后面
	//在追加的時(shí)候會(huì)將str1字符串的'\0'覆蓋掉
	my_strcat(str1, str2);
	printf("%s\n", str1);

	return 0;
}

模擬實(shí)現(xiàn)strstr

函數(shù)原型：const char * strstr ( const char * str1, const char * str2 );

原理：尋找str1這個(gè)字符串中是否包含str2字符串

若是包含則返回str2第一次出現(xiàn)的位置

否則返回NULL

也就是判斷str2是否是str1的子串

模擬實(shí)現(xiàn)：

#include#include 

//模擬實(shí)現(xiàn)strstr函數(shù)
char* my_strstr(const char* str1, const char* str2)
{
	assert(str1 && str2);
	char* p = (char*)str1;
	char* s1 = NULL;
	char* s2 = NULL;
	if (*str2 == '\0')
	{
		return (char*)str1;
	}
	while (*p)
	{
		s1 = p;
		s2 = (char*)str2;
		while (*s1 && *s2 && !(*s1 - *s2))
		{
			s1++;
			s2++;
		}
		if (!*s2)
		{
			return p;
		}
		p++;
	}
	return NULL;
}

int main()
{
	char str1[] = "kkkabcdefghijklmnabcdefgxyz";
	char str2[] = "abcdef";

	//查找str2是否是str1的子串
	//若是返回str2第一次出現(xiàn)的位置
	//不是則返回NULL
	char* p = my_strstr(str1, str2);
	if (p == NULL)
	{
		printf("不是子串\n");
	}
	else
	{
		printf("是子串\n");
		printf("從返回的地址處開始打印：%s\n", p);
	}

	return 0;
}

模擬實(shí)現(xiàn)strcmp

函數(shù)原型：int strcmp ( const char * str1, const char * str2 );

原理： 讓str1字符串與str2字符串

?從首字符開始一個(gè)字符一個(gè)字符向后比較

?若兩個(gè)字符相等則繼續(xù)向后比較

?直到出現(xiàn)兩個(gè)字符不等的情況下停止比較

?并且返回這兩個(gè)不同字符比較的結(jié)果

?若str1大于str2返回大于0的數(shù)

?若str1等于str2返回等于0的數(shù)

?若str1小于str2返回小于0的數(shù)

模擬實(shí)現(xiàn)：

#include#include 

//模擬實(shí)現(xiàn)strcmp函數(shù)
int my_strcmp(const char* str1, const char* str2)
{
	assert(str1 && str2);

	while (*str1 && *str2)
	{
		if (*str1 == *str2)
		{
			str1++;
			str2++;
		}
		else
		{
			return (*str1 - *str2);
		}
	}

	return (*str1 - *str2);
}

int main()
{
	char str1[] = "abcdefg";
	char str2[] = "abcdhjk";

	int ret = my_strcmp(str1, str2);
	if (ret == 0)
	{
		printf("str1 = str2\n");
	}
	else if (ret >0)
	{
		printf("str1 >str2\n");
	}
	else
	{
		printf("str1< str2\n");
	}
	return 0;
}

模擬實(shí)現(xiàn)memcpy

函數(shù)原型：void * memcpy ( void * destination, const void * source, size_t num );

原理：將source指向的內(nèi)存塊中

?num個(gè)字節(jié)的內(nèi)容復(fù)制到

?destination指向的內(nèi)存塊中

?返回復(fù)制完成后的destination

一般情況下不能勝任重疊拷貝

也就是自己拷貝自己

模擬實(shí)現(xiàn)：

#include#include 

//模擬實(shí)現(xiàn)memcpy
void* my_memcpy(void* dest, void* src, size_t num)
{
	assert(dest && src);
	void* p = dest;
	while (num--)
	{
		*(char*)dest = *(char*)src;
		++(char*)dest;
		++(char*)src;
	}
	return p;
}

int main()
{
	//拷貝整型
	int arr[] = { 1,2,3,4,5 };
	int brr[] = { 6,7,8,9,10 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	my_memcpy(arr,brr,8);
	int i = 0;
	for (i = 0; i< sz; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");

	//拷貝字符串
	char str1[] = "xxxxxxxxxx";
	char str2[] = "abcde";
	my_memcpy(str1, str2, 5);
	printf("%s\n", str1);

	return 0;
}

模擬實(shí)現(xiàn)memmove

函數(shù)原型：void * memmove ( void * destination, const void * source, size_t num );

原理：將source指向的內(nèi)存塊中

?num個(gè)字節(jié)的內(nèi)容復(fù)制到

?destination指向的內(nèi)存塊中

?返回復(fù)制完成后的destination

?完全勝任重疊拷貝

?可以自己拷貝自己

模擬實(shí)現(xiàn)：

#include#include 

//模擬實(shí)現(xiàn),memmove
//可實(shí)現(xiàn)重疊拷貝
//當(dāng)destsrc時(shí)從后向前
//當(dāng)dest=src時(shí)從前向后 從后向前

void* my_memmove(void* dest, void* src, size_t num)
{
	void* p = dest;
	assert(dest && src);
	if (dest >src)
	{
		dest = (char*)dest + num-1;
		src = (char*)src + num-1;
		while (num--)
		{
			*(char*)dest = *(char*)src;
			dest=(char*)dest-1;
			src=(char*)src-1;
		}
	}
	else
	{
		while (num--)
		{
			*(char*)dest = *(char*)src;
			++(char*)dest;
			++(char*)src;
		}
	}
	return p;
}

int main()
{
	//拷貝整型
	int arr[] = { 6,7,8,9,10 };
	int brr[] = { 1,2,3,4,5 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	my_memmove(arr, brr, 12);
	int i = 0;
	for (i = 0; i< sz; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");

	//拷貝字符串
	char str1[] = "yyyyyyyyyy";
	char str2[] = "abcdef";
	my_memmove(str1, str2, 4);
	printf("%s\n", str1);

	//重疊拷貝
	int prr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int s = sizeof(prr) / sizeof(prr[0]);
	my_memmove(prr + 5, prr, 12);
	int j = 0;
	for (j = 0; j< s; j++)
	{
		printf("%d ", prr[j]);
	}
	return 0;
}

你是否還在尋找穩(wěn)定的海外服務(wù)器提供商？創(chuàng)新互聯(lián)www.cdcxhl.cn海外機(jī)房具備T級(jí)流量清洗系統(tǒng)配攻擊溯源，準(zhǔn)確流量調(diào)度確保服務(wù)器高可用性，企業(yè)級(jí)服務(wù)器適合批量采購(gòu)，新人活動(dòng)首月15元起，快前往官網(wǎng)查看詳情吧

當(dāng)前標(biāo)題：字符串+內(nèi)存函數(shù)（C語(yǔ)言）-創(chuàng)新互聯(lián)
文章來(lái)源：http://muchs.cn/article10/dgidgo.html

成都網(wǎng)站建設(shè)公司_創(chuàng)新互聯(lián)，為您提供服務(wù)器托管、建站公司、網(wǎng)站策劃、外貿(mào)網(wǎng)站建設(shè)、用戶體驗(yàn)、外貿(mào)建站

廣告

聲明：本網(wǎng)站發(fā)布的內(nèi)容（圖片、視頻和文字）以用戶投稿、用戶轉(zhuǎn)載內(nèi)容為主，如果涉及侵權(quán)請(qǐng)盡快告知，我們將會(huì)在第一時(shí)間刪除。文章觀點(diǎn)不代表本網(wǎng)站立場(chǎng)，如需處理請(qǐng)聯(lián)系客服。電話：028-86922220；郵箱：631063699@qq.com。內(nèi)容未經(jīng)允許不得轉(zhuǎn)載，或轉(zhuǎn)載時(shí)需注明來(lái)源： 創(chuàng)新互聯(lián)