常见函数实现

(1 ) Strlen（）的C语言实现(不能使用任何变量...)
===============
strlen的几种不同实现方法
第一种方法：
int strlen(const char *str)
{
    assert(str != NULL);
   
    int len = 0;
   
    while((*str++) != '\0')
    {
        len++;
    }
   
    return len;
}

第二种方法：
int strlen(const char *str)
{
    assert(str);
   
    const char *p = str;
   
    while(*p++);
   
    return p - str - 1;
}

第三种方法：
int strlen(const char* str)
{
    if (str[0] == '\0')
    {
        return 0;
    }
    else
    {
        return strlen((char *)(&str[0]+1))+1;
    }
}


strcpy函数－软件工程师面试常考的一道题

编写strcpy 函数
已知strcpy 函数的原型是
char *strcpy(char *strDest, const char *strSrc);
其中strDest 是目的字符串，strSrc 是源字符串。
（1）不调用C++/C 的字符串库函数，请编写函数 strcpy
char *strcpy(char *strDest, const char *strSrc);
{
assert((strDest!=NULL) && (strSrc !=NULL));
char *address = strDest;
while( (*strDest++ = * strSrc++) != ‘\0’ )
NULL ;
return address ;
}
（2）strcpy 能把strSrc 的内容复制到strDest，为什么还要char * 类型的返回值？
答：为了实现链式表达式。
例如 int length = strlen( strcpy( strDest, “hello world”) );

 

测试用：( 编译: gcc strcpy.c -Wall -g  运行: a.out  abcdef   结果: The string is: abcdef)

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

char *strcpy1(char *str_dest, const char *str_src);
int main(int argc, char **argv)
{
    char *p = NULL;
    char *q = NULL;
    p = malloc(sizeof(argv[1]));
    q = malloc(sizeof(argv[1]));
    p = strcpy1(q, argv[1]);
    printf("The string is:%s\n", p);
    return 0;
}

char *strcpy1(char *str_dst, const char *str_src)
{
    assert((str_dst != NULL) && (str_src != NULL));
    char *address = str_dst;
    while ((*str_dst++ = *str_src++) != '\0') {
        NULL;
    }
    return address;
}

补充：

1、布尔变量与零值比较
??  不可将布尔变量直接与TRUE、FALSE 或者1、0 进行比较。根据布尔类型的语义，零值为“假”（记为FALSE），任何非零值都是“真”（记为TRUE）。TRUE 的值究竟是什么并没有统一的标准。例如Visual C++ 将TRUE 定义为
1，而Visual Basic 则将TRUE 定义为-1。假设布尔变量名字为flag，它与零值比较的标准if 语句如下：

　　if (flag) // 表示flag 为真if (!flag) // 表示flag 为假
其它的用法都属于不良风格，例如：
　　if (flag == TRUE)
　　if (flag == 1 )
　　if (flag == FALSE)
　　if (flag == 0)
2、整型变量与零值比较
??  应当将整型变量用“==”或“！=”直接与0 比较。假设整型变量的名字为value，它与零值比较的标准if 语句如下：

　　if (value == 0)
　　if (value != 0)
不可模仿布尔变量的风格而写成
　　if (value) // 会让人误解 value 是布尔变量
　　if (!value)
3、浮点变量与零值比较
??  不可将浮点变量用“==”或“！=”与任何数字比较。千万要留意，无论是float 还是double 类型的变量，都有精度限制。所以一定要避免将浮点变量用“==”或“！=”与数字比较，应该设法转化成“>=”或“<=”形式。
假设浮点变量的名字为x，应当将
　　if (x == 0.0) // 隐含错误的比较
转化为
　　if ((x>=-EPSINON) && (x<=EPSINON))
其中EPSINON 是允许的误差（即精度）。
4、指针变量与零值比较
??  应当将指针变量用“==”或“！=”与NULL 比较。指针变量的零值是“空”（记为NULL）。尽管NULL 的值与0 相同，但是两者意义不同。假设指针变量的名字为p，它与零值比较的标准if 语句如下：
　　if (p == NULL) // p 与NULL 显式比较，强调p 是指针变量
　　if (p != NULL)
不要写成
　　if (p == 0) // 容易让人误解p 是整型变量
　　if (p != 0)
或者
　　if (p) // 容易让人误解p 是布尔变量
　　if (!p)

有时候我们可能会看到 if (NULL == p) 这样古怪的格式。不是程序写错了，是程
序员为了防止将 if (p == NULL) 误写成 if (p = NULL)，而有意把p 和NULL 颠倒。
编译器认为 if (p = NULL) 是合法的，但是会指出 if (NULL = p)是错误的，因为NULL
不能被赋值。

5、for循环效率

   在多重循环中，如果有可能，应当将最长的循环放在最内层，最短的
循环放在最外层，以减少CPU 跨切循环层的次数。例如示例(b)的效率比示例
(a)的高。
for (row=0; row<100; row++)
{
for ( col=0; col<5; col++ )
{
sum = sum + a[row][col];
}　　　　　　
}

　　　　　　(a)低效率：长循环在最外层

for (col=0; col<5; col++ )
{
for (row=0; row<100; row++)
{
sum = sum + a[row][col];
}
}

　　　　　　(b)高效率：长循环在最内层

6、for循环效率

如果循环体内存在逻辑判断，并且循环次数很大，宜将逻辑判断移到循环体的外面。示例(c)的程序比示例(d)多执行了N-1 次逻辑判断。并且由于前者老要进行逻辑判断，打断了循环“流水线”作业，使得编译器不能对循环
进行优化处理，降低了效率。如果N 非常大，最好采用示例4-4(d)的写法，可以提高效率。如果N 非常小，两者效率差别并不明显，采用示例4-4(c)的写法比较好，因为程序更加简洁。
for (i=0; i<N; i++)
{
if (condition)
DoSomething();
else
DoOtherthing();
}

 

　　　　表(c) 效率低但程序简洁

if (condition)
{
for (i=0; i<N; i++)
DoSomething();
}
else
{
for (i=0; i<N; i++)
DoOtherthing();
}

　　　　表(d) 效率高但程序不简洁