string.h 的实现

现在的位置: 首页 > 综合 > 正文

string.h 的实现

2013年04月15日 ⁄ 综合 ⁄ 共 8292字 ⁄ 字号小中大 ⁄ 评论关闭

最近很是烦躁，没做什么事，随便花了点时间把 C 库中的 string.h 中的几个函数实现了下，不多说了，直接贴代码吧，可能会存在错误和不好的算法，希望大家见谅：

测试函数写的乱七八糟，就不贴在这里了，有些函数是不需要实现差错控制的，使用不当，程序崩溃那是自己的事，我实现的这些个函数可能和经典的实现存在较大的差距，不过，我说过了，这仅仅是个人觉得好玩才随便写的，我也没那么多的时间去一一验证和调试。

dlut_string.h

/*
 * dlut_string.h
 *
 *  Created on: 2013年12月18日
 *      Author: DLUTBruceZhang
 */

#ifndef DLUT_STRING_H_
#define DLUT_STRING_H_

#include <malloc.h>
#include <stdio.h>

#define 					dlut_strcmpi(buf1, buf2)				dlut_stricmp(buf1, buf2)

void * 					dlut_memcpy(void *, const void *, unsigned int);
int							dlut_memcmp(const void *, const void *, unsigned int);
void *						dlut_memset(void *, int, unsigned int);
char *						dlut_strset(char *, int);
char *						dlut_strcpy(char *, const char *);
char *						dlut_strcat(char *, const char *);
int							dlut_strcmp(const char *, const char *);
unsigned int 			dlut_strlen(const char *);
void *						dlut_memccpy(void *, const void *, int, unsigned int);
void *						dlut_memchr(void *, int, unsigned int);
int							dlut_memicmp(const void *, const void *, unsigned int);
void *						dlut_memmove(void *, const void *, unsigned int);
char *						dlut_strchr(const char *, int);
int							dlut_stricmp(const char *, const char *);
int							dlut_strcoll(const char *, const char *);
int 						dlut_stricoll(const char *, const char *);
int							dlut_strncoll(const char *, const char *, unsigned int);
int							dlut_strnicoll(const char *, const char *, unsigned int);
unsigned int				dlut_strcspn(const char *, const char *);
char *						dlut_strdup(const char *);
char *						dlut_strerror(const char *);
char *						dlut_strlwr(char *);
char *						dlut_strncat(char *, const char *, unsigned int);
int							dlut_strncmp(const char *, const char *, unsigned int);
int							dlut_strnicmp(const char *, const char *, unsigned int);
char *						dlut_strncpy(char *, const char *, unsigned int);
char *						dlut_strnset(char *, int , unsigned int);
char *						dlut_strpbrk(const char *, const char *);
char *						dlut_strrchr(const char *, int);
char *						dlut_strrev(char *);
unsigned int 			dlut_strspn(const char *, const char *);
char *						dlut_strstr(const char *, const char *);
char *						dlut_strtok(char *, const char *);
char *						dlut_strupr(char *);
int							dlut_bcmp(const void *, const void *, unsigned int);
void						dlut_bcopy(const void *, void *, unsigned int);
void						dlut_bzero(void *, unsigned int);

#endif /* DLUT_STRING_H_ */

dlut_string.c

/*
 * dlut_string.c
 *
 *  Created on: 2013年12月18日
 *      Author: DLUTBruceZhang
 */

#include "dlut_string.h"

void * dlut_memcpy(void *dst, const void *src, unsigned int size)
{
	void *dst_ = dst;

	if (src == 0 || dst == 0 || !size)
		return dst_;

	while (size-- && *(char *)src)
	{
		*(char *)dst++ = *(char *)src++;
	}

	return dst_;
}

int dlut_memcmp(const void *buf1, const void *buf2, unsigned int size)
{
	char *buf1_ = (char *)buf1;
	char *buf2_ = (char *)buf2;

	if (!size)
		return 0;

	while (size-- && *buf1_ == *buf2_)
	{
		buf1_++;
		buf2_++;
	}

	return *buf1_ - *buf2_;
}

void * dlut_memset(void *buf, int v, unsigned int size)
{
	void *buf_ = buf;

	if (!size)
		return buf_;

	while (size--)
	{
		*(char *)buf = (char)v;

		buf = (char *)buf + 1;
	}

	return buf_;
}

char * dlut_strset(char *buf, int v)
{
	char *start = buf;

	while (*buf)
	{
		*buf++ = (char)v;
	}

	return start;
}

char * dlut_strcpy(char *dst, const char *src)
{
	char *start = dst;

	while (*src)
	{
		*dst++ = *src++;
	}

	return start;
}

char * dlut_strcat(char *buf, const char *sub)
{
	char *start = buf;

	while (*buf)
		buf++;

	while (*sub)
	{
		*buf++ = *sub++;
	}

	return start;
}

int dlut_strcmp(const char *buf1, const char *buf2)
{
	while (*buf1 == *buf2)
	{
		buf1++;
		buf2++;
	}

	return *buf1 - *buf2;
}

