函数的作用和实现

一:函数的作用和实现

一.[strlen库函数的用法](strlen - C++ Reference (cplusplus.com))

• The length of string.

/* strlen example */
#include <stdio.h>
#include <string.h>

int main ()
{
  char szInput[256];
  printf ("Enter a sentence: ");
  gets (szInput);
  printf ("The sentence entered is %u characters long.\n",(unsigned)strlen(szInput));
  return 0;
}

三.[strcpy函数的用法](strcpy - C++ Reference (cplusplus.com))

• 源字符串必须以 ‘\0’ 结束。
• 会将源字符串中的 ‘\0’ 拷贝到目标空间。
• 目标空间必须足够大，以确保能存放源字符串。
• 目标空间必须可变。
• 学会模拟实现。

#include<stdio.h>
int main() {
	char arr1[] = "abcddf";
	char arr2[20] = { 0 };
	strcpy(arr2, arr1);
	printf("%s", arr2);
}

四:[strcat](strcat - C++ Reference (cplusplus.com))函数的用法

• 标准规定:

  • 第一个字符串大于第二个字符串，则返回大于0的数字
  • 第一个字符串等于第二个字符串，则返回0
  • 第一个字符串小于第二个字符串，则返回小于0的数字
  • 那么如何判断两个字符串？

  #include <stdio.h>
  #include <string.h>
  
  int main()
  {
  	char str[80];
  	strcpy(str, "these ");
  	strcat(str, "strings ");
  	strcat(str, "are ");
  	strcat(str, "concatenated.");
  	puts(str);
  	return 0;
  }
  

五:[strcmp函数的用法](strcmp - C++ Reference (cplusplus.com))

• 标准规定
  • 第一个字符串大于第二个字符串，则返回大于0的数
  • 第一个字符串等于第二个字符串，则返回0
  • 第一个字符串小于第二个字符串，则返回小于0的数字
  • 那么如何判断两个字符串

#include <stdio.h>
#include <string.h>

int main()
{
    char key[] = "apple";
    char buffer[80];
    do {
        printf("Guess my favorite fruit? ");
        //ffush,刷新缓冲区 保证输出的准确性和及时性,比如后面如果有‘\n'会及时刷新清除
        //fflush(stdout);
        scanf("%s", buffer);
    } while (strcmp(key, buffer) != 0);
    puts("Correct answer!");
    return 0;
}

二:几个可以拷贝字节的库函数

一:[strncpy库函数的用法](strncpy - C++ Reference (cplusplus.com))

• 拷贝num个字符从源字符串到目标空间。
• 如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个。

/* strncpy example */
#include <stdio.h>
#include <string.h>

int main ()
{
  char str1[]= "To be or not to be";
  char str2[40];
  char str3[40];

  /* copy to sized buffer (overflow safe): */
  strncpy ( str2, str1, sizeof(str2) );

  /* partial copy (only 5 chars): */
  strncpy ( str3, str2, 5 );
  str3[5] = '\0';   /* null character manually added */

  puts (str1);
  puts (str2);
  puts (str3);

  return 0;
}

二:[strncat库函数的用法](strncat - C++ Reference (cplusplus.com) )

• Appends the first num characters of source to destination, plus a terminating null-character.
• If the length of the C string in source is less than num, only the content up to the terminating null character is copied

#include<stdio.h>
#include<string.h>
int main() {
	char arr1[20] = "abcdef";
	char arr2[20] = "bcdefgh";
	strncat(arr1, arr2,6);
	printf("%s", arr1);
}

三:[strncmp库函数的用法](strncmp - C++ Reference (cplusplus.com))

• 比较到出现另个字符不一样或者一个字符串结束或者num个字符全部比较完。
• 

/* strncmp example */
#include <stdio.h>
#include <string.h>

int main ()
{
  char str[][5] = { "R2D2" , "C3PO" , "R2A6" };
  int n;
  puts ("Looking for R2 astromech droids...");
  for (n=0 ; n<3 ; n++)
  //放入首元素的地址
    if (strncmp (str[n],"R2xx",2) == 0)
    {
      printf ("found %s\n",str[n]);
    }
  return 0;
}

四:[strstr库函数的用法](strstr - C++ Reference (cplusplus.com))

• Returns a pointer to the first occurrence of str2 in str1, or a null pointer if str2 is not part of str1.

• 下面是一个例子,观察一个字符串里面有没有另一个字符串

#include<string.h>
#include<stdio.h>
#include<assert.h>
char* my_strstr(const char* str1, const char* str2) {
	assert(str1, str2);
	if (*str2 == '\0') {
		return str1;
	}
	const char* s1 = str1;
	const char* s2 = str2;
	const char* cp = str1;
	while (*cp) {
		
		s1 = cp;
		s2 = str2;
		while (*s1!='\0'&&*s2!='\0'&& * s1 == *s2) {
			s1++;
			s2++;
		}
		if (*s2 == '\0')
			return cp;
		cp++;
	}
	return NULL;
}
int main() {
	char arr1[] = "abcdef";
	char arr2[] = "bc";
	char* ret = my_strstr(arr1, arr2);
	if (ret == NULL)
		printf("找不到");
	else
		printf("找到了,%s", ret);
}

