strlen函數(shù)

1.函數(shù)原型

size_t strlen（const char *string );

我們也可以打開MSDN查看他的原型

?2.函數(shù)功能：求一個(gè)字符串指定string字符串的長度

3.strlen函數(shù)的實(shí)現(xiàn)：

實(shí)現(xiàn)的思想是這樣的我們只要讓一個(gè)指針指向字符串的起始位置，讓他一直往后走直到遇到/0就停止在上述過程中用計(jì)數(shù)器count統(tǒng)計(jì)str走了多少步，count的值就是這個(gè)字符串的長度了

說明：

strlen() 函數(shù)計(jì)算的是字符串的實(shí)際長度，遇到第一個(gè)’/0’結(jié)束；
參數(shù)指向的字符串必須以 ’ /0 ‘結(jié)束
函數(shù)返回值一定是size_t ,是無符號的
如果你只定義沒有給它賦初值，這個(gè)結(jié)果是不定的，它會從首地址一直找下去，直到遇到’/0’停止
sizeof返回的是變量聲明后所占的內(nèi)存數(shù)，不是實(shí)際長度，此外sizeof不是函數(shù)，僅僅是一個(gè)操作符，strlen()是函數(shù)
這是特別要注意的?。。。。。。。。。。。。。。。。。。。。。。。。。。。。?/p>

代碼實(shí)現(xiàn)：

#include#includeint my_strlen(const char* str)//我們只是要求一下他的長度并不會修改他所以加const保護(hù)字符串{	assert(str);//斷言防止str為空指針	int count = 0;	while (*str!="/0")	{		str++;		count++;//計(jì)數(shù)	}	return count;}int main(){	char arr[] = "abcd";	int ret=my_strlen(arr);	printf("%d", ret);}

?方法2：遞歸方法（重點(diǎn)，以后面試可能會問到）

#include#includeint my_strlen(const char* str)//我們只是要求一下他的長度并不會修改他所以加const保護(hù)字符串{	assert(str);//斷言防止str為空指針	if (*str)	{		return 1 + my_strlen(++str);	}	else	{		return 0;	}}int main(){	char arr[] = "abcd";	int ret=my_strlen(arr);	printf("%d", ret);}

方法3：指針減指針

#include#includeint my_strlen(const char* str)//我們只是要求一下他的長度并不會修改他所以加const保護(hù)字符串{	assert(str);//斷言防止str為空指針	const char* start = str;	const char* end = str;	while (*end != "/0")	{		end++;	}	return end - start;}int main(){	char arr[] = "abcdf";	int ret=my_strlen(arr);	printf("%d", ret);}

strcpy（）函數(shù)

1.函數(shù)原型：

?2.函數(shù)功能：將參數(shù)str字符串拷貝到參數(shù)dest所指向的字符串的地址中.注入事項(xiàng)：strcpy拷貝的時(shí)候是要拷貝到"/0"才停止拷貝。所以一定要保證目的地空間足夠大.我strcpy的脾氣就是我要拷貝到‘/0"我才停止你空間足不足夠我才不關(guān)心，我只負(fù)責(zé)拷貝其他的我不管。

說明：

? ?1.? 源字符串必須以’/0’結(jié)束

? 2. 會將源字符串的’/0’拷貝到目標(biāo)空間

? 3.目標(biāo)空間必須可變

? 4. 如果參數(shù)dest所指的內(nèi)存空間不夠大，可能會造成緩沖溢出的錯(cuò)誤情況，在編寫程序時(shí)需特別留意，或者用strncpy()來取代

#include#includeint main(){	char arr1[] = "abcdef";	char arr2[] = "abc";char *ret=strcpy(arr2, arr1);printf(ret);}

在這個(gè)實(shí)驗(yàn)中我們把a(bǔ)rr1的內(nèi)容拷貝到arr2中但是arr2中的空間只有4個(gè)字節(jié)而arr1是有7個(gè)字節(jié)，我們一起來看一下啊運(yùn)行結(jié)果：

?我們可以看到雖然字符串a(chǎn)rr1被拷貝到arr2中去了但此時(shí)程序已經(jīng)崩潰了。所以我們在使用strcpy時(shí)一定要確保目的地空間足夠大。

3.代碼實(shí)現(xiàn)：

#include#includechar* my_strcpy(char* dest, const char* src){	assert(dest && src);//防止dest和src為空指針	char* ret = dest;	while (*src)	{		*dest = *src;		dest++;		src++;	}	*dest = *src;//將src中的’/0"拷貝到dest中	return ret;}int main(){	char arr1[] = "abcdef";	char arr2[] = "abv";	char*ret=my_strcpy(arr1, arr2);	printf(ret);}

