字符串解析

字符串操作

bcmp（）

比较s1和s2前n个字符是否相等

• int bcmp(const void *s1, const void *s2, size_t n);
• 返回值
  当是s1和s2相等，或者n为0时，返回0；
  其他返回非0值。
• 注意：
  函数不检查地址是否为NULL；
  n可以大于字符串长度。

bcopy

copy byte sequence
从src复制n长度的字符串给dest

• void bcopy(const void *src, void *dest, size_t n);
• 注意：
  不检查NULL

bzero()

write zero-valued bytes
置字符串s的前n个字节为0
void bzero(void *s, size_t n);

memcpy

从src指向的内存复制n长度的字符串给dest指向的内存，返回指针指向dest
void *memcpy(void *dest, const void *src, size_t n);

sprintf()

变参按照format格式拼接成字符串，存入str中
int sprintf(char *str, const char *format, ...);
int snprintf(char *str, size_t size, const char *format, ...);

#include
#include
typedef struct student
{
    char *name;
    unsigned char age;
    float score;
}stu;
int main(int argc, char *argv[])
{
    stu li;
    li.name = "lisi";
    li.age = 20;
    li.score = 98.5;
    char info[50];

    sprintf(info, "name：%s\nage: %d\nscore:%g\n", li.name, li.age, li.score);
    printf("%s", info);

    return 0;
}

• strcpy 危险函数！

复制字符串src给dest，包括 '\0'，但是dest的空间必须足够大，否则可能溢出，参见BUGS
char *strcpy(char *dest, const char *src);

• stpcpy 危险函数！

copy a string returning a pointer to its end
功能和strcpy相同，返回的是末尾地址
char *stpcpy(char *dest, const char *src);

strncpy

最多复制n个字节，但是如果在src的n个字节中没有空字节,那么所放置的字符串将没有结尾符
char *strncpy(char *dest, const char *src, size_t n);

stpncpy

功能和strncpy相同，返回的是末尾地址
char *stpncpy(char *dest, const char *src, size_t n);

strcat

strcat, strncat - concatenate two strings
将src连接到dest后面，返回dest地址
char *strcat(char *dest, const char *src);
测试代码：

#include  
#include 
#define MAXSIZE 10
int main(void)
{
        while(1)
        {
                int flag=0;
                char *ret;
                char dest[MAXSIZE] = {};
                char src[MAXSIZE] = {};

                for(int i=0; i<2; i++)
                {
                        printf(flag==0 ? "输入目标字符串:\n" : "输入附加字符串:\n");
                        ret = fgets(flag==0 ? dest : src, MAXSIZE, stdin);
                        if(ret)
                        {
                                char *s;
                                s = strrchr(flag==0 ? dest : src, '\n');
                                if(s)
                                        *s = '\0';
                                else
                                        while(getchar() != '\n');
                        }
                        flag=1;
                }

                
                printf("strcat   : %s\n", strcat(dest, src));
                
                printf("dest: %s\n", dest);
                printf("stc : %s\n", src);
        }

       return 0; 
}
//输出
输入目标字符串:
afaf 3rwe
输入附加字符串:
ADFEF
strcat   : afaf 3rweADFEF
dest: afaf 3rweADFEF
stc : ADFEF

strncat

char *strncat(char *dest, const char *src, size_t n);

strchr

locate character in string
在字符串c中查找字符首次出现的位置，否则返回-1
char *strchr(const char *s, int c);

strrchr

在字符串中反向查找 ，即查找字符c在s中最后出现的位置
char *strrchr(const char *s, int c);

strchrnul

和strchr类似 ，但是返回的指针指向s的结尾符\0，而不是NULL
char *strchrnul(const char *s, int c);

#include
#include
int main()
{
        char *p;
        char *s1 = "1234567890";
        char c2 = 'a';
        p = strchrnul(s1, c2);
        printf("%p\n", p);
        p = s1;
        printf("%p\n", p);
}
//输出
0x40075e
0x400754

strcmp

compare two strings
s1 < s2，返回负值
s1 = s2, 返回0
s1 > s2, 返回正值
int strcmp(const char *s1, const char *s2);

• strncmp
  int strncmp(const char *s1, const char *s2, size_t n);

strcasecmp

compare two strings ignoring case
比较字符串，忽略大小写
s1 < s2，返回负值
s1 = s2, 返回0
s1 > s2, 返回正值
int strcasecmp(const char *s1, const char *s2);

strncasecmp

int strncasecmp(const char *s1, const char *s2, size_t n);

strspn

以accept字符串的所有字符作为集合，在s字符串查找不属于该集合的第一个元素的下标
size_t strspn(const char *s, const char *accept);

strcspn

以accept字符串的所有字符作为集合，在s字符串查找属于该集合的第一个元素的下标
未找到则返回字符串s'\0'的下标
size_t strcspn(const char *s, const char *reject);

strdup

strndup, strdupa, strndupa - duplicate a string
char *strdup(const char *s);

• 描述
  The strdup() function returns a pointer to a new string which is a duplicate of the string s. Memory for the new string is obtained with malloc(3), and can be freed with free(3).

#include  
#include 
#include 

int main() 
{ 
        char *dup_str, *string="abcde"; 

        dup_str=strdup(string); 
        printf("string:%s\n", string); 
        printf("dup_str:%s\n", dup_str); 
        free(dup_str); 

        return 0; 
}
//输出
string:abcde
dup_str:abcde

strlen

计算字符串长度，不包括'\0'
size_t strlen(const char *s);

strpbrk

search a string for any of a set of bytes
在s中查找accept中的字符串，返回第一次出现的指针，否则返回NULL
char *strpbrk(const char *s, const char *accept);

strstr

locate a substring
在haystack中查找子串needle，返回haystack第一次出现needle的地址，否则返回NULL
也就是说返回值能随haystack变化而变化
char *strstr(const char *haystack, const char *needle);

strcasestr

char *strcasestr(const char *haystack, const char *needle);

strtok

char *strtok(char *str, const char *delim);

• 描述：
  The strtok() function breaks a string into a sequence of zero or more nonempty tokens. On the first call to strtok() the string to be parsed should be specified in str. In each subsequent call that should parse the same string, str must be NULL.
• 注意：
  根据delim中的分隔符，分隔字符串str。
  进行子调用时第一参数必须是NULL
  str会被破坏

#include
#include

int main()
{
        int count = 0;
        char *delims = {" ,.!"};
        char *p;
        char *buffer;

        buffer = strdup("hello world!");
        p = strtok(buffer, delims);
        count++;
        while(p != NULL)
        {
                printf("sub str:%s\n", p);            
                p = strtok(NULL, delims);       //注意，此处第一个参数为NULL
                count++;
        }
        printf("%s\n", buffer);
}
//输出：
sub str:hello
sub str:world
hello