一些简单函数的实现

#include<iostream>
#include<stdio.h>
#include<vector>
#include<assert.h>
#include <string.h>
using namespace  std;


#include <stdio.h>

#include <assert.h>

int strlen_new(const char* src)

{

    int len = 0;

    assert(src);

    while(*src++ != '\0')

        len ++;

    return len;

}

int strlen_new1(const char* str)

{

    const char *temp = str;

    assert(str);

    while(*str ++ !='\0');

    /*通过地址长度来取得*/

    return str - temp -1;

}

int main()
{
	char *p="01234566789";
	printf("%d\n",strlen (p));
}

strcpy 函数的实现

char *strcpy(char *det,const char * src);

1.实现strcpy函数

char * strcpy(char *dst,const char *src)
{
	assert(dst!=NULL&&src!=NULL);
	char *ret=dst;
	while((*dst++=*src++)!='\0');
	return  ret;
}
//注意while(*dst++=*src++) 这样写是错误的

2.解释为什莫要返回char*

但会dst的原始值使函数能够支持链式表达式

链式表达式的形式如下

int l=strlen(strcpy(strA,strB));

char*strA=strcpy(new char[10],strB);

返回src的值是错误的，因为源字符串肯定是已知的，返回他没有意义

不能支持char*strA=strcpy(new char[10],strB)这样的表达式

把const char*作为char *返回，类型不符，编译报错

 

 

3.假如考虑dst和src内存重叠的情况，strcpy该怎末实现

char s[10]=''hello'';

strcpy(s,s+1);//应返回ello

char s[10]="hello";

strcpy(s, s+1); //应返回ello，

//strcpy(s+1, s); //应返回hhello，但实际会报错，因为dst与src重叠了，把'\0'覆盖了

所谓重叠，就是src未处理的部分已经被dst给覆盖了，只有一种情况：src<=dst<=src+strlen(src)

C函数memcpy自带内存重叠检测功能，下面给出memcpy的实现my_memcpy。

char * strcpy(char *dst,const char *src)
{
    assert(dst != NULL && src != NULL);

    char *ret = dst;

    my_memcpy(dst, src, strlen(src)+1);

    return ret;
}

char *my_memcpy(char *dst, const char* src, int cnt)
{
    assert(dst != NULL && src != NULL);

    char *ret = dst; 

    if (dst >= src && dst <= src+cnt-1) //内存重叠，从高地址开始复制
    {
        dst = dst+cnt-1;
        src = src+cnt-1;
        while (cnt--)
            *dst-- = *src--;
    }
    else    //正常情况，从低地址开始复制
    {
        while (cnt--)
            *dst++ = *src++;
    }
    
    return ret;
}