運(yùn)行結(jié)果：

?拷貝前：

拷貝后：

在上面這個(gè)版本上我們還可以進(jìn)行改進(jìn)：

#include#includechar* my_strcpy(char* dest, const char* src){	assert(dest && src);//防止dest和src為空指針	char* ret = dest;	while (*dest++ = *src++)		;	return ret;}int main(){	char arr1[] = "abcdef";	char arr2[] = "abv";	char*ret=my_strcpy(arr1, arr2);	printf(ret);}

strcmp（）函數(shù)

1.函數(shù)原型：

2.函數(shù)功能：

字符串進(jìn)行比較

我們通過文檔我們可以知道：如果第一個(gè)字符串小于第二個(gè)返回的是小于0的數(shù)如果第一個(gè)字符串等于第二個(gè)返回的·是0如果第一個(gè)字符串大于第二個(gè)字符串返?回的是大于0的數(shù)字

原型：strcmp(str1,str2);

功能：比較兩個(gè)字符串，如果兩個(gè)字符串相等，則返回0；若str1大于str2（對于大于的理解，是指從兩個(gè)字符串的第一個(gè)字符開始比較，若兩個(gè)字符相同，則繼續(xù)比較，若發(fā)現(xiàn)兩個(gè)字符不相等，且str1中該字符的ASCII碼大于str2中的，則表示str1大于str2），返回一個(gè)正數(shù)（這個(gè)正數(shù)不一定是1）；若str1小于str2，返回一個(gè)負(fù)數(shù)（不一定是-1）；若字符串str1的長度大于str2，且str2的字符與str1前面的字符相同，則也相對于str1大于str2處理

區(qū)分大小寫比較的，如果希望不區(qū)分大小寫進(jìn)行字符串比較，可以使用stricmp函數(shù)

?首先判斷第一個(gè)字符是否相等如果相等直接繼續(xù)往后走直到兩個(gè)不相等

3.代碼實(shí)現(xiàn)：

#includeint my_strcmp(const char* dest, const char* src){            assert(dest&&src);	while (*dest == *src)	{		if (*dest == "/0")//如果dest等于‘/0"說明這兩個(gè)字符串相等相等返回0		{			return 0;		}		dest++;		src++;	}	return *dest - *src;//說明這兩個(gè)字符串不相等，返回他們第一不相等字符的差值}int main(){	char str1[] = "abcde";	char str2[] = "abcdrq";	int ret = my_strcmp(str1, str2);	printf("%d", ret);}

strcat()函數(shù)

1.函數(shù)聲明原型

?2.函數(shù)功能：字符串拼接函數(shù)

實(shí)現(xiàn)思路大致是:先找到dest’/0"的位置，然后從該位置將str中的內(nèi)容向后面追加

追加前：

追加后：

?我們也可以調(diào)試看到：

注意！

1.源字符串必須’/0’結(jié)束
2. 目標(biāo)空間必須可修改
3.strcat() 會將參數(shù)src字符串復(fù)制到參數(shù)dest所指的字符串尾部
4.dest最后的結(jié)束字符’/0’會被覆蓋掉，并在連接后的字符串的尾部再增加一個(gè)’/0’
5.dest與src所指的內(nèi)存空間不能重疊，且dest要有足夠的空間來容納要復(fù)制的字符串
6.所以不能夠自己給自己拷貝因?yàn)椤?0"已經(jīng)被覆蓋了而strcat是要追加到‘/0"才停止追加?。。。。。。?/p>

代碼實(shí)現(xiàn)：

#include#include#includechar* my_strcat(char* dest, const char* src){	assert(dest && src);	char* ret = dest;	while (*dest)	{		dest++;//找到dest所指向的字符串"/0’的位置	}	while (*dest++ = *src++)		;	return ret;}int main(){	char str1[] = "abcded/0XXXXXXX";	char str2[] = "abc";	my_strcat(str1, str2);	printf("%s", str1);	return 0;}

strchr

1.函數(shù)原型

2.函數(shù)功能：

功能：在str字符串中查找首次出現(xiàn)字符c的位置（從字符串的首地址開始查找）

原型2：strrchr(str,c);

功能2：在字符串str中從后向前開始查找字符c首次出現(xiàn)的位置

3.代碼實(shí)現(xiàn)：