unsigned int dlut_strlen(const char *buf)
{
	int i = 0;

	while (*buf)
	{
		buf++;
		i++;
	}

	return i;
}

void * dlut_memccpy(void *dst, const void *src, int v, unsigned int size)
{
	while (size-- && (int)*(char *)src != v)
	{
		*(char *)dst++ = *(char *)src++;
	}

	if (*(char *)src == v)
		return (void *)++src;
	else
		return 0;
}

void * dlut_memchr(void *str, int v, unsigned int size)
{
	while (size-- && (int)*(char *)str != v)
		str++;

	return (int)*(char *)str == v ? str : 0;
}

#define DLUT_TO_LOWER(c)		(c >= 'A' && c <= 'Z') ? (c + 'a' - 'A') : c

int dlut_memicmp(const void *buf1, const void *buf2, unsigned int size)
{
	char buf1_;
	char buf2_;

	while (size-- &&
			((buf1_ = DLUT_TO_LOWER(*(char *)buf1)) == (buf2_ = DLUT_TO_LOWER(*(char *)buf2))))
	{
		buf1 = (char *)buf1 + 1;
		buf2 = (char *)buf2 + 1;
	}

	return (int)*(char *)buf1 - (int)*(char *)buf2;
}

/*
 * this function is similar to dlut_memcpy, but you need know,
 * dlut_memmove support memory overlapping, its method is here:
 * 1.if src address is equal dst address, dont't do any thing
 * 2.if src address is less than dst address, do reverse copy
 * 3.if src address is greater than dst address, do forward copy
 *
 * */
void * dlut_memmove(void *dst, const void *src, unsigned int size)
{
	void *dst_ = dst;

	if (src > dst)
	{
		while (size--)
		{
			*(char *)dst++ = *(char *)src++;
		}
	}
	else if (src < dst)
	{
		src = (char *)src + size - 1;
		dst = (char *)dst + size - 1;

		while (size--)
		{
			*(char *)dst-- = *(char *)src--;
		}
	}

	return dst_;
}

char * dlut_strchr(const char *str, int v)
{
	while (*str && (int)*str != v)
		str++;

	return (char *)str;
}

/*you need know '\0' and '\0' is equal too*/
int dlut_stricmp(const char *buf1, const char *buf2)
{
	while ((DLUT_TO_LOWER(*buf1)) == (DLUT_TO_LOWER(*buf2))
			&& *buf1 && *buf2)
	{
		buf1++;
		buf2++;
	}

	return (int)(*buf1 - *buf2);
}

int dlut_strcoll(const char *buf1, const char *buf2)
{
	while (*buf1 == *buf2)
	{
		buf1++;
		buf2++;
	}

	return *buf1 - *buf2;
}

int dlut_stricoll(const char *buf1, const char *buf2)
{
	while ((DLUT_TO_LOWER(*buf1)) == (DLUT_TO_LOWER(*buf2))
			&& *buf1 && *buf2)
	{
		buf1++;
		buf2++;
	}

	return (int)(*buf1 - *buf2);
}

int dlut_strncoll(const char *buf1, const char *buf2, unsigned int size)
{
	while (size-- && *buf1 == *buf2 && *buf1 && *buf2)
	{
		buf1++;
		buf2++;
	}

	return *buf1 - *buf2;
}

int dlut_strnicoll(const char *buf1, const char *buf2, unsigned int size)
{
	while (size-- && *buf1 && *buf2 && ((DLUT_TO_LOWER(*buf1)) == (DLUT_TO_LOWER(*buf2))))
	{
		buf1++;
		buf2++;
	}

	return *buf1 - *buf2;
}

unsigned int dlut_strcspn(const char *buf1, const char *buf2)
{
	const char *start;

	int count = 0;

	while (*buf2)
	{
		start = buf1;

		count = 0;

		while (*start)
		{
			if (*start == *buf2)
				return count;
			else
			{
				start++;
				count++;
			}
		}

		buf2++;
	}

	return count;
}

char * dlut_strdup(const char *str)
{
	char *dup;

	dup = (char *)malloc(dlut_strlen(str));

	dlut_strcpy(dup, str);

	return dup;
}

char * dlut_strerror(const char *str)
{
	return 0;
}

char * dlut_strlwr(char *str)
{
	char *start = str;

	while (*str)
	{
		if ((*str >= 'A') && (*str <= 'Z'))
		{
			*str = *str + 'a' - 'A';
		}
		str++;
	}

	return start;
}

char * dlut_strncat(char *dst, const char *src, unsigned int size)
{
	char *start = dst;

	while (*dst)
		dst++;

	while (size-- && *dst)
	{
		*dst++ = *src++;
	}

	*dst = '\0';

	return start;
}

int dlut_strncmp(const char *buf1, const char *buf2, unsigned int size)
{
	while (--size && *buf1 && *buf2 && *buf1 == *buf2)
	{
		buf1++;
		buf2++;
	}

	return *buf1 - *buf2;
}

