C语言中字符字符串以及内存操作函数

1字符及其操作函数

1.1字符

    字符类型char是C语言中极为重要的一种类型，相比整型，浮点型其操作也有略微不同，今天就来介绍C语言中关于字符的那些事。

    我们这里谈到的字符均指的是美国信息交换标准代码（American Standard Code for Information Interchange，下文简称ASCII码）表中的字符，根据该表可知，每一个字符都对应一个编号，例如字符'a'的ASCII码编号为97，字符'A'的ASCII码编号为65，字符'1'的ASCII码编号为49等等。由于计算机只能存储二进制码，所以字符在内存中实际存储的是该字符对应ASCII码的二进制码，因此我们也可以这样认为：char相当于是1个字节的无符号整型。

b8fa57afb64bbee79618b21ade3dc6d4.png

图1.1 ASCII码表

    由于有些字符或命令不能直接被表示出来（例如回车符，再如C语言中定义一个字符需要用单引号把字符引起来，而单引号自己本身也是字符），此时我们需要使用转义字符来表示，其书写格式为“反斜杠后边跟指定字符”，而此时转义字符中的反斜杠后边那个字符将不再表示其原来的含义。例如'n'的本意就表示英文字符'n',如果加上反斜杠：'\n'，此时编译器会把反斜杠和n放在一起编译，其对应的含义就为换行。

    常见的转义字符和所对应的含义（来源百度百科<转义字符>）：

转义字符

含义

ASCII码值

\a

响铃（BEL）

007

\b

退格（BS），将当前位置移到前一列

008

\f

换页（FF），将当前位置移到下页开头

012

\n

换行（LF），将当前位置移到下一行开头

010

\r

回车（CR），将当前位置移到本行开头

013

\t

水平制表(HT) （跳到下一个TAB位置）

009

\v

垂直制表(VT)

011

\\

代表一个反斜线字符''\'

092

\’

代表一个单引号（撇号）字符

039

\”

代表一个双引号字符

034

\?

代表一个问号

063

\0

空字符(NULL)

000

\ddd

1到3位八进制数所代表的任意字符

三位八进制

\xhh

十六进制所代表的任意字符

十六进制


    对于汉字，不同的编码对应的汉字所占的字节数不同，因此本文不做讨论。

1.2字符操作函数

    C语言中关于字符函数主要有两大类，一类是字符分类函数，常用于判断用户的输入是否合法，另一类是字符转换函数，用于将英文字母的字符转换为大写或者小写。

1.2.1字符分类函数

    常见的字符分类函数见下表：

函数

如果该函数的参数符合下述条件就返回真，否则返回假

iscntrl

任何控制字符

isspace

空白字符：空格’ ’，换页’\f，换行’\n’，回车’\r’，制表符’\t’，垂直制表符’\v’。

isdigit

十进制数字0~9

isxdigit

十六进制数字，包括所有的十进制数字，小写字母a~f,大写字母A~F

islower

小写字母a~z

isupper

大写字母A~Z

isalpha

字母a~z或A~Z

isalnum

字母或数字，0~9,a~z,A~Z

ispunct

标点符号，任何不属于数字或字母的字符（可打印）

isgraph

任何图形字符

isprint

任何可打印字符，包括图形字符和空白字符

    注：在ASCII码中，第0～31号及第127号(共33个)是控制字符或通讯专用字符，如控制符：LF（换行）、CR（回车）、FF（换页）、DEL（删除）、BS（退格)、BEL（振铃）等；通讯专用字符：SOH（文头）、EOT（文尾）、ACK（确认）等。

1.2.2字符转换函数

  • 转小写：

int tolower(int c);

  • 转大写：

int toupper(int c);

    例如：

char s = 'a';
printf("%c\n",toupper(s));
printf("%c\n",s);

    image.png

图1.2   

    从程序运行结果可以看出来，在转换字符时，字符本身没有发生变化，只是字符转换函数将其对应的大写（或小写）对应的ASCII码值返回。如果想改变某个字符串的大写或小写，只需遍历该字符串，使用字符转换函数即可。

2字符串及其操作函数

2.1字符串

    严格来讲，C语言中并没有字符串类型，因此我们使用字符数组来模拟字符串，或者直接使用常量字符串。既然是以字符数组来模拟字符串，而字符又以ASCII码存放在内存中，何时停止？即编译器如何知道到哪里是某段字符串的结束。C语言标准有如下规定：以'\0'作为字符串的结束标志。

    字符串有两种定义方式：

    方式1：

char str1[] = "Hello";

    虽然Hello有5个字符，但实际上系统会自动在字符'o'后边加上字符'\0'.如下图所示。

image.png

图2.1

    方式2：