#include#includechar* my_strchr(const char* str, int ch){	assert(str);	char* ret = (char*)str;	while (*ret)	{		if (*ret ==(char) ch)		{			return ret;		}		ret++;	}	return NULL;}int main(){	char str[] = "abcdefhfmg";	char* tmp = my_strchr(str, "0");	if (tmp == NULL)	{		printf("找不到");		return 0;	}	printf("%c", *tmp);}

strrchr（）函數(shù)

1.函數(shù)原型：

?2。函數(shù)功能：

查找一個(gè)字符c在一個(gè)字符串string最后一次出現(xiàn)的位置（也就是從字符串的右側(cè)開始查找字符c首次出現(xiàn)的位置）并返回從字符串中的字符c所在的位置開始直到結(jié)束的所有字符，如果沒有找到字符c則返回空指針即NULL

3.代碼實(shí)現(xiàn)：

#include#includechar* my_strrchr(const char* str,int ch){	assert(str);	char* ret = NULL;	while (*str)	{		if (*str == (char)ch)		{			ret = str;		}		str++;	}	return ret;}int main(){	char str[] = "abcdeabcef";	char* tmp = my_strrchr(str, "a");	printf(tmp);}

strncpy()函數(shù)

1.函數(shù)原型：

2.函數(shù)功能

功能：將字符串str2中的前n個(gè)字符復(fù)制到字符串str1的前n個(gè)字符中

注意：（1）不會清除str1中全部字符串，只會改變前n個(gè)字符串，

（2）n不能大于字符串str1、str2的長度

（3）但是如果使用strncpy_s便會清除str1中的全部字符串

說明：

• 如果src字符串長度小于n，則拷貝完字符串后，在目標(biāo)后追加0，直到num個(gè)
• strncpy不會向dest追加’/0’
• src和dest所指的內(nèi)存區(qū)域不能重疊，且dest必須有足夠的空間放置n個(gè)字符

3.代碼實(shí)現(xiàn)

#include#include#includechar* my_strncpy(char* dest, const char* src, int n){	assert(dest && src);	char* tmp = dest;	while ((n--) && (*dest++ = *src++));	if (n > 0)	{		while (n--)		{			*dest++ = "/0";		}	}	return tmp;}int main(){	char str1[] = "abcdeXXXXXXXXXXXX";	char str2[] = "avcdf";	char* ret =my_strncpy(str1, str2, 6);	return 0;}

雖然比strncpy要安全一點(diǎn)但還是要注意要保證目的地空間足夠

strncat

1.函數(shù)原型：

?函數(shù)功能：

該函數(shù)會將字符串src的開頭拷貝n個(gè)字符到dest的尾部，dest要有足夠的空間來容納要拷貝的字符串，如果n大于src的長度，那么只會把src僅有的字符串內(nèi)容追加到dest的尾部。strncat會將dest里面的‘/0’覆蓋掉字符追加完畢后自動加一個(gè)‘/0"

也就相當(dāng)于這樣：

我們在上面那個(gè)長的字符串從下面這個(gè)字符串中追加2個(gè)字符那么結(jié)果將為：

通過調(diào)試我們也能夠證明上面這個(gè)是對的：

如果追加3個(gè)字符那么結(jié)果和上面是一樣的。大家可以做實(shí)驗(yàn)驗(yàn)證

注意！?。。?！

• strncat將會從字符串src的開頭拷貝n個(gè)字符到dest字符串尾部
• dest要有足夠的空間來容納要拷貝的字符串
• 如果n大于字符串src的長度，那么僅將src全部追加到dest的尾部
• strncat會將dest字符串最后的’/0’覆蓋掉，字符追加完成后，再追加’/0’

代碼實(shí)現(xiàn)：

#include#include#includechar* my_strncat(char* dest, const char* src, int n){	assert(dest && src);	char* ret = dest;	while (*dest)	{		++dest;	}	for (int i = 0; i < n; i++)	{		if (*src)		{			*dest = *src;			dest++;			src++;		}		else		{			break;		}		}	*dest = "/0";	return ret;}int main(){	char str1[] = "abcde/0XXXXXX";	char str2[] = "avbv";	strncat(str1, str2, 2);	return 0;}

strncmp()函數(shù)

1.函數(shù)原型：

2.函數(shù)功能：strncmp的功能和strcmp的功能和相似，只不過多了一個(gè)參數(shù)用來確定比較的個(gè)數(shù)

3。代碼實(shí)現(xiàn)：