int dlut_strnicmp(const char *buf1, const char *buf2, unsigned int size)
{
	while (--size && *buf1 && *buf2 && ((DLUT_TO_LOWER(*buf1)) == (DLUT_TO_LOWER(*buf2))))
	{
		buf1++;
		buf2++;
	}

	if (((DLUT_TO_LOWER(*buf1)) == (DLUT_TO_LOWER(*buf2))))
		return 0;
	else
		return *buf1 - *buf2;
}

char * dlut_strncpy(char *buf1, const char *buf2, unsigned int size)
{
	char *start = buf1;

	while (size-- && *buf2)
	{
		*buf1++ = *buf2++;
	}

	*buf1 = '\0';

	return start;
}

char * dlut_strnset(char *str, int v, unsigned int size)
{
	char *start = str;

	while(size-- && *str)
	{
		*str++ = (char)v;
	}

	return start;
}

char * dlut_strpbrk(const char *buf1, const char *buf2)
{
	char *start;

	while (*buf2)
	{
		start = (char *)buf1;

		while (*start)
		{
			if (*start == *buf2)
			{
				return start;
			}

			start++;
		}

		buf2++;
	}

	return start;
}

char * dlut_strrchr(const char *str, int v)
{
	const char *high = str;

	while (*high)
		high++;

	--high;

	while (high != str - 1)
	{
		if (*high == (char)v)
			return (char *)high;
		else
			high--;
	}

	return 0;
}


char * dlut_strrev(char *str)
{
	char *start = str;

	char *low = str;
	char *high = str;

	char c;

	while (*high)
		high++;

	--high;


	while (low < high)
	{
		c = *low;
		*low++ = *high;
		*high-- = c;
	}

	return start;
}

/*
 * map有32个字节。就是256个BIT，可把map看成是一个2维数组[32][8]，

每个ASCII码（设为c）有8BIT，把它分为2部分，低3位构成下标j（通过c & 7得到），高5位构成下标i（通过c>>3得到），
这样在map[[i][j]中置1代表该字符存在。

算法中先根据control构成map，然后把string中每个字符用同样方法计算出i和j，如果map[i][j]为1，则count加1 。

 * */
unsigned int dlut_strspn(const char *buf1, const char *buf2)
{
	unsigned int count = 0;

	const char *buf1_ = buf1;
	const char *buf2_ = buf2;

	char map[32];

	for (count = 0; count != 32; count++)
		map[count] = 0;

	while (*buf2_)
	{
		map[*buf2_ >> 3] |= (1 << (*buf2_ & 7));

		buf2_++;
	}

	if (*buf1)
	{
		count = 0;

		while ((map[*buf1_ >> 3] & (1 << (*buf1_ & 7))) && *buf1_)
		{
			count++;
			buf1_++;
		}

		return count;
	}

	return 0;
}

char * dlut_strstr(const char *buf1, const char *buf2)
{
	char *buf1_;
	char *buf2_;
	char *start;

	while(*buf1)
	{
		start = (char *)buf1;
		buf1_ = (char *)buf1;

		for (buf2_ = (char *)buf2; *buf2_; buf2_++)
		{
			if (*buf1_ == *buf2_)
			{
				if (*(buf2_ + 1) == '\0')
				{
					return start;
				}
				else
				{
					buf1_++;
				}
			}
			else
				break;
		}

		buf1++;
	}

	return 0;
}

char * dlut_strtok(char *str, const char *delim)
{
	static char *reserved;

	char *start;

	if (str == 0)
		str = reserved;
	if (str == 0)
		return 0;

	start = str;

	while (*str)
	{
		if (*delim && *delim == *str)
		{
			*str = '\0';

			reserved = str + 1;

			return start;
		}

		str++;
	}

	reserved = 0;

	return start;
}

char * dlut_strupr(char *str)
{
	char *start = str;

	if (str == 0)
		return 0;

	while (*str)
	{
		if (*str >= 'a' && *str <= 'z')
		{
			*str = *str - 'a' + 'A';
		}

		str++;
	}

	return start;
}

int dlut_bcmp(const void *buf1, const void *buf2, unsigned int size)
{
	char *buf1_ = (char *)buf1;
	char *buf2_ = (char *)buf2;

	while (size-- && *buf1_ == *buf2_)
	{
		buf1_++;
		buf2_++;
	}

	return *buf1_ - *buf2_;
}

void dlut_bcopy(const void *src, void *dst, unsigned int size)
{
	char *src_ = (char *)src;
	char *dst_ = (char *)dst;

	while (size--)
	{
		*dst_++ = *src_++;
	}

	return;
}

void dlut_bzero(void *str, unsigned int size)
{
	char *str_ = (char *)str;

	while (size--)
	{
		*str_++ = 0;
	}

	return;
}

【上篇】cpp 重载覆盖隐藏
【下篇】English经典句子

作者: disgusted

该日志由 disgusted 于11年前发表在综合分类下，最后更新于 2013年04月15日.
转载请注明: string.h 的实现 | 学步园 +复制链接

抱歉!评论已关闭.

学步园

string.h 的实现

作者: disgusted

书签

最新文章New

本站推荐

返回首页