strcpy()

原型宣告：char strcpy(char dest, const char *src); 
功能：把從src地址開始且含有NULL結束符的字串複製到以dest開始的地址空間 
說明：src和dest所指記憶體區域不可以重疊且dest必須有足夠的空間來容納src的字串。 
返回指向dest的指標。

#include <assert.h>

char* *strcpy(char* dest, constchar *src) //point1: 源字串不改變，需要加const保證{
    assert(NULL != dest && NULL != src); 
 
//point2:保證指標有效

char * temp = dest;                  //point3:下面涉及到指標的移動，而我們需要返回dest的頭指標，所以dest保留，而使  用temp來移動

 while ((*temp++ = *src++) != '\0'); /* point4:末尾的'\0'也要複製過來
     * 上面先執行 *temp++ = *src++ ，再判斷 *src 是否等於'\0'
     * 所以保證了'\0'先複製後判斷
     */

     return dest; //point5:返回dest頭指標，支援鏈式表示式
}

鏈式的例子：

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

• 1

strncpy()

strcpy()是一個高危函式，因為沒有指定複製的大小，當dest的空間比src小時，就會出錯，而我們沒法進行控制。於是有了比較安全的strncpy()：

//把src所指向的字串中以src地址開始的前n個位元組複製到dest所指的陣列中，並返回dest。#include <assert.h>char *strncpy(char* dest, constchar *src, unsignedint n)
{
    assert(NULL != dest && NULL != src);
    char
 
 * temp = dest;
    while (n-- > 0 && (*temp++ = *src++) != '\0'); 
    /* 上面語句兩種終止情況：
     * 1. n = 0，此時下面的語句也不執行，如果未達到src末尾
     * 不會自動在dest末尾新增'\0'的，所以需要使用者自己新增
     * 2. n > 0 但是src已經到達末尾，那麼執行下面語句，將
     * dest填充'\0'達到長度n（ANSI C規定）
     */while (n-- > 0) *temp++ = '\0';
    return dest;
}

strcmp()

比較兩個字串 
設這兩個字串為str1，str2， 
若str1==str2，則返回零； 
若str1>str2，則返回正數； 
若str1

#include <assert.h>intstrcmp(constchar *str1, constchar *str2)
{
    assert(NULL != str1 && NULL != str2);
    /*不可用while(*str1++==*str2++)來比較，當不相等時仍會執行一次++，
    return返回的比較值實際上是下一個字元。應將++放到迴圈體中進行。*/

     while(*str1 && *str2 && *str1 == *str2)
    {
        str1++;
        str2++;
    }
    return *str1 - *str2;
    /* 若相等，則*str1 - *str2 = '\0' - '\0' = 0;
     * 否則，*str1 - *str2 != 0;
     * 因為前面的位都相等，所以只需要比較當前位來確定返回值
     */
}

strcat()

把src所指字串新增到dest結尾處(覆蓋dest結尾處的’\0’)。

char *strcat(char *dest,constchar *src)
{
    assert(NULL != dest && NULL != src);
    char *temp = dest;
    while ('\0' != *temp) //自增放在迴圈裡，才可以覆蓋'\0'
        ++temp;
    while ((*temp++ = *src++) != '\0');
    return dest;
}

strlen()

功能：計算給定字串的（unsigned int型）長度，不包括’\0’在內 
說明：返回s的長度，不包括結束符NULL。

unsignedintstrlen(constchar *s)
{
    assert(NULL != s);
    unsignedint len = 0;
    while (*s++ != '\0')
        ++len;
    return len;
}

memset()

void *memset(void *s, int ch, size_t n);

函式解釋：將s中前n個位元組 （typedef unsigned int size_t ）用 ch 替換並返回 s 。 
memset：作用是在一段記憶體塊中填充某個給定的值，它是對較大的結構體或陣列進行清零操作的一種最快方法。

注意，memset是以【位元組】為單位進行賦值的，因此下面用法將導致錯誤：

int arr[5];
memset(array,1,sizeof(arr));

arr指向5個位元組的空間，每個都用ASCII為1的字元去填充，轉為二進位制後，1就是00000001,佔一個位元組。一個INT元素是4位元組，合一起就是00000001000000010000000100000001，就等於16843009，就完成了對一個INT元素的賦值了。所以上面結果不是1而是16843009！

void *memset(void *s,int c,unsignedint n) //point1:s指標型別未知,另外，n為位元組數！
{
    assert(NULL != s);
    void *temp = s;
    while (n--)
    {
        *(char *temp) = (char)c; //point2:轉化為字元（1位元組）
        temp = (char *)temp + 1; //point3:不能自增，因為不知道指標型別
    }
    return s;
}

memcpy()

記憶體拷貝函式，memcpy函式的功能是從源src所指的記憶體地址的起始位置開始拷貝n個位元組到目標dest所指的記憶體地址的起始位置中。

void *memcpy(void *dest, constvoid *src, size_t n)
{
    assert(NULL != dest && NULL != src);
    int i = 0;
    void *temp = dest;
    while (i < n)
    {
        *((char *)temp + i) = *((char *)src + i); //未知型別，不能自增
        ++i;
    }
    return dest;
}

atoi()

這個函式就比較經典了，面試常常出現，因為可以考察各種特殊情況：空指標、空串、正負號、非法字元、溢位等等。

最大的int：0x7FFF FFFF; 
最小的int：0x8000 0000;

enum = {Invalid = 0, Valid};
bool errno = Invalid;
int atoi(const char * str)
{
    longlong num = 0; //point1:可能溢位，所以用long long存
    errno = Invalid;
    if (NULL != str && *str != '\0') //point2
    {
        bool minus = false;
        if (*str == '+')
        {   
            ++str;
        }
        elseif (*str == '-')
        {
            ++str;
            minus = true;
        }
        if ('\0' != *str) //只有符號，Invalid
            atoiCore(str, minus, num);
    }
    return (int)num; //已經檢查過溢位，保證了num在int範圍內    
}

void atoiCore(const char *str, bool minus, longlong &num)
{
    while ('\0' != *str)
    {
        if (*str >= '0' && *str <= '9')
        {
            num = num*10 + (*str) - '0';
            ++str;
            if ((!minus && num > 0x7FFFFFFF)||(minus && (-num) < (signed int)0x80000000))
            {
                errno = Invalid;
                num = 0;
                return;
            }
        }
        else
        {
                errno = Invalid;
                num = 0;
                return;
        }
    }
    if (minus)
        num = -num;
    errno = Valid;
}