#include#include#includeint my_strncmp(const char* dest, const char* src, int n){	assert(dest && src);	while ((n--) && (*dest) && (*src) && (*src == *dest))	{		src++;		dest++;	}	return *dest - *src;}int main(){	char str1[] = "abcdef";	char str2[] = "abcf";	int ret = my_strncmp(str1, str2, 2);		printf("%d", ret);}

strstr（）函數(shù)

函數(shù)原型：

?2.函數(shù)功能：

在字符串中找子串原理是string中是否包含strcharset如果包含就返回第一個(gè)出現(xiàn)字符的地址，如果沒有就返回空指針

3.代碼實(shí)現(xiàn)。

#include#includechar* my_strstr(const char* dest, const char* src){	assert(dest && src);	if (!*src)	{		return (char*)dest;	}	const char* cur =dest;	const char* s1;	const char* s2;	s1 = s2 = NULL;	while (cur)	{		s1 = cur;		s2 = src;		while ((*s1) && (*s2) && (*s1 == *s2))		{			s1++;			s2++;		}		if (*s2 == "/0")		{			return (char*)cur;		}		cur++;	}	return NULL;//找不到字串}int main(){	char str1[] = "abcdef";	char str2[] = "bcdef";	printf(my_strstr(str1, str2));}

strtoke（）函數(shù)

1.函數(shù)原型:

2.函數(shù)功能：

功能：根據(jù)分隔符將字符串分隔成一個(gè)個(gè)片段
返回值：返回下一個(gè)分割后的字符串指針，如果已無從分割則返回NULL
說明：
1.sep參數(shù)是個(gè)字符串，定義了用作分隔符的字符集合
2.第一個(gè)參數(shù)指定一個(gè)字符串，它包含了一個(gè)或者多個(gè)由sqp字符串中一個(gè)或者多個(gè)字符分割的標(biāo)記
3.第一次調(diào)用時(shí)將字符串首地址傳進(jìn)去，之后調(diào)用不用傳地址，內(nèi)部會有static函數(shù)保存指向地址
4.分隔符不作為輸出內(nèi)容，只做分界符
5. 當(dāng)strtok在參數(shù)s的字符串中發(fā)現(xiàn)到參數(shù)sep的分割字符時(shí)則會將該字符改為’/0’字符
6. 在第一次調(diào)用時(shí)，strtok必須賦予參數(shù)str字符串，往后的調(diào)用則將參數(shù)s設(shè)置成NULL
7.strtok會修改原字符串，所以必須放至棧上

代碼實(shí)現(xiàn)：

