字符串试题

原型：extern int strlen(char *s);
功能：计算字符串s的(unsigned int型）长度
说明：返回s的长度，不包括结束符NULL。

int strlen(const char *str)
{
	if(!str)return 0;
	const char *p = str; 
	while(*p++); 
	return p - str - 1; 
}

int strlenN(const char *str)
{
 unsigned int i = 0;
 if(!str)return i;
 for (i = 0; *str != '\0'; i++,*str++);
 return i;
}

原型：extern char *strcat(char *dest,char *src);
功能：把src所指字符串添加到dest结尾处(覆盖dest结尾处的'\0')并添加'\0'。
说明：src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。
返回指向dest的指针。

char *strcat(char *dest,char *src)
{
	char* cp = dest;
	while(*cp)
		cp++; 
	while(*cp++ = *src++); //*cp == '\0';
	return(dest); 
}

原型：extern int strcmp( const char *str1, const char *str2 );
功能：比较字符串str1 and str2, 返回值如下:
< 0        str1 is less than str2 
= to 0     str1 is equal to str2 
> than 0   str1 is greater than str2 
以ASCII码逐个比较假如一个字符大于第二个字符 不论后面有多少字符 第一字符永远大于第二字符的

int strcmp(const char *str1, const char *str2)
{
	register signed char __res;       
	while(1) 
	{
		if((__res = *str1 - *str2++) != 0 || !*str1++)
			break;    
	}
	if (__res == 0)return __res;
	__res = __res>0?1:-1;
	return __res;  
}



原型：extern char* strcpy(char* dest,const char* src);
功能：复制字符串src 中的字符到字符串dest，包括空值结束符。返回值为指针to。
char* pde = NULL;
char* dest 含有默认的指针保护 同变量保护相同理解 当出函数栈时 形参将还原指针的位置
但变量这时未起到保护 所以变量发生改变而指针位置未发生改变

char* strcpy(char* dest,const char* src)
{
    char *tmp = dest;
    while ((*dest++ = *src++) != '\0');//pde = dest;
    return tmp;       
}

原型：extern char *strncpy(char* dest,const char* src,size_t count);
功能：复制字符串src 中的字符到字符串dest，复制的长度由count设定。返回值为指针to。

char *strncpy(char* dest,const char* src,size_t count)
{
  char *tmp = dest;
     size_t available = count;
     while ((*dest++ = *src++) != '\0' && --available > 0);
  return tmp;
}

原型：extern char *strset(char *s, char c);
功能：把字符串s中的所有字符都设置成字符c。
说明：返回指向s的指针。

Sets all of characters in string (except the terminating '/0'character) equal to c.
把字符串的所有字符都设置为字符c。

char *strset(char *s, char c)
{
   char *p = s;
   while (*s)
    *s++ = c;
   return(p);
}

原型：extern void *memcpy(void *dest, void *src, unsigned int count);
功能：由pSrc所指内存区域复制nCount个字节到pDest所指内存区域。
说明：pSrc和pDest所指内存区域不能重叠，函数返回指向pDest的指针。
           PSrc和pDest若重叠则使用逆拷贝功能，函数返回指向pDest的指针。

void* memcpy(void* pDest, const void* pSrc, unsigned int nCount)   
{  
 if (pDest == NULL && pSrc == NULL)
  return pDest;
 unsigned char* pTmpD = (unsigned char*)pDest + nCount;   
 const unsigned char* pTmpS = (unsigned char*)pSrc + nCount;   
 while (nCount--)   
 {   
  *--pTmpD = *--pTmpS;
 }   
 return pDest; 
}

strcpy和memcpy的区别
(1).strcpy只能用于字符串拷贝；而memcpy是内存拷贝，可以拷贝任何类型的数据。
(2).当二者都进行字符串拷贝时，strcpy遇到字符串结尾'\0'即完成；而memcpy只是内存的原样拷贝，不管遇到什么。

原型：extern void *memset(void *buffer, int c, int count);
功能：把buffer所指内存区域的前count个字节设置成字符c。
说明：返回指向buffer的指针。

void * memset(void* buffer,char c,size_t count)       
{       
     char *xs = (char*) buffer;       
  while(count--)       
     *xs++ = c;       
  return buffer;       
}  

原型：extern void *memchr(void *buf, char ch, unsigned count);
功能：从buf所指内存区域的前count个字节查找字符ch。
说明：当第一次遇到字符ch时停止查找。如果成功，返回指向字符ch的指针；否则返回NULL。

void *memchr(const void *buf, char ch, size_t count)
{
    const unsigned char *p = (const unsigned char *) buf;   
    while (count--)
    {   
           if ((unsigned char)ch == *p++) 
           {   
               return (void *)(p-1);   
           }   
    }   
    return NULL; 
}

原型：extern void *memmove(void *dest, const void *src, unsigned int count);
功能：由src所指内存区域复制count个字节到dest所指内存区域。
说明：src和dest所指内存区域可以重叠，但复制后src内容会被更改。函数返回指向dest的指针。

           (前拷贝,顺序拷贝;后拷贝是防止值的先拷 [主要功能:考虑src在前时的问题])

void * memmove(void * dest,const void *src,size_t count)   
{   
 char *tmp, *s;   
 if (dest <= src /* || (char*)dest >= (char*)src+count */ ) //dest < (char*)src+count 唯一条件 会有带值现象
 {   
  tmp = (char *) dest;
  s = (char *) src;   
  while (count--)   
   *tmp++ = *s++;   
 }             //保证dest 所付的值 src不被用到即可 由于反拷贝并

不影响 
 else            // (char*)dest >= (char*)src+count 的现象 也可省略 这个
 {             //使他在反拷贝中实现 保证 函数的调用速度
  tmp = (char *) dest + count;     
  s = (char *) src + count;      //保证下标０的位置在首位被用到所以先自减一再赋值
  while (count--)   
   *--tmp = *--s;   
 } 
 return dest;   
}   

一字节对齐

#pragma pack(push,1)

#pragma pack(pop)

只包含一次头文件

#pragma once