C 언어 로 구현 되 는 String 라 이브 러 리

char arr[] = "hello world!";

/**
 * struct xstring - string metadata
 * @str: pointer to buf
 * @len: current length of buf contents
 * @cap: maximum capacity of buf
 * @truncated: -1 indicates truncation
 */
typedef struct xstring {
    char *str;
    size_t len;
    size_t cap;
    int truncated;
} xstring;

xstring *xstrNew(const size_t size)
{
    char *str;
    xstring *x;

    if (size < 1) {
        errno = EINVAL;
        return NULL;
    }

    str = malloc(size);//mark 1
    if (!str)
        return NULL;

    x = malloc(sizeof(struct xstring));//mark 2
    if (!x) {
        free(str);
        return NULL;
    }

    xstrInit(x, str, size, 0);
    return x;
}

struct xstring* newStruct(){
    struct xstring s;
    return &s;
}

// sds   
typedef char *sds;

// sdshdr   
struct sdshdr {

    // buf      
    int len;

    // buf       
    int free;

    //             
    //   c99(C99 specification 6.7.2.1.16)     flexible array member,  buf   sdshdr     ，
    //   google "flexible array member"
    char buf[];
};

char buf[];

struct header {
  size_t len;
  unsigned char data[1];
};

//        ，           ，   (n-1)    
//            
// | struct (char) | （n - 1） char |
ptr = malloc(sizeof(struct header) + (n-1));

  /*
   *    sds buf       
   */
  static inline size_t sdslen(const sds s) {
      struct sdshdr *sh = (void*)(s-(sizeof(struct sdshdr)));
      return sh->len;
  }
  
  /*
   *    sds buf      
   */
  static inline size_t sdsavail(const sds s) {
      struct sdshdr *sh = (void*)(s-(sizeof(struct sdshdr)));
      return sh->free;
  }
  
  /*
   *           sds 
   *           init   ，    init     sds   buf   
   *
   * T = O(N)
   */
  sds sdsnewlen(const void *init, size_t initlen) {
  
      struct sdshdr *sh;
  
      //   init ？
      // O(N)
      if (init) {
          sh = zmalloc(sizeof(struct sdshdr)+initlen+1);
      } else {
          sh = zcalloc(sizeof(struct sdshdr)+initlen+1);
      }
  
      //     ，    
      if (sh == NULL) return NULL;
  
      sh->len = initlen;
      sh->free = 0;
  
      //       init   initlen    0   
      //     init        sds buf
      // O(N)
      if (initlen && init)
          memcpy(sh->buf, init, initlen);
  
      //      
      sh->buf[initlen] = '\0';
  
      //    buf       sdshdr
      return (char*)sh->buf;
  }
  

struct sdshdr *sh = (void*)(s-(sizeof(struct sdshdr)));

#include 
#include "./src/simple_dynamic_str.h"

int main() {

    sds s = sdsnew("Hello World! K&R");
    printf("%s
", s);
    printf("%zu %zu
", sdslen(s), sdsavail(s));

    printf("%c",s[0]);

    return 0;
}

  :
Hello World! K&R
16 0
H

/* Note: sdshdr5 is never used, we just access the flags byte directly.
 * However is here to document the layout of type 5 SDS strings. */
struct __attribute__ ((__packed__)) sdshdr5 {
    unsigned char flags; /* 3 lsb of type, and 5 msb of string length */
    char buf[];
};
struct __attribute__ ((__packed__)) sdshdr8 {
    uint8_t len; /* used */
    uint8_t alloc; /* excluding the header and null terminator */
    unsigned char flags; /* 3 lsb of type, 5 unused bits */
    char buf[];
};
struct __attribute__ ((__packed__)) sdshdr16 {
    uint16_t len; /* used */
    uint16_t alloc; /* excluding the header and null terminator */
    unsigned char flags; /* 3 lsb of type, 5 unused bits */
    char buf[];
};
struct __attribute__ ((__packed__)) sdshdr32 {
    uint32_t len; /* used */
    uint32_t alloc; /* excluding the header and null terminator */
    unsigned char flags; /* 3 lsb of type, 5 unused bits */
    char buf[];
};
struct __attribute__ ((__packed__)) sdshdr64 {
    uint64_t len; /* used */
    uint64_t alloc; /* excluding the header and null terminator */
    unsigned char flags; /* 3 lsb of type, 5 unused bits */
    char buf[];
};