char str2[6] = {'H','e','l','l','o','\0'};

    对于这种定义方式，必须要在最后手动加上'\0'，否则我们定义的就是字符数组而不是字符串。

2.2字符串函数

    C语言中，跟字符串相关的函数主要有以下几个：

函数名

含义

strlen

求取字符串长度

strcpy

字符串拷贝

strcat

字符串拼接函数

strcmp

字符串比较函数

strncpy

字符串指定字符数拷贝

strncat

字符串指定字符数拼接

strcnmp

字符串指定字符比较函数

strstr

判断一个字符串是否为另一个字符串的片段

strtok

按指定分隔符分割字符串

strerror

错误信息报告函数

下面将逐一介绍并模拟实现其中的部分函数。

2.2.1strlen

    strlen:求字符串长度函数.

size_t strlen( const char *string );

    可以看出，该函数的返回值为无符号整型，所以实际应用中我们不能直接对两个strlen进行减法，否则会出错。

    strlen的功能是求取一个字符串的长度，在上文中我们已经提到过，字符串的末尾以'\0'作为结束标志，所以我们只要从字符串的开始进行遍历，当到'\0'时自动停止，然后返回'\0'前的字符数。

    所以可以写出如下代码：

size_t my_strlen1( const char *str )
{
    assert(str);
    int count = 0;
    while (*str++ && ++count);
    return count;
}

或者

size_t my_strlen2( const char *str )
{
    assert(str);
    const char *start = str;
    while (*str++);
    return (str - 1 - start);//减1是因为上一步中指针指向'\0'后，虽然条件不满足退出了循环，但str还要接着进行一步加加操作，所以减掉1.
}

或者不使用临时变量：

size_t my_strlen3( const char *str )
{
    assert(str);
    if (*str == '\0')
    {
        return 0;
    }
    return my_strlen3(str+1)+1;
}

2.2.2strcpy

    strcpy:字符串拷贝函数：

char *strcpy( char *strDestination, const char *strSource );

其含义是把源头字符串strSource拷贝到目的地字符串strDestination中去。

该函数使用有如下注意事项：

  • 首先要保证目的地字符串的空间足够大，能够放下源头字符串，目的地字符串空间至少要和源头空间一样大，此外，目标空间还应当可修改（不被const修饰）.

  • 源字符串必须要以'\0'结束，否则会出错。

  • 源字符串的'\0'会拷贝到目标空间中，作为字符串的结束标志。

  • 返回 char*是为了实现函数的链式访问。

    模拟实现：

char* my_strcpy( char *dest, const char *src )
{
    assert(dest);
    assert(src);
    char* ret = dest;
    while(*dest++ = *src++);
    return ret;
}

2.2.3strcat

    strcat:字符串拼接函数

char *strcat( char *strDestination, const char *strSource );

其含义是把源字符串strSource拼接到目标字符串strDestination之后。

    该函数使用有如下注意事项：

  • 目标字符串剩余空间足够大可以容纳下源字符串。

  • 源字符串必须要以'\0'结尾。

  • 追加时是从目标字符串的'\0'位置处开始的，即会把'\0'覆盖掉，因此字符串不能给自己追加自己本身。

    模拟实现：

char* my_strcat( char *dest, const char *src )
{
    assert(dest);
    assert(src);
    char* ret = dest;
    while (*dest++);
    dest--;
    while (*dest++ = *src++);
    return ret;
}


2.2.4strcmp

    strcmp:字符串比较函数

int strcmp( const char *string1, const char *string2 );

    字符串本身没有大小，此处比较的是两个字符串对应字符的ASCII码值的大小，即如果string1的第一个字符ASCII码值大于string2的第一个字符ASCII码值，就返回一个大于0的数，如果string1的第一个字符ASCII码值小于string2的第一个字符ASCII码值，就返回一个小于0的数，如果string1的第一个字符ASCII码值等于string2的第一个字符ASCII码值，就接着比较它们的第二个字符，以此类推。

    模拟实现：

int my_strcmp( const char *str1, const char *str2 )
{
    assert(str1);
    assert(str1);
    while (*str1 == *str2)
    {
        if (*str1 == '\0')
        {
            return 0;
        }
        str1++;
        str2++;
    }
    return *str1 - *str2;
}


2.2.5strcpy

    strncpy:字符串指定字符数拷贝

char *strncpy( char *strDest, const char *strSource, size_t count );

其含义是把源字符串的count个字符拷贝到目标字符串空间。

    该函数使用时有如下注意事项：

  • 如果源字符串长度小于count，则在拷贝完源字符串后，在目标后边追加'\0'，直到追加count个。

  • count应当不超过目标字符串空间(因为字符串最后还有'\0'，所以count应当小于目标字符串的空间)。

    模拟实现：

