strlen函數

1.函數原型

size_t strlen（const char *string );

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

?2.函數功能：求一個字符串指定string字符串的長度

3.strlen函數的實現：

實現的思想是這樣的我們只要讓一個指針指向字符串的起始位置，讓他一直往后走直到遇到/0就停止在上述過程中用計數器count統計str走了多少步，count的值就是這個字符串的長度了

說明：

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

代碼實現：

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

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

#include#includeint my_strlen(const char* str)//我們只是要求一下他的長度并不會修改他所以加const保護字符串{	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保護字符串{	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（）函數

1.函數原型：

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

說明：

? ?1.? 源字符串必須以’/0’結束

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

? 3.目標空間必須可變

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

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

在這個實驗中我們把arr1的內容拷貝到arr2中但是arr2中的空間只有4個字節而arr1是有7個字節，我們一起來看一下啊運行結果：

?我們可以看到雖然字符串arr1被拷貝到arr2中去了但此時程序已經崩潰了。所以我們在使用strcpy時一定要確保目的地空間足夠大。

3.代碼實現：

#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);}

運行結果：

?拷貝前：

拷貝后：

在上面這個版本上我們還可以進行改進：

#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（）函數

1.函數原型：

2.函數功能：

字符串進行比較

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

原型：strcmp(str1,str2);

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

區分大小寫比較的，如果希望不區分大小寫進行字符串比較，可以使用stricmp函數

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

3.代碼實現：

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

strcat()函數

1.函數聲明原型

?2.函數功能：字符串拼接函數

實現思路大致是:先找到dest’/0"的位置，然后從該位置將str中的內容向后面追加

追加前：

追加后：

?我們也可以調試看到：

注意！

1.源字符串必須’/0’結束
2. 目標空間必須可修改
3.strcat() 會將參數src字符串復制到參數dest所指的字符串尾部
4.dest最后的結束字符’/0’會被覆蓋掉，并在連接后的字符串的尾部再增加一個’/0’
5.dest與src所指的內存空間不能重疊，且dest要有足夠的空間來容納要復制的字符串
6.所以不能夠自己給自己拷貝因為’/0"已經被覆蓋了而strcat是要追加到‘/0"才停止追加！！！！！！！

代碼實現：

#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.函數原型

2.函數功能：

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

原型2：strrchr(str,c);

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

3.代碼實現：

#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（）函數

1.函數原型：

?2。函數功能：

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

3.代碼實現：

#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()函數

1.函數原型：

2.函數功能

功能：將字符串str2中的前n個字符復制到字符串str1的前n個字符中

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

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

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

說明：

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

3.代碼實現

#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要安全一點但還是要注意要保證目的地空間足夠

strncat

1.函數原型：

?函數功能：

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

也就相當于這樣：

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

通過調試我們也能夠證明上面這個是對的：

如果追加3個字符那么結果和上面是一樣的。大家可以做實驗驗證

注意！！！！！

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

代碼實現：

#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()函數

1.函數原型：

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

3。代碼實現：

#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（）函數

函數原型：

?2.函數功能：

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

3.代碼實現。

#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（）函數

1.函數原型:

2.函數功能：

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

代碼實現：

char* strtok1(char* str, const char* sep){	static int ret = 0;//這個靜態變量也十分重要！當指針指向最后一個 字符串str 出現的 sep字符分隔符，	//因為最后一段字符串并不會再出現sep中任何一個分隔符，所以字符串就不會打印，	//那我們如何區分這種情況和str中就從來沒有出現過sep字符的情況，我們設置一個靜態變量，如果靜態變量被修改過，就輸出字符串，如果沒修改過就返回空指針。	static char* a = NULL;       //這里要用到靜態變量，這樣函數結束變量就不會銷毀，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;}

其實這里還有一些函數博主就不一 一實現就在這里簡單的介紹一個就可以了

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

模擬實現atoi（）函數

1.函數原型：

int atoi(const char* str)

2.函數功能

將字符串轉換成整數

注意：

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

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

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

3.函數實現：

#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);}

模擬實現itoa()函數

代碼實現：

#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);}