char* strtok1(char* str, const char* sep){	static int ret = 0;//這個(gè)靜態(tài)變量也十分重要！當(dāng)指針指向最后一個(gè) 字符串str 出現(xiàn)的 sep字符分隔符，	//因?yàn)樽詈笠欢巫址⒉粫俪霈F(xiàn)sep中任何一個(gè)分隔符，所以字符串就不會打印，	//那我們?nèi)绾螀^(qū)分這種情況和str中就從來沒有出現(xiàn)過sep字符的情況，我們設(shè)置一個(gè)靜態(tài)變量，如果靜態(tài)變量被修改過，就輸出字符串，如果沒修改過就返回空指針。	static char* a = NULL;       //這里要用到靜態(tài)變量，這樣函數(shù)結(jié)束變量就不會銷毀，a會記住上一次的地址	if (str != NULL)               // 判斷是否為NULL	{		a = str;		ret = 0;	}	else	{		if (ret == 2)			return NULL;		a++;	}	char* first = a;	while (*a)	{		const char* p = sep;		while (*p)		{			if (*p == *a)			{				*a = "/0";				ret = 1;				return first;			}			p++;		}		a++;		if (*a == "/0")		{			ret = 2;			break;		}	}	if (ret == 0)		return NULL;	else if(ret == 2)		return first;}

其實(shí)這里還有一些函數(shù)博主就不一 一實(shí)現(xiàn)就在這里簡單的介紹一個(gè)就可以了

? ? ? ? ? ? ? ? ? ? ? ? ?

模擬實(shí)現(xiàn)atoi（）函數(shù)

1.函數(shù)原型：

int atoi(const char* str)

2.函數(shù)功能

將字符串轉(zhuǎn)換成整數(shù)

注意：

返回值：每個(gè)函數(shù)返回?int?值，此值由將輸入字符作為數(shù)字解析而生成。?如果該輸入無法轉(zhuǎn)換為該類型的值，則atoi的返回值為?0。

工作原理：atoi通過全局變量來區(qū)分返回0的情況。
如果是非法輸入，返回0，并把這個(gè)全局變量設(shè)為特殊標(biāo)志；
如果輸入是”0”，則返回0，不會設(shè)置全局變量。

使用該函數(shù)時(shí)要注意atoi返回的是int類型，注意輸入str的范圍不要超出int類型的范圍。

3.函數(shù)實(shí)現(xiàn)：

#include#include#include#include#includeint my_atoi(const char* str){	assert(str);	long long ret = 0;	int flag = 1;	if (!*str)	{		return 0;	}	while (isspace(*str))	{		str++;	}	if (*str == "+")	{		str++;	}	else if (*str == "-")	{		flag = -1;		str++;	}	while (isdigit(*str))	{		ret = ret * 10 + *str - "0";		if (ret > INT_MAX || ret < INT_MIN)//超出整型最大說明溢出了		{			return 0;		}		str++;	}	if (*str == "/0")	{		return (int)ret*flag;	}	return (int)flag*ret;}int main(){	int tmp = my_atoi("-123");	printf("%d", tmp);}

模擬實(shí)現(xiàn)itoa()函數(shù)

代碼實(shí)現(xiàn)：

#include#includevoid my_reverse(char* str){	int right= strlen(str)-1;	int left = 0;	while (left 

#include#include#includedouble my_atof(const char* str){	double ret = 0;	int flag = 1;	int count = 0;	assert(str);	while (isspace(*str))	{		str++;	}	while (*str)	{		if (count)		{			count = count * 10;		}		if (*str == "+")		{			str++;		}		else if (*str=="-")		{			str++;			flag = -1;		}		else if (*str == ".")		{			count++;			str++;		}		else if ((*str>="0")&&(*str<="9"))		{			ret = ret * 10 + (double)(*str - "0");			str++;		}		else		{			return 0;		}	}	return ret * flag / count;}int main(){	double tmp = my_atof("123.3abc");	printf("%.2lf", tmp);}

#include#includevoid* my_memcpy(void* dest, const void* src, int n){	assert(dest && src);	void* ret = dest;	while (n--)	{		*(char*)dest = *(char*)src;		dest = (char*)dest + 1;		src = (char*)src + 1;	}	return ret;}int main(){	int arr1[10] = { 0 };	int arr2[] = { 1,2,3,4,5 };	my_memcpy(arr1, arr2, 20);	for (int i = 0; i < 10; i++)	{		printf("%d ", arr1[i]);	}	return 0;}

#include#includeint my_memcmp(const void* str1, const void* str2, int num){	if (num == 0)	{		return 0;	}	assert(str1 && str2);	char* s1 = (char*)str1;	char* s2 = (char*)str2;	while ((num--)&&(*s1==*s2)&&*s1&&*s2)	{		s1++;		s2++;	}	return *s1 - *s2;}int main(){	int arr1[10] = { 1,2,3,4,5 };	int arr2[10] = { 5,2,3,5 };	int tmp = my_memcmp(arr1, arr2, 0);	printf("%d", tmp);}

#include#includevoid* my_memset(void* dest, int val, int num){	assert(dest);	char* s1 = (char*)dest;	void* ret = dest;	while (num--)	{		*s1 = (char)val;		s1++;	}	return ret;}int main(){	int arr[10];	my_memset(arr, 0, 40);	for (int i = 0; i < 10; i++)	{		printf("%d ", arr[i]);	}}

void* my_memchr(const void* dest, int c, int num){	assert(dest);	char* ret = (char*)dest;	while (num--)	{		if ((char)c == *ret)		{			return ret;		}		else		{			ret++;		}	}	return NULL;}

void *my_memove(void* dest, const void* src, int num){	assert(dest && src);	void* ret = dest;	if(dest

int mySqrt(int x){long tmp = x;        while (tmp*tmp > x)        {            tmp = (tmp + x/tmp) / 2;        }        return (int)tmp;        }

double myPow(double x, int n) {        if(x == 1 || n == 0)         {            return 1;        }        double tmp = 1;        long count=n;        if(n < 0){            count = -count;            x = 1/x;        }        while(count)        {            if(count & 1)             {                tmp *= x;            }            x *= x;               count>>= 1;        }        return tmp;    }

#includeint my_abs(int n){	int tmp = n >> 31;	return (n ^ tmp) - tmp;}int main(){	int tmp = my_abs(10);	printf("%d", tmp);}