char* my_strncpy( char *dest, const char *src, size_t n)
{
    assert(dest);
    assert(src);
    char* ret = dest;
    while(n && (*dest++ = *src++))
    {
        n--;
    }
    if(n)
    {
        while (--n)
        {
            *dest++ ='\0';
        }
    }
    return ret;
}

2.2.6strncat

    strncat:字符串指定字符数拼接

char *strncat( char *strDest, const char *strSource, size_t count );

        其含义是把源字符串的count个字符追加到目标字符串后边。

    该函数使用时有如下注意事项：

  • 目标字符串必须以'\0'结尾。

  • 追加时从目标字符串的'\0'开始追加，count个字符串追加结束后，在后边补'\0'。

  • count不应当超过目标字符串剩余的空间。

  • 如果源字符串长度不够count个，则在后边追加'\0'，直到补满count个为止。

    模拟实现：

char *my_strncat( char *dest, const char *src, size_t n )
{
    assert(dest);
    assert(src);
    int i;
    char* ret = dest;
    while(*dest)
    {
        dest++;
    }
    for(i=0;src[i] && i<n;i++)
    {
        dest[i] = src[i];
    }
    while(i <= n)
    {
        dest[i] = '\0';
        i++;
    }
    return ret;
}


2.2.7strncmp

    strncmp:比较两个字符串的前n个字符

int strncmp( const char *string1, const char *string2, size_t count );

    比较两个字符串的前count字符，原理同strcmp。

2.2.8strstr

    strstr:判断一个字符串是否为另一个字符串的子字符串。

char *strstr( const char *string, const char *strCharSet );

其含义为判断strCharSet是否为string的子字符串。返回值为一个指针，如果不是子字符串，则返回一个NULL指针，如果是，则返回strCharSet在string中第一次出现的位置。

    实现原理，从string的第一个字符与strCharSet的第一个字符进行比较，如果不相等，就比较string的第二个字符和strCharSet的第一个字符，如果相等，比较string的第三个字符和strCharSet的第二个字符，如果不相等，则从string的第三个字符开始再与strCharSet的第一个字符比较，以此类推。

    模拟实现：

char *my_strstr( const char *str1, const char *str2)
{
    const char* s1 = str1;
    const char* s2 = str2;
    const char* cp = str1;
    if(*str2 == '\0')
    {
        return str1;
    }
    while(cp)
    {
        s1 = cp;
        s2 = str2;
        while(s1 && s2 && *s1 = *s2)
        {
            s1++;
            s2++;
        }
        if(*s2 = '\0')
        {
            return (char*)cp;
        }
        cp++;
    }
    return NULL;
}


2.2.9strtok

    strtok:按指定分隔符分割字符串

char *strtok( char *strToken, const char *strDelimit );

其含义是按照strDelimit中的字符来分割字符串strToken。

    该函数使用时应注意：

  • strToken包含了0个或多个由strDelimit字符串中一个或多个分隔符分割的标记。

  • strtok函数找到strToken中的下一个标记，将该标记改为'\0',并返回一个指向该子串的指针。

  • 如果strtok函数的第一个参数不为NULL，函数将找到str中的第一个标记，strtok函数将保存它在字符串中的位置。并返回被已经分隔好的字符串的起始地址。

  • 如果strtok函数的第一个参数为NULL，函数将在同一个字符串中被保存的位置开始，查找下一个标记。

  • 如果字符串中没有更多的标记（即所有的标记已经查找完），则返回NULL指针。

    使用案例：

char str1[] = "123.456.55.88";
char str2[] = ".";
char* p = NULL;
char str3[50];
strcpy(str3,str1);
for (p = strtok(str3, str2); p != NULL; p = strtok(NULL, str2))
{
    printf("%s\n",p);
}


2.2.10strerror

    strerror:返回错误码所对应的错误信息

char* strerror(int errnum)

    在编写程序时，总有某些情况我们考虑不周全，在程序的某些可能出错地方，我们可以预先设置一些错误提示，这样在程序运行时，可以帮助我们迅速定位到出错的位置，使程序更加易于调试。在系统中提前定义好了一些错误和错误码，这些错误码放在全局变量errno(需要引用头文件errno.h)中。我们在使用时只需要调用上述函数，如果发生错误，将会为我们返回错误码及其对应的信息，没有错误时，errno默认的值为0.

    例如：打开一个文件前，我们需要判断文件是否存在，如果不存在就不能打开，此时就可以调用该函数。


FILE* pFile;
pFile = fopen("1.txt","r");
if (pFile == NULL)
{
    printf("Error opening file 1.txt:%s\n", strerror(errno));
}

    由于实际中，并没有该文件，所以程序输出该文件不存在，如图所示。

image.png

图2.2

    还有另外一个函数perror，整合了打印和strerror的功能，所以上述代码行中printf对应的那行可以改写为：