/* strstr example */
 #include <stdio.h>
 #include <string.h>
 int main ()
 {
 char str[] ="This is a simple string";
 char * pch;
 pch = strstr (str,"simple");
 strncpy (pch,"sample",6);
 puts (str);
 return 0;
 }

五:[strtok库函数的用法](strtok - C++ Reference (cplusplus.com))

• sep参数是个字符串，定义了用作分隔符的字符集合

• 第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。

• strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。（注：strtok函数会改 变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）

• strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。

• strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记。

• 如果字符串中不存在更多的标记，则返回 NULL 指针。

 //strtok找到指向下一个标记，将其用'\0'结尾，返回指向这个标记的指针
//strtok会改变操作的字符串,一般都切割临时拷贝的内用
//第一个参数不为空，函数将找到str在中的第一个标记,strtok将保存他在字符串中的位置
//第一个参数为空,函数将在同一个字符串中被保存的位置开始,查找下一个标记
//如果字符串不存在更多标记，返回null
#include<stdio.h>
#include<string.h>
int main() {
	//char arr[] = "@@zpengwei@yeah.net";
	char arr[] = "@192.168.120.85";
	char* p = "@.#";
	char buffer[20] = { 0 };
	//必须拷贝
	strcpy(buffer, arr);
	char* ret = NULL;
	for (ret = strtok(buffer, p); ret != NULL;ret = strtok(NULL, p)) {
		printf("%s\n", ret);
	}
	/*char* ret = strtok(buffer, p);
	printf("%s\n", ret);
	ret = strtok(NULL, p);
	printf("%s\n", ret);
	ret = strtok(NULL, p);
	printf("%s\n", ret);
	ret = strtok(NULL, p);
	printf("%s", ret);
}*/
}

六:[strerror库函数的用法](strerror - C++ Reference (cplusplus.com))

• 返回错误码，所对应的错误信息。
• prrror会直接打印,相当与print+strerror(),如果不想直接打印,建议直接用strerror

/* strerror example : error list */ 
#include <stdio.h> 
#include <string.h> 
#include <errno.h>//必须包含的头文件 
比特科技
int main () 
{ 
  FILE * pFile; 
  pFile = fopen ("unexist.ent","r"); 
  if (pFile == NULL) 
    printf ("Error opening file unexist.ent: %s\n",strerror(errno)); 
    //errno: Last error number 
  return 0; 
} 

三:字符转换函数

##常见的字符转换函数

一:判断是不是小写字母

#include<stdio.h>
int main() {
	
	int ret = islower('a');
	printf("%d", ret);
}

二:小写字母转化为大写字母

#include<stdio.h>
int main() {
	int ret = toupper('a');
	printf("%c", ret);

}

三:大写字母转化为小写字母

#include<stdio.h>
int main() {
	char arr[] = "I love Apple.";
	int i = 0;
	while (arr[i]) {
		if (isupper(arr[i])) {
			printf("%c", tolower(arr[i]));
		}
		else {
			printf("%c", arr[i]);
		}
		i++;
	}
}

四:判断是不是0~9里面的数字

#include<stdio.h>
int main() {
	int i = 0;
	for (i = 0; i < 100; i++) {
		if (isdigit(i)) {
			printf("%d ", i);
		}
	}
}

由于其他函数也都是这样判断,我就不写了,自己感兴趣的话可以自己练习

四:内存操作函数

一:[memcpy内存库函数的用法](memcpy - C++ Reference (cplusplus.com))

• 函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
• 这个函数在遇到 ‘\0’ 的时候并不会停下来。
• 如果source和destination有任何的重叠，复制的结果都是未定义的。

#include <stdio.h> 
#include <string.h> 
struct{
	char name[40];
	int age;
} person, person_copy;
int main()
{
	char myname[] = "Pierre de Fermat";
	/* using memcpy to copy string: */
	memcpy(person.name, myname, strlen(myname) + 1);
	person.age = 46;
	/* using memcpy to copy structure: */
    //通过地址的字节一个一个字节的拷贝,所以要取两个结构体的地址
	memcpy(&person_copy, &person, sizeof(person));
	printf("person_copy: %s, %d \n", person_copy.name, person_copy.age);
	return 0;
}

二:memmove内存库函数的用法

• 和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
• 如果源空间和目标空间出现重叠，就得使用memmove函数处理

/* memmove example */ 
#include <stdio.h> 
#include <string.h> 
int main () 
{ 
  char str[] = "memmove can be very useful......"; 
  memmove (str+20,str+15,11); 
  puts (str); 
  return 0; 
} 

三:[memcmp库函数的用法](memcmp - C++ Reference (cplusplus.com))

• 比较从ptr1和ptr2指针开始的num个字节
• 返回值如下：
• 

