C : 字符串操作

strstr strrstr

char *strstr(char *str, const char *sub_str);
作用：str中查找sub_str
参数：str: 被查找目标　string expression to search.
sub_str: 要查找对象　The string expression to find.
返回值：若sub_str是str的子串，则返回sub_str在str的首次出现的地址；如果sub_str不是str的子串，则返回NULL。

char *strrstr(char *str, const char *sub_str);
作用：str中查找sub_str，在字符串中查找指定字符串最后一次出现的位置
参数：str: 被查找目标　string expression to search.
sub_str: 要查找对象　The string expression to find.
返回值：若sub_str是str的子串，则返回sub_str在str的最后一次出现的地址；如果sub_str不是str的子串，则返回NULL

#include <stdio.h>

const char *my_strstr(const char *str, const char *sub_str)
{
    int i; int tem; int j;
    if(NULL == sub_str)
        return str;

    for(i=0; str[i]!='\0'; i++){
        tem = i; //tem保留str中开始判断的下标位置
        j = 0;
        while(str[i++] == sub_str[j++]){
            if(sub_str[j] == '\0'){
                return &str[tem];
            }
        }
        i = tem;
    }
    return NULL;
}

char *my_strrstr(const char *dest,const char *src)
{
    const char *ret=NULL;
    const char *last=NULL;

    if(*src == '\0')
        return (char *)dest;

    while(ret = my_strstr(dest,src)){
        last = ret;
        dest = ret + 1;
    }

    return (char *)last;
}

int main()
{
    char *s = "1233345hello345";
    char *sub = "345";
    printf("%s\n", my_strstr(s, sub));
    printf("%s\n", my_strrstr(s, sub));

    return 0;
}

strncpy

/* strncpy 实现*/
#include <stdio.h>
#include <assert.h>

char* mystrncpy(char* dest, const char* src, int len)
{ 
    assert(dest!=NULL && src!=NULL);
    char* temp = dest;

    int i = 0;
    while(i++ < len  && (*temp++ = *src++) != '\0')//temp被赋值后判断其值不为‘\0’则执行++
        ;
    if(*(temp) != '\0')
        *temp='\0';

    return dest;
}

int main(void)
{
    char buffer[50];
    char *src = "qwert yuiop";
    char *dest = NULL;

    dest = mystrncpy(buffer, src, 12);

    printf("%s\n", buffer);
    printf("%s\n", dest);

    return 0;
}

strcmp

int strcmp(const char *dest, const char *source) ;
作用：字符串比较，字符大小是按照字符的字典序列进行排列的
参数：dest: 目的字符串
source: 源字符串
都是以’/0’为结束符的字符串
返回值：如果dest > source,则返回值大于0，如果dest = source,则返回值等于0，如果dest < source ,则返回值小于0

#include <stdio.h>

int mystrcmp(const char *src, const char *dst)
{
    int ret = 0;
    while(!(ret = *src - *dst) && *dst){
        src++;
        dst++;  
    }

    if(ret < 0)
        ret = -1;
    else if(ret > 0)
        ret = 1;

    return ret;
}
 
int main()
{
    char *s = "1233345hello";
    char *sub = "1345";
    printf("%d\n", mystrcmp(s, sub));

    return 0;
}

memmove

void memmove(void dest, const void* src, size_t count);
功能: 从src拷贝count个字符到dest, 如果目标区域和源区域有重叠的话，memmove能够保证源串在被覆盖之前将重叠区域的字节拷贝到目标区域中
参数：dest,source分别为目标串和源串的首地址
count为要移动的字符的个数
返回值：返回指向dest的void *指针
用法
char *p=“hello world!”;
char q=(char)malloc(sizeof(char)*strlen§);
memmove(q,p,sizeof§+1);

void *memmove(void* dest, const void* src, size_t count)
{
    char *d = dest;
    const char *s = src;

    //当源内存的首地址大于目标内存的首地址时,实行正向拷贝. d >= s+count时正向反向拷贝都可以
    if(d <= s || d >= s+count){
        while(count--)
            *d++ = *s++;
    }
   else{
        d = (char *)dest + count-1;
        s = (char *)src + count-1;
        while(count--)
            *d-- = *s--;
    }
    return dest;
}

int main(void)
{
    char str[]="Golden Global View";
    memmove(str,str+7,strlen(str)-7);//+1是取'\0',可以去掉看下结果  
    printf("%s\n",str);

    return 0;
}

offsetof

size_t offsetof( structName, memberName);
  功能：该宏 用于求一个成员在该结构体中的偏移量
  参数：structName：结构体的名字
       memberName：结构体成员的名字
返回值：structName中成员memberName的偏移量(size_t类型)

用法：
#define offsetof(type, member) ((size_t) &((type*)0)->member)

container_of(ptr, type, member) ({                      \
const typeof( ((type *)0)->member ) *__mptr = (ptr);    \     //typeof获取member的类型
(type *)( (char *)__mptr - offsetof(type,member) );})

功能：根据结构体变量中的一个成员变量的指针来获取整个结构体变量的指针

读文件的一行

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

ssize_t read_line(int fd, void *buf, size_t count)
{
    int i, n;
    char *p;

    p = (char *)buf;
    for(i = 0; i < count; i++){
        n = read(fd, p, sizeof(char));
        if(n == -1)
            return -1;
        else if(n == 0)
            break;
        else{
            if(*p == '\n')
                break;
            else
                p++;
        }
    }
    if(i > 0) i++;
    
    return i;
}

void err_sys(const char *str){
    perror(str);
    exit(1);
}

int main(void)
{
    int fd;
    char buf[1024];
    FILE *fp;
#ifdef TEST
    fd = open("test.txt", O_RDONLY);
    if(fd == -1)
        err_sys("open error");
    while(read_line(fd, buf, 1024));
    close(fd);
#else
    fp = fopen("test.txt", "r");
    if(fp == NULL)
        err_sys("fopen error");
    while(fgets(buf, 1024, fp));
    fclose(fp);
#endif
    return 0;
}

//chinese string
#include <stdio.h>
#include <wchar.h>
#include <locale.h>
    
int main()  
{  
    setlocale(LC_ALL, "");
    wchar_t test[] = L"中国CHINA";
    
    printf("%ls\n", test);  
  
    return 0;  
}

//reverse string
#include <stdio.h>
#include <string.h>

#define swap(t, x, y) { t tmp; tmp=x; x=y; y=tmp; }

void reverse(char s[], int l, int r)
{
    if (l>=r) 
        return;
    swap(char, s[l], s[r]);
    reverse(s, ++l, --r);//礩归算法
}

int main()
{
    char s[] = "abcdefg";
    reverse(s, 0, strlen(s)-1);
    printf("%s\n", s);

    return 0;
}