字符串函数与内存函数介绍

字符串函数

1.strlen

        size_t strlen( const char * str );

        作用：计算字符串的长度

        1.字符串以‘\0'作为结束标志，strlen函数返回的使在字符串中’\0'前面出现的字符个数（不含'\0'）

        2.参数指向的字符串必须要以‘\0'结束

        3.函数的返回值为size_t，是无符号的

自己实现size_t的三种方法：
        1.直接计算

size_t my_strlen(const char arr[])
{
	assert(arr);
	size_t count = 0;
	while (*arr)
	{
		arr++;
		count++;
	}
	return count;
}

        2.指针-指针

size_t my_strlen(char arr[])
{
	assert(arr);
	char* start = arr;
	while (*arr)
	{
		arr++;
	}
	return arr - start;
}

        3.递归

size_t my_strlen(const char arr[])
{
	if (*arr == '\0')
		return 0;
	else
		return 1 + my_strlen(arr + 1);
}

2.strcpy

        char* strcpy( char * destination, const char * source );

        作用：拷贝字符串

        1,被拷贝（源）字符串必须以’\0'结束

        2.源字符串中的'\0'会拷贝到目标空间

        3.目标空间要足够大，以确保能存放源字符串

        4.目标空间必须可变

自己实现strcpy：

char* my_strcpy(char* des, char* sour)
{
	char* ret = des;
	assert(des && sour);
	while (*des++ = *sour++)
	{
		;
	}
	return ret;
}
int main()
{
	char arr[100] = "hello world";
	char str[100] = "xxxxx";
	char * ptr=my_strcpy(arr, str);
	puts(ptr);
	return 0;
}

3.strcat

        char * strcat ( char * desination, const char * source );

        作用：连接或追加字符串

        1.源字符串必须以'\0'结束

        2.目标空间必须足够大，能够容纳下源字符串的内容

        3.目标空间必须可修改

        4.用该函数字符串不能自己给自己追加，会报错

自己实现strcat：

char* my_strcat(char* des, char* sour)
{
	char* ret = des;
	assert(des && sour);
	while (*des)
	{
		des++;
	}
	while (*des++ = *sour++)
	{
		;
	}
	return ret;
}
int main()
{
	char arr[100] = "hello ";
	char str[100] = "world";
	char * ptr=my_strcat(arr, str);
	puts(ptr);
	return 0;
}

4.strcmp

        int strcmp ( const char * str1, const char * str2 )

        作用：比较两个字符串大小

        1.第一个字符串大于第二个字符串，则返回大于0的数字

        2.第一个字符串等于第二个字符串，则返回0

        3.第一个字符串小于第二个字符串，则返回小于0的数字

自己实现strcmp：

int my_strcmp(const char* str1, const char* str2)
{
	assert(str1 && str2);
	while (*str1 == *str2)
	{
		if (*str1 == '\0')
			return 0;
		str1++;
		str2++;
	}
	if (str1 > str2)
		return 1;
	else
		return 0;
}
int main()
{
	char arr[100] = "hello ";
	char str[100] = "world";
	int p = my_strcmp(arr, str);
	printf("%d", p);
	return 0;
}

5.strncpy

        char * strncpy ( char * destination, const char * source, size_t num );

        作用：拷贝前n个字符串到另一个字符

        1.如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，知道num个为之

自己实现strncpy

char* my_strncpy(char* dest, const char* sour, size_t num)
{
	char* ret = dest;
	assert(dest && sour);
	while (num)
	{
		*dest = *sour;
		dest++;
		sour++;
		num--;
	}
	return ret;
}
int main()
{
	char str1[] = "To be or not to be";
	char str2[40];
	char str3[40];

	my_strncpy(str2, str1, sizeof(str2));

	my_strncpy(str3, str2, 5);
	str3[5] = '\0';
	puts(str1);
	puts(str2);
	puts(str3);

	return 0;
}

6.strstr

        char * strstr ( const char *str1, const char * str2 );

        作用：在字符串中找子字符串

        1.在str1中找str2出现的第一次的位置，找不到则返回空指针

char* my_strstr(char* str1,const char* str2)
{
    char* start = str1;
    char* sour = str1;
    const char* dest = str2;
    while (start)
    {
        str1 = start;
        str2 = dest;
        while (*str1 && *str2 && *str1 == *str2)
        {
            str1++;
            str2++;
        }
        if (*str2 == '\0')
            return start;
        start++;
    }
    return NULL;
}
int main()
{
    char str[] = "This is a simple string";
    char* pch;
    pch = my_strstr(str, "simple");
    if (pch != NULL)
        strncpy(pch, "sample", 6);
    puts(str);
    return 0;
}

7.strtok

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

        作用：提前字符串中的某一段

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

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

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

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

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

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

8.strerror

        char * strerror ( int errnum );

        作用：把错误码翻译成错误信息

        注：功能与perror相近，但perror能直接打印出错误信息

9.字符转换

        大写转小写： int tolower ( int c );

        小写转大写：int toupper ( int c );

内存函数

1.memcpy

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

        作用：（内存拷贝）用来处理不重叠的内容拷贝

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

        2.这个函数在遇到‘\0'的时候并不会停下来

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

自己实现：

void* my_memcpy(void* dest, const void* sour, size_t num)
{
	assert(dest && sour);
	void* ret = dest;
	while (num)
	{
		*(char*)dest = *(char*)sour;
		dest=(char*)dest+1;
		sour = (char*)sour + 1;
		num--;
	}
	return ret;
}
int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[20] = { 0 };
	my_memcpy(arr2, arr1, 40);
	int i = 0;
	for (i = 0; i < 20; i++)
	{
		printf("%d ", arr2[i]);
	}
	return 0;
}

2.memmove

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

        1.和memcpy的差别为memmove函数处理的源内存块和目标内存块是可以重叠的

        2.如果源空间和目标空间出现重叠，就得使用memmove函数处理

自己实现：

void* my_memmove(void* dest, const void* sour, size_t num)
{
	assert(dest && sour);
	void* ret = dest;
	if(dest<sour)
	{
		while (num)
		{
			*(char*)dest = *(char*)sour;
			dest = (char*)dest + 1;
			sour = (char*)sour + 1;
			num--;
		}
	}
	else
	{
		while (num--)
		{
			*((char*)dest + num) = *((char*)sour + num);
		}
	}
	return ret;
}
int main()
{
	char str[] = "memmove can be very useful......";
	memmove(str + 20, str + 15, 11);
	puts(str);
	return 0;
}

3.memcmp

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

        1.比较从ptr1和ptr2指针开始的num个字节

4.memset

        void * memset ( void * ptr, int value, size_t num )；

        在ptr指针指向的位置替换成n个value字符