/* memcmp example */ 
#include <stdio.h> 
#include <string.h> 
int main () 
{ 
  char buffer1[] = "DWgaOtP12df0"; 
  char buffer2[] = "DWGAOTP12DF0"; 
  int n; 
  n=memcmp ( buffer1, buffer2, sizeof(buffer1) ); 
  return 0; 
} 
  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); 

五:库函数的模拟实现

一:[strlen库函数的模拟实现](strlen - C++ Reference (cplusplus.com))

1. //计数器方式 
   int my_strlen(const char * str) 
   { 
   int count = 0; 
   while(*str) 
   { 
   count++; 
   str++; 
   } 
   return count; 
   } 
   

2. //不能创建临时变量计数器 
   int my_strlen(const char * str) 
   { 
   if(*str == '\0') 
   return 0; 
   else 
   return 1+my_strlen(str+1); 
   }
   

3. int my_strlen(char *s) 
   { 
          char *p = s; 
          while(*p != ‘\0’ ) 
                 p++; 
          return p-s; 
      }
   

二:[模拟实现strcpy](strcpy - C++ Reference (cplusplus.com))

//1.参数顺序 
//2.函数的功能，停止条件 
//3.assert 
//4.const修饰指针 
//5.函数返回值 
//6.题目出自《高质量C/C++编程》书籍最后的试题部分 
char *my_strcpy(char *dest, const char*src) 
{  
char *ret = dest; 
assert(dest != NULL);
assert(src != NULL); 
while((*dest++ = *src++)) 
{ 
; 
} 
return ret; 
}

三:[模拟实现strstr](strstr - C++ Reference (cplusplus.com))

• 如果第二个指针

char *my_strstr(const char* str1, const char* str2 ) 
{ 
assert(str1); 
assert(str2); 
//char *cp = (char*)str1; 
//char *substr = (char *)str2; 
//char *s1 = NULL; 
if(*str2 == '\0') 
return NULL; 
while(*cp) 
{ 
（char*)s1 = (char*)str1;
char *substr = (char *)str2; 
//解引用两个地址,找到两个地址的存放的内容,同时比较
while(*s1 && *substr && (*s1 == *substr)) 
{ 
s1++; 
substr++;
} 
if(*substr == '\0') 
return cp; 
cp++; 
} 
}

四:[模拟实现strcmp](strcmp - C++ Reference (cplusplus.com))

int my_strcmp (const char * src, const char * dst) 
{ 
        int ret = 0 ; 
assert(src != NULL); 
assert(dest != NULL); 
        while( ! (ret = *(unsigned char *)src - *(unsigned char *)dst) && *dst) 
                ++src, ++dst; 
        if ( ret < 0 ) 
                ret = -1 ; 
        else if ( ret > 0 ) 
                ret = 1 ; 
        return( ret ); 
}

五:[模拟实现memcpy](memcpy - C++ Reference (cplusplus.com))

void * memcpy ( void * dst, const void * src, size_t count) 
{ 
        void * ret = dst; 
assert(dst); 
assert(src); 
        /* 
         * copy from lower addresses to higher addresses 
         */ 
        while (count--) { 
                *(char *)dst = *(char *)src; 
                dst = (char *)dst + 1; 
                src = (char *)src + 1; 
        } 
} 
        return(ret); 

六:[模拟实现strcat](strcat - C++ Reference (cplusplus.com))

char *my_strcat(char *dest, const char*src) 
{ 
char *ret = dest; 
assert(dest != NULL); 
assert(src != NULL); 
while(*dest) 
{ 
dest++; 
} 
while((*dest++ = *src++)) 
{ 
; 
} 
return ret; 
} 

七:[模拟实现memmove](memmove - C++ Reference (cplusplus.com))

void * memmove ( void * dst, const void * src, size_t count) 
{ 
        void * ret = dst; 
        if (dst <= src || (char *)dst >= ((char *)src + count)) { 
                /* 
                 * Non-Overlapping Buffers 
                 * copy from lower addresses to higher addresses 
                 */ 
                while (count--) { 
                        *(char *)dst = *(char *)src; 
                        dst = (char *)dst + 1; 
                        src = (char *)src + 1; 
                } 
        } 
        else { 
                /* 
                 * Overlapping Buffers 
                 * copy from higher addresses to lower addresses 
                 */ 
                dst = (char *)dst + count - 1; 
                src = (char *)src + count - 1; 
                while (count--) { 
                        *(char *)dst = *(char *)src; 
                        dst = (char *)dst - 1; 
                        src = (char *)src - 1; 
                } 
        } 
        return(ret); 
} 
本章完

ar *)dst + 1;
src = (char )src + 1;
}
}
else {
/
* Overlapping Buffers
* copy from higher addresses to lower addresses
*/
dst = (char *)dst + count - 1;
src = (char *)src + count - 1;
while (count–) {
*(char *)dst = *(char *)src;
dst = (char *)dst - 1;
src = (char *)src - 1;
}
}
return(ret);
}
本章完