perror("Error opening file 1.txt")

两者输出结果一样。

3内存（memory）操作函数

    在字符串操作中，有字符串的比较，拷贝，拼接等等，但其只能实现字符串的操作，往往还受其结束符'\0'的限制，当我们想拷贝比较或者其他类型时，这些函数则失去了作用，所以在此处引入内存操作函数，其与字符串操作函数类似，但又不尽相同。

3.1memcpy

    memcpy：字符串拷贝函数

void *memcpy( void *dest, const void *src, size_t count );

其含义为该函数会从src对应的起始地址开始向后拷贝count个字节的数据到dest指向的地址中。拷贝结束，返回dest的起始地址。

    由于是对内存直接进行拷贝，所以其可以拷贝任何类型的数据，当然也不受'\0'的限制，即遇到该字符时并不会停下来，而是接着拷贝，直到拷贝满count个字节为止。

    当dest在src+count的范围内时，则复制结果不一定正确（对于不同的平台该函数实现的方式不太一样，如果拷贝和粘贴同时进行，则重叠区域会被新数据覆盖掉，拷贝结果可能就不是我们所期望的，而如果是先拷贝完后再粘贴，才可能是我们所期望的）。

    模拟实现：

void *my_memcpy1( void *dest, const void *src, size_t num )
{
    assert(dest);
    assert(src);
    void* ret = dest;
    int i;
    for (i = 0; i < num; i++)
    {
        *((char*)dest+i) = *((char*)src+i);
    }
    return ret;
}

或者

void *my_memcpy2( void *dest, const void *src, size_t num )
{
    assert(dest);
    assert(src);
    void* ret = dest;
    while(num--)
    {
        *((char*)dest) = *((char*)src);
        dest = (char*)dest+1;
        src = (char*)src+1;
    }
    return ret;
}


3.2memmove

    memmove:内存移动

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

顾名思义，内存移动，就是把src开始向后的count个字节内存拷贝移动到dest对应的位置上。和memcpy函数一样，都是把src开始向后的count个字节内存拷贝移动到dest对应的位置上，但是上边也谈到，当dest在src+count范围（或者src在dest+count的范围内）内，即源空间和目标空间有重叠时，memcpy就无法保证拷贝结果的正确性，memmove函数就是为了解决此问题。

    分析，当dest在src+count范围内时（也就是dest在src的右边），即如图所示：

image.png

图3.1

D为重叠区域，如果从前向后拷贝，即先把A拷贝到D处，则会把原来D位置的数据覆盖掉，那么再把D处的数据拷向G时，实际上拷贝的是A的数据。如果从后向前拷贝，即先把D处的数据拷贝到G，再把C处的数据拷贝到F，依次类推，此时可以达到我们想要的结果。

而当src在dest+count的范围内（即dest在src的左边），如图所示，按照上述分析此时应当从前向后拷贝，即先把D处得到数据拷贝到A中，再把E处的数据拷贝到B中，依次类推。

image.png

图3.2

有了上述分析，进行模拟实现（实际上主要是判断dest是在src的左边还是右边）：

void *my_memmove( void *dest, const void *src, size_t num )
{
    assert(dest);
    assert(src);
    void* ret = dest;
    if (dest < src)
    {
        while{num--}//从前向后拷贝
        {
            *((char*)dest) = *((char*)src);
            dest = (char*)dest+1;
            src = (char*)src+1;
        }
    }
    else
    {
        while{num--}//从后向前拷贝
        {
            *((char*)dest+count) = *((char*)src+count);
        }
    }
    return ret;
}

3.3memcmp

    memcmp:比较函数

int memcmp( const void *buf1, const void *buf2, size_t count );

其含义为比较内存区域buf1与buf2的count个字节的大小。

  • 如果buf1>buf2，则返回正数；

  • 如果buf1=buf2，返回0；

  • 如果buf1<buf2，返回负数；

    模拟实现：

int my_memcmp( const void *buf1, const void *buf2, size_t num )
{
    assert(buf1);
    assert(buf2);
    while(*((*char)buf1) == *((*char)buf2)&& count--)
    {
        buf1 = (*char)buf1+1;
        buf2 = (*char)buf2+1;
    }
    if (count == 0)
    {
        return 0;
    }
    return *((char*)buf1) - *((char*)buf2)
}


3.4memset

    memset:初始化

void *memset( void *dest, int c, size_t count );

其含义为从dest位置开始，将接下来的count个字节置为整数c，并最终返回dest的地址。

因为是按字节赋值，所以无论c多大，系统都只能取c的后八位二进制码对其进行赋值，也正是因为如此，一般用0（二进制码全0）或-1（二进制码全1）进行初始化，否则容易出错。