C语言学习笔记—P28（＜C语言高阶＞+字符函数和字符串函数＜2＞+题例+图解）

新晓·故知

已于 2022-03-05 16:22:20 修改

阅读量729

点赞数

分类专栏：《C语言》文章标签： c语言

于 2022-02-03 00:54:35 首次发布

本文链接：https://blog.csdn.net/m0_57859086/article/details/122773489

版权

《C语言》专栏收录该内容

62 篇文章 30 订阅

订阅专栏

什么都不做，才会来不及！

2.7 模拟实现memmove 参考代码：

后记：●由于作者水平有限，文章难免存在谬误之处，敬请读者斧正，俚语成篇，恳望指教！ ——By 作者：新晓·故知

1.9 strtok

char * strtok ( char * str, const char * sep );

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

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

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

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

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

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

/* strtok example */
#include <stdio.h>
#include <string.h>
int main()
{
    char str[] = "- This, a sample string.";
    char* pch;
    printf("Splitting string \"%s\" into tokens:\n", str);
    pch = strtok(str, " ,.-");
    while (pch != NULL)
    {
        printf("%s\n", pch);
        pch = strtok(NULL, " ,.-");
    }
    return 0;
}

分析以下代码：

#include <stdio.h>
int main()
{
	char* p = "zhangpengwei@bitedu.tech";
	const char* sep = ".@";
	char arr[30];
	char* str = NULL;
	strcpy(arr, p);//将数据拷贝一份，处理arr数组的内容
	for (str = strtok(arr, sep); str != NULL; str = strtok(NULL, sep))
	{
		printf("%s\n", str);
	}
}

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

int main()
{
	const char* p = "@.";
	char arr[] = "zpengwei@yeah.net";
	char buf[50] = { 0 };// "zpengwei@yeah.net"
	strcpy(buf, arr);

	char* str = strtok(buf, p);//zpengwei
	printf("%s\n", str);
	str = strtok(NULL, p);//yeah
	printf("%s\n", str);
	str = strtok(NULL, p);//net
	printf("%s\n", str);
	//strtok - 开始返回NULL

	return 0;
}

优化代码：

猜测strtok函数内部有一个静态变量static保存了其要保存的位置，在进行后来调用后，便直接找到位置。

#include <stdio.h>
#include <string.h>
int main()
{
	const char* p = "@.#";
	char arr[] = "zpengwei@yeah.net#hehe";
	char buf[50] = { 0 };// "zpengwei@yeah.net"
	strcpy(buf, arr);
	char* str = NULL;

	for (str = strtok(buf, p); str != NULL; str=strtok(NULL, p))
	{
		printf("%s\n", str);
	}
	//strtok - 开始返回NULL
	return 0;
}

1.10 strerror

char * strerror ( int errnum );

返回错误码，所对应的错误信息。

/* 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;
}
Edit& Run

//strerror - 可以把错误码翻译成错误信息
int main() 
{
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%s\n", strerror(i));
	}
	return 0;
}

#include <errno.h>
int main()
{
	//打开文件
	FILE* pf = fopen("test.txt", "r");
	if (NULL == pf)
	{
		//出错误的原因是什么
		printf("%s\n", strerror(errno));
		return 0;
	}
	//读文件
	//...
	
	//关闭文件
	fclose(pf);
	pf = NULL;

	return 0;
}

字符分类函数：

字符转换：

int tolower ( int c );

int toupper ( int c );

int main()
{
	char ch = 0;
	ch = getchar();
	if (islower(ch))
	{
		ch = toupper(ch);
	}
	else
	{
		ch = tolower(ch);
	}
	printf("%c\n", ch);

	return 0;
}

/* isupper example */
#include <stdio.h>
#include <ctype.h>
int main()
{
    int i = 0;
    char str[] = "Test String.\n";
    char c;
    while (str[i])
    {
        c = str[i];
        if (isupper(c))
            c = tolower(c);
        putchar(c);
        i++;
    }
    return 0;
}

1.11 memcpy

void * memcpy ( void * destination, const void * source, size_t num );

♦函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。

♦这个函数在遇到 '\0' 的时候并不会停下来。

♦如果source和destination有任何的重叠，复制的结果都是未定义的。

模拟实现memcpy函数：

当拷贝后，源字符串改变！

#include <assert.h>
void* my_memcpy(void* dest, const void*src, size_t num)
{
	void* ret = dest;
	assert(dest && src);

	while (num--) 
	{
		*(char*)dest = *(char*)src;
		dest = (char*)dest + 1;
		src = (char*)src + 1;
	}

	return ret;
}


int main()
{
	
	char arr1[] = "abcdef";
	char arr2[20] = { 0 };
	strcpy(arr2, arr1);//拷贝字符串的

	int arr3[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr4[5] = { 0 };

	my_memcpy(arr4, arr3+5, 5*sizeof(arr3[0]));

	int i = 0;
	for (i = 0; i < 5; i++)
	{
		printf("%d\n", arr4[i]);
	}

	return 0;
}

/* memcpy example */
#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;
}

1.12 memmove

void * memmove ( void*destination, const void * source, size_t num );

♦和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;
}

模拟实现memmove函数：

#include <assert.h>
void* my_memmove(void* dest, const void* src, size_t num)
{
	void* ret = dest;
	assert(dest && src);
	
	if (dest < src)
	{
		//前->后
		while (num--)
		{
			*(char*)dest = *(char*)src;
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}
	}
	else
	{
		//后->前
		while (num--)
		{
			*((char*)dest+num) = *((char*)src + num);
		}
	}
	return ret;
}


void test1()
{
	int arr3[] = { 1,2,3,4,5,6,7,8,9,10 };
	//1 2 1 2 3 4 5 8 9 10
	//my_memcpy(arr3+2, arr3, 5 * sizeof(arr3[0]));
	my_memmove(arr3, arr3 + 2, 20);

	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr3[i]);
	}
}

int main()
{
	test1();
	return 0;
}

1.13 memcmp

int memcmp(const void* ptr1,const void* ptr2,size_t num);

比较从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));
	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;
}

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

	printf("%d\n", ret);
	return 0;
}

1.14memset

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	memset(arr, 'x', 10);
	//00 00 00 00 00 00 00 00 00 00 00 00 04 00 00 00 ...
	return 0;
}

2. 库函数的模拟实现

2.1 模拟实现strlen

三种方式：

方式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;
}