面试中的手写函数

目录:

strcpy函数

strstr函数

memmove函数

memcpy函数

memset函数

strcmp函数

string类

    1. string()

   2.string (const char*str)

    3.const char* getStr()const

   4.string(conststring& str)

   5.string& operator= (const string& str)

    6.~string()

 

strcpy

题目:

已知strcpy原形:

     char*strcpy(char* strDest, const char* strSrc);

要点:

1.自我检测

2.检查指针为空.

3.返回char*,以便链式使用.

4.移动指针

char *strcpy ( char* strDest, const char * strSrc)
{
    if ( strDest == strSrc ){
        return strDest ;
    }
    assert((! strDest )&&(!strSrc ));
    char * add = strDest;
    while ( (* strDest ++ = *strSrc ++ )!= '\0') ;
    return add ;
}

strstr

函数描述

包含文件：string.h

函数名: strstr

函数原型：extern char*strstr(char *str1, char *str2);

功能：从字符串str1中查找是否有字符串str2，如果有，从str1中的str2位置起，返回str1中str2起始位置的指针，如果没有，返回null。

返回值：返回该位置的指针，如找不到，返回空指针。

函数实现

 

//1.Copyright1990Software Development Systems, Inc.
char*strstr(constchar*s1, const char*s2 )
{
intlen2;
if(!(len2 = strlen(s2)) )
return(char*)s1;
for(; *s1; ++s1 ){
if(*s1 == *s2 && strncmp( s1, s2, len2 )==0 )
return(char*)s1;
}
return  NULL;
}
 
//2.Copyright1986- 1999 IAR Systems. All rights reserved
char*strstr(constchar*s1,const char*s2)
{
    intn;
    if(*s2)
{
        while(*s1)
    {
            for(n=0; *(s1 + n) == *(s2 + n); n++)
       {
                if(!*(s2 + n + 1))
                return (char*)s1;
       }
       s1++;
   }
        returnNULL;
}
    else
        return(char*)s1;
}
//3.GCC-4.8.0
char*
strstr(constchar*s1,const char*s2)
{
        const char*p = s1;
        const size_t len = strlen(s2);
        for(; (p = strchr(p, *s2)) != 0; p++)
    {
            if(strncmp(p, s2, len) == 0)
            return(char*)p;
    }
        return(0);
}
 

 

memcpy

函数原形:

void*memcpy(void *dest,const void *src,size_t n)

功能:

从src拷贝n个字节到dest中.

C语言中使用#include<string.h>

C++中使用#include<cstring>

返回值

函数返回dest的值。

注意事项:

1.dest和src内存区域是可以重叠的.使用memmove可以处理重叠区域.

2.返回一个void*,可以链式操作

3.按字节赋值内存数据,不考虑数据内容(无格式复制).

4.当dest头部覆盖src尾部时候,会发生错误,即无限赋值.

void*memcpy(void *dest,const void *src, size_t n)
{
    assert( (!dest) && (!src) ) ;
    char *temp = dest;
    while(n--){
        *temp++ = *src++;
    }
    return dest;
}

 

memmove函数

函数原形:

void *memmove(void *dest, const void *src, size_t n);

注意事项:

1.该函数核心在于可以处理有重叠部分的数据

2.当数据有重叠部分的时候,总是dest覆盖src.

3.当src<dest且有重叠区域的时候,从后向前复制

4.当src>dest且有重叠区域的时候,从前向后复制.

5.当没有重叠区域的时候从前向后复制

函数实现:

void* memmove(void *dest, const void *src, size_t n)
{
assert( (dest!=null) && (src != null));
char *de_begin = (char*)dest;
const char *src_begin = (char*)src;
if (de_begin>src_begin &&de_begin-src_begin<n) {
while ( n--){
*(de_begin+n) = *(src+n);
}
}  else {
while ( n--){
*de_begin++ = *src+n+;
}
}
return dest;
}

memset函数

void *memset(void *str, int c,size_t n);

功能:将s所指向的某一块内存中的每个字节的内容全部设置为ch指定的ASCII值,块的大小由第三个参数指定,这个函数通常为新申请的内存做初始化工作。

注意事项:

1.函数指针为空情况

2.按字节复制

3.返回值,可以进行链式操作

void *memset(void *str, int c,size_t n)
{
asssert( str==null);
char *p =(char*)str;
char ch =(char)c;
while(n--){
*p++ = ch;
}
return str;
}

 

strcmp

所在头文件：string.h

功能：比较字符串s1和s2。

一般形式：strcmp(字符串1，字符串2)

说明：

当s1<s2时，返回值=-1

当s1==s2时，返回值=0

当s1>s2时，返回值 =1

注：c++ 中

当s1<s2时，返回值小于0

当s1==s2时，返回值等于0

当s1>s2时，返回值 大于0

即：两个字符串自左向右逐个字符相比（按ASCII值大小相比较），直到出现不同的字符或遇'\0'为止。

intstrcmp(constchar *s1,const char * s2)
{
    assert((s1==null)||(s2==null));
    while(*s1 && *s2 && *s1 ==*s2){
s1++;
s2++;
}
return *s1-*s2;
}

 

string类

 

//该string类中,内部数据_data总是存在的,即永远不为null
class string
{
public:
    string()
: _data(new char[1])
    {
        *_data = '\0';
    }
//当str为null时候,将异常转移到strlen函数中
//由strlen函数控制异常的处理.
//也可以根据具体要求改写str为null时候的处理方式
    string (const char* str)
        :_data(new char[strlen(str)+1])
    {
        strcpy(_data,str);
    }
    //获取内部数据_data,但是不允许改写,如果要改写必须通过函数进行.
    //防止误操作,将_data改写
    const char* getStr()const
    {
        return _data;
    }
//拷贝构造函数
//将异常转移到temp的构造函数中
    string(const string& str)
    {
        string temp(str.getStr());
        char *p = temp._data;
        temp._data = _data;
        _data = p;
    }
//将异常转移到临时对象str中.
//当自我拷贝的时候,会增加无所谓的成本.
    string& operator = (string str)
    {
        char *p = str._data;
        str._data = _data;
        _data = p;
    }
//版本2
//考虑到自我拷贝
    string& operator = (const string& str)
    {
if(&str == this)
return *this;
string temp(str._data);
        char *p = temp._data;s
        temp._data = _data;
        _data = p;
    }
    ~string()
    {
        delete []_data;
    }
private:
    char *_data;
};