c/c++开发分享structc开源框架介绍

{      "configurations": [          {              "name": "linux",              "includepath": [                  "/usr/include/c++/7",                  "/usr/include/x86_64-linux-gnu/c++/7",                  "/usr/include/c++/7/backward",                  "/usr/lib/gcc/x86_64-linux-gnu/7/include",                  "/usr/local/include",                  "/usr/lib/gcc/x86_64-linux-gnu/7/include-fixed",                  "/usr/include/x86_64-linux-gnu",                  "/usr/include",                  "${workspaceroot}",                  "${workspaceroot}/structc/base",                  "${workspaceroot}/structc/struct",                  "${workspaceroot}/structc/system"              ],              "defines": [                  "_debug",                  "__gnuc__"              ],              "intellisensemode": "clang-x64",              "browse": {                  "path": [                      "/usr/include/c++/7",                      "/usr/include/x86_64-linux-gnu/c++/7",                      "/usr/include/c++/7/backward",                      "/usr/lib/gcc/x86_64-linux-gnu/7/include",                      "/usr/local/include",                      "/usr/lib/gcc/x86_64-linux-gnu/7/include-fixed",                      "/usr/include/x86_64-linux-gnu",                      "/usr/include",                      "${workspaceroot}"                  ],                  "limitsymbolstoincludedheaders": true,                  "databasefilename": ""              },              "compilerpath": "/usr/bin/clang",              "cstandard": "c11",              "cppstandard": "c++17"          }      ],      "version": 4  }

{      // 使用 intellisense 了解相关属性。       // 悬停以查看现有属性的描述。      // 欲了解更多信息，请访问: https://go.microsoft.com/fwlink/?linkid=830387      "version": "0.2.0",      "configurations": [          {              "name": "(gdb) launch",              "type": "cppdbg",              "request": "launch",              "program": "${workspacefolder}/out/main.exe",              "args": [],              "stopatentry": false,              "cwd": "${workspacefolder}",              "environment": [],              "externalconsole": true,              "prelaunchtask": "debug",              "mimode": "gdb",              "setupcommands": [                  {                      "description": "enable pretty-printing for gdb",                      "text": "-enable-pretty-printing",                      "ignorefailures": true                  }              ]          }      ]  }

4. f5 -> tasks.json

{      // see https://go.microsoft.com/fwlink/?linkid=733558      // for the documentation about the tasks.json format      "version": "2.0.0",      "tasks": [          {              "type"    : "shell",              "label"   : "debug",              "command" : "make d=-d_debug"          }      ]  }

wzhi@wzc:~/structc/structc$ tree -l 1  .  ├── base  ├── conf  ├── main  ├── readme.md  ├── struct  ├── structc.vcxproj  ├── structc.vcxproj.filters  ├── structc.vcxproj.user  ├── system  └── test

wzhi@wzc:~/structc/structc/main$ tree  .  ├── main.c  ├── main_init.c  ├── main_run.c  └── main_test.c

#include "head.h"    //  // main - 程序的总入口, 从扯开始  // argc     : 输入参数个数  // argv     : 参数集  // return   : 返回程序退出的状态码  //  int main(int argc, char * argv[]) {      //      // 初始化 ... ...      // ... ...      extern_run(main_init);        //      // make d=-d_debug      // main_test 单元测试才会启动      //  #ifdef _debug      extern_run(main_test);  #endif        // ...       // ... 启动当前项目运行的主函数      //      extern_run(main_run, argc, argv);        return exit_success;  }

//  // extern_run - 简单的声明, 并立即使用的宏  // ftest    : 需要执行的函数名称  // ...      : 可变参数, 保留  //  #define extern_run(ftest, ...)                                    do {                                                                  extern void ftest();                                              ftest (__va_args__);                                          } while(0)

#include "head.h"    //  // test - 用于单元测试函数, 执行并输出运行时间  // ftest    : 需要执行的测试函数名称  // ...      : 可变参数, 保留  //  #define test(ftest, ...)                                           do {                                                                   extern void ftest();                                               clock_t $s = clock();                                              ftest (##__va_args__);                                             double $e = (double)clock();                                       printf(str(ftest)" run time:%lfsn", ($e-$s)/clocks_per_sec);  } while(0)      //  // main_test - *_test is here run  // return   : void  //  void main_test(void) {      //      // 开始你的表演, 单元测试      //        extern_run(uv_tty_test);  }

#include   #include   #include   #include     //  // 测试 libuv tty 操作控制台  // 输出一段有颜色的文字  //  void uv_tty_test(void) {      uv_tty_t tty;      uv_buf_t buf[3];      unsigned i, len = sizeof buf / sizeof *buf;      uv_loop_t * loop = uv_default_loop();        // 目前只对 tty 控制台处理      if (uv_guess_handle(1) != uv_tty) {          fprintf(stderr, "uv_guess_handle(1) != uv_tty!n");          exit(exit_failure);      }        uv_tty_init(loop, &tty, 1, 0);      uv_tty_set_mode(&tty, uv_tty_mode_normal);        // 开始发送消息      buf[0].base = "33[46;37m";      buf[1].base = u8"(✿◡‿◡) 喵酱 ((●'-'●)) 比 ♥ 里~ n";      buf[2].base = "33[0m";      for (i = 0; i 

#ifndef _h_socket  #define _h_socket    #include   #include   #include "struct.h"  #include   #include     #ifdef __gnuc__    #include   #include   #include   #include   #include   #include   #include   #include   #include     //  // this is used instead of -1, since the. by winsock  // on now linux eagain and ewouldblock may be the same value   // connect 链接中, linux 是 einprogress，winds 是 wsaewouldblock  //  typedef int socket_t;    #define invalid_socket          (~0)  #define socket_error            (-1)    // socket_init - 初始化 socket 库初始化方法  inline void socket_init(void) {      // 管道破裂, 忽略 sigpipe 信号      signal(sigpipe, sig_ign);  }    inline int socket_close(socket_t s) {      return close(s);  }    // socket_set_block     - 设置套接字是阻塞  // socket_set_nonblock  - 设置套接字是非阻塞  inline int socket_set_block(socket_t s) {      int mode = fcntl(s, f_getfl, 0);      return fcntl(s, f_setfl, mode & ~o_nonblock);  }    inline int socket_set_nonblock(socket_t s) {      int mode = fcntl(s, f_getfl, 0);      return fcntl(s, f_setfl, mode | o_nonblock);  }    // socket_recv      - 读取数据  // socket_send      - 写入数据  inline int socket_recv(socket_t s, void * buf, int sz) {      return (int)read(s, buf, sz);  }    inline int socket_send(socket_t s, const void * buf, int sz) {      return (int)write(s, buf, sz);  }    #endif    #ifdef _msc_ver    #include     #undef  errno  #define errno                   wsagetlasterror()  #undef  strerror  #define strerror                ((char * (*)(int))strerr)    #undef  eintr  #define eintr                   wsaeintr  #undef  eagain  #define eagain                  wsaewouldblock  #undef  einprogress  #define einprogress             wsaewouldblock    /*   * winsock 2 extension -- manifest constants for shutdown()   */  #define shut_rd                 sd_receive  #define shut_wr                 sd_send  #define shut_rdwr               sd_both    #define so_reuseport            so_reuseaddr    typedef socket socket_t;  typedef int socklen_t;    //  // gettimeofday - linux sys/time.h 中得到微秒时间实现  // tv       : 返回结果包含秒数和微秒数  // tz       : 包含的时区, winds 上这个变量没有作用  // return   : 默认返回 0  //  extern int gettimeofday(struct timeval * tv, void * tz);    //  // strerr - linux 上替代 strerror, winds 替代 formatmessage   // error    : linux 是 errno, winds 可以是 wsagetlasterror() ...   // return   : system os 拔下来的提示常量字符串  //  extern const char * strerr(int err);    // socket_init - 初始化 socket 库初始化方法  inline void socket_init(void) {      wsadata wsad;      wsastartup(winsock_version, &wsad);  }    // socket_close     - 关闭上面创建后的句柄  inline int socket_close(socket_t s) {      return closesocket(s);  }    // socket_set_block     - 设置套接字是阻塞  // socket_set_nonblock  - 设置套接字是非阻塞  inline int socket_set_block(socket_t s) {      u_long mode = 0;      return ioctlsocket(s, fionbio, &mode);  }    inline int socket_set_nonblock(socket_t s) {      u_long mode = 1;      return ioctlsocket(s, fionbio, &mode);  }    // socket_recv      - 读取数据  // socket_send      - 写入数据  inline int socket_recv(socket_t s, void * buf, int sz) {      return sz > 0 ? recv(s, buf, sz, 0) : 0;  }    inline int socket_send(socket_t s, const void * buf, int sz) {      return send(s, buf, sz, 0);  }    #endif    //  // 通用 sockaddr_in ipv4 地址  //  typedef struct sockaddr_in sockaddr_t[1];    // socket_dgram     - 创建 udp socket  // socket_stream    - 创建 tcp socket  inline socket_t socket_dgram(void) {      return socket(pf_inet, sock_dgram, ipproto_udp);  }    inline socket_t socket_stream(void) {      return socket(pf_inet, sock_stream, ipproto_tcp);  }    // socket_set_reuse - 开启端口和地址复用  // socket_set_keepalive - 开启心跳包检测, 默认2h 5次  inline int socket_set_enable(socket_t s, int optname) {      int ov = 1;      return setsockopt(s, sol_socket, optname, (void *)&ov, sizeof ov);  }    inline int socket_set_reuse(socket_t s) {      return socket_set_enable(s, so_reuseport);  }    inline int socket_set_keepalive(socket_t s) {      return socket_set_enable(s, so_keepalive);  }    // socket_set_rcvtimeo - 设置接收数据毫秒超时时间  // socket_set_sndtimeo - 设置发送数据毫秒超时时间  inline int socket_set_time(socket_t s, int ms, int optname) {      struct timeval ov = { 0,0 };      if (ms > 0) {          ov.tv_sec = ms / 1000;          ov.tv_usec = (ms % 1000) * 1000;      }      return setsockopt(s, sol_socket, optname, (void *)&ov, sizeof ov);  }    inline int socket_set_rcvtimeo(socket_t s, int ms) {      return socket_set_time(s, ms, so_rcvtimeo);  }    inline int socket_set_sndtimeo(socket_t s, int ms) {      return socket_set_time(s, ms, so_sndtimeo);  }    // socket_get_error - 得到当前socket error 值, 0 表示正确, 其它都是错误  inline int socket_get_error(socket_t s) {      int err;      socklen_t len = sizeof(err);      int r = getsockopt(s, sol_socket, so_error, (void *)&err, &len);      return r <0 ? errno : err;  }    // socket_recvfrom  - recvfrom 接受函数  // socket_sendto    - sendto 发送函数  inline int socket_recvfrom(socket_t s, void * buf, int len, int flags, sockaddr_t in) {      socklen_t inlen = sizeof (sockaddr_t);      return recvfrom(s, buf, len, flags, (struct sockaddr *)in, &inlen);  }    inline int socket_sendto(socket_t s, const void * buf, int len, int flags, const sockaddr_t to) {      return sendto(s, buf, len, flags, (const struct sockaddr *)to, sizeof(sockaddr_t));  }    //  // socket_recvn     - socket 接受 sz 个字节  // socket_sendn     - socket 发送 sz 个字节  //  extern int socket_recvn(socket_t s, void * buf, int sz);  extern int socket_sendn(socket_t s, const void * buf, int sz);    // socket_bind          - bind    绑定函数  // socket_listen        - listen  监听函数  // socket_accept        - accept  等接函数  // socket_connect       - connect 链接函数  inline int socket_bind(socket_t s, const sockaddr_t addr) {      return bind(s, (const struct sockaddr *)addr, sizeof(sockaddr_t));  }    inline int socket_listen(socket_t s) {      return listen(s, somaxconn);  }    inline socket_t socket_accept(socket_t s, sockaddr_t addr) {      socklen_t len = sizeof (sockaddr_t);      return accept(s, (struct sockaddr *)addr, &len);  }    inline int socket_connect(socket_t s, const sockaddr_t addr) {      return connect(s, (const struct sockaddr *)addr, sizeof(sockaddr_t));  }    //  // socket_binds     - 端口绑定返回绑定好的 socket fd, 返回 invalid_socket or pf_inet pf_inet6  // socket_listens   - 端口监听返回监听好的 socket fd.  //  extern socket_t socket_binds(const char * ip, uint16_t port, uint8_t protocol, int * family);  extern socket_t socket_listens(const char * ip, uint16_t port, int backlog);      //  // socket_addr -socket_recv 通过 ip, port 构造 ipv4 结构  //  extern int socket_addr(const char * ip, uint16_t port, sockaddr_t addr);    // socket_pton - 返回 ip 串  inline char * socket_pton(sockaddr_t addr, char ip[inet_addrstrlen]) {      return (char *)inet_ntop(af_inet, &addr->sin_addr, ip, inet_addrstrlen);  }    //  // socket_host - 通过 ip:port 串得到 socket addr 结构  // host     : ip:port 串  // addr     : 返回最终生成的地址  // return   : >= ebase 表示成功  //  extern int socket_host(const char * host, sockaddr_t addr);    //  // socket_tcp - 创建 tcp 详细套接字  // host     : ip:port 串    // return   : 返回监听后套接字  //  extern socket_t socket_tcp(const char * host);    //  // socket_udp - 创建 udp 详细套接字  // host     : ip:port 串    // return   : 返回绑定后套接字  //  extern socket_t socket_udp(const char * host);    //  // socket_connects - 返回链接后的阻塞套接字  // host     : ip:port 串    // return   : 返回链接后阻塞套接字  //  extern socket_t socket_connects(const char * host);    //  // socket_connectos - 返回链接后的非阻塞套接字  // host     : ip:port 串    // ms       : 链接过程中毫秒数  // return   : 返回链接后非阻塞套接字  //  extern socket_t socket_connectos(const char * host, int ms);    #endif//_h_socket

#include "socket.h"    #ifdef _msc_ver    //  // gettimeofday - linux sys/time.h 中得到微秒时间实现  // tv       : 返回结果包含秒数和微秒数  // tz       : 包含的时区, winds 上这个变量没有作用  // return   : 默认返回 0  //  int   gettimeofday(struct timeval * tv, void * tz) {      struct tm m;      systemtime se;        getlocaltime(&se);      m.tm_year = se.wyear - 1900;      m.tm_mon = se.wmonth - 1;      m.tm_mday = se.wday;      m.tm_hour = se.whour;      m.tm_min = se.wminute;      m.tm_sec = se.wsecond;      m.tm_isdst = -1; // 不考虑夏令时        tv->tv_sec = (long)mktime(&m);      tv->tv_usec = se.wmilliseconds * 1000;        return 0;  }    #endif    //  // socket_recvn     - socket 接受 sz 个字节  // socket_sendn     - socket 发送 sz 个字节  //    int   socket_recvn(socket_t s, void * buf, int sz) {      int r, n = sz;      while (n > 0) {          r = recv(s, buf, n, 0);          if (r == 0) break;          if (r == socket_error) {              if (errno == eintr)                  continue;              return socket_error;          }          n -= r;          buf = (char *)buf + r;      }      return sz - n;  }    int   socket_sendn(socket_t s, const void * buf, int sz) {      int r, n = sz;      while (n > 0) {          r = send(s, buf, n, 0);          if (r == 0) break;          if (r == socket_error) {              if (errno == eintr)                  continue;              return socket_error;          }          n -= r;          buf = (char *)buf + r;      }      return sz - n;  }    //  // socket_addr - 通过 ip, port 构造 ipv4 结构  //  int   socket_addr(const char * ip, uint16_t port, sockaddr_t addr) {      addr->sin_family = af_inet;      addr->sin_port = htons(port);      addr->sin_addr.s_addr = inet_addr(ip);      if (addr->sin_addr.s_addr == inaddr_none) {          struct hostent * host = gethostbyname(ip);          if (!host || !host->h_addr)              return eparam;            // 尝试一种, 默认 ipv4          memcpy(&addr->sin_addr, host->h_addr, host->h_length);      }      memset(addr->sin_zero, 0, sizeof addr->sin_zero);        return sbase;  }    //  // socket_binds     - 端口绑定返回绑定好的 socket fd, 返回 invalid_socket or pf_inet pf_inet6  // socket_listens   - 端口监听返回监听好的 socket fd.  //  socket_t   socket_binds(const char * ip, uint16_t port, uint8_t protocol, int * family) {      socket_t fd;      char ports[sizeof "65535"];      struct addrinfo * addr = null, hint = { 0 };      if (null == ip || *ip == '')          ip = "0.0.0.0"; // default inaddr_any        sprintf(ports, "%hu", port);      hint.ai_family = af_unspec;      if (protocol == ipproto_tcp)          hint.ai_socktype = sock_stream;      else {          assert(protocol == ipproto_udp);          hint.ai_socktype = sock_dgram;      }      hint.ai_protocol = protocol;        if (getaddrinfo(ip, ports, &hint, &addr))          return invalid_socket;        fd = socket(addr->ai_family, addr->ai_socktype, 0);      if (fd == invalid_socket)          goto err_free;      if (socket_set_reuse(fd))          goto err_close;      if (bind(fd, addr->ai_addr, (int)addr->ai_addrlen))          goto err_close;        // success return ip family      if (family)          *family = addr->ai_family;      freeaddrinfo(addr);      return fd;    err_close:      socket_close(fd);  err_free:      freeaddrinfo(addr);      return invalid_socket;  }    socket_t   socket_listens(const char * ip, uint16_t port, int backlog) {      socket_t fd = socket_binds(ip, port, ipproto_tcp, null);      if (invalid_socket != fd && listen(fd, backlog)) {          socket_close(fd);          return invalid_socket;      }      return fd;  }    // host_parse - 解析 host 内容  static int host_parse(const char * host, char ip[bufsiz], uint16_t * pprt) {      int port = 0;      char * st = ip;      if (!host || !*host || *host == ':')          strcpy(ip, "0.0.0.0");      else {          char c;          // 简单检查字符串是否合法          size_t n = strlen(host);          if (n >= bufsiz)              return(eparam, "host err %s", host);            // 寻找分号          while ((c = *host++) != ':' && c)              *ip++ = c;          *ip = '';          if (c == ':') {              if (n > ip - st + sizeof "65535")                  return(eparam, "host port err %s", host);              port = atoi(host);              // 有些常识数字, 不一定是魔法 ... :)              if (port <= 1024 || port > 65535)                  return(eparam, "host port err %s, %d", host, port);          }      }        *pprt = port;      return sbase;  }    //  // socket_host - 通过 ip:port 串得到 socket addr 结构  // host     : ip:port 串  // addr     : 返回最终生成的地址  // return   : >= ebase 表示成功  //  int   socket_host(const char * host, sockaddr_t addr) {      uint16_t port; char ip[bufsiz];      if (host_parse(host, ip, &port) = sbase)          if (socket_connect(s, addr) >= sbase)              return s;        socket_close(s);      return(invalid_socket, "socket_connects %s", host);  }    //  // socket_connecto      - connect 超时链接, 返回非阻塞 socket  //  static int socket_connecto(socket_t s, const sockaddr_t addr, int ms) {      int n, r;      struct timeval to;      fd_set rset, wset, eset;        // 还是阻塞的connect      if (ms <0) return socket_connect(s, addr);        // 非阻塞登录, 先设置非阻塞模式      r = socket_set_nonblock(s);      if (r = sbase || errno != einprogress) {          socket_set_block(s);          return r;      }        // 超时 timeout, 直接返回结果 ebase = -1 错误      if (ms == 0) {          socket_set_block(s);          return ebase;      }        fd_zero(&rset); fd_set(s, &rset);      fd_zero(&wset); fd_set(s, &wset);      fd_zero(&eset); fd_set(s, &eset);      to.tv_sec = ms / 1000;      to.tv_usec = (ms % 1000) * 1000;      n = select((int)s + 1, &rset, &wset, &eset, &to);      // 超时直接滚      if (n <= 0) {          socket_set_block(s);          return ebase;      }        // 当连接成功时候,描述符会变成可写      if (n == 1 && fd_isset(s, &wset)){          socket_set_block(s);          return sbase;      }        // 当连接建立遇到错误时候, 描述符变为即可读又可写      if (fd_isset(s, &eset) || n == 2) {          socklen_t len = sizeof n;          // 只要最后没有 error 那就 链接成功          if (!getsockopt(s, sol_socket, so_error, (char *)&n, &len) && !n)              r = sbase;      }      socket_set_block(s);      return r;  }    //  // socket_connectos - 返回链接后的非阻塞套接字  // host     : ip:port 串    // ms       : 链接过程中毫秒数  // return   : 返回链接后非阻塞套接字  //  socket_t   socket_connectos(const char * host, int ms) {      sockaddr_t addr;      socket_t s = socket_stream();      if (invalid_socket == s) {          return(s, "socket_stream is error");      }        // 解析配置成功后尝试链接      if (socket_host(host, addr) >= sbase)          if (socket_connecto(s, addr, ms) >= sbase)              return s;        socket_close(s);      return(invalid_socket, "socket_connectos %s", host);  }

#ifndef _h_atom  #define _h_atom    #include "atomic.h"    //  // atom_t 自旋锁类型  // [static] atom_t o = 0;  //   atom_lock(o);  //  - one man rpg  // atom_unlock(o);  //  typedef volatile long atom_t;    // atom_acquire - 维护优化后读写代码不在其前  #define atom_acquire()      atomic_fence(atomic_acquire)  // atom_release - 维护优化后读写代码不在其后  #define atom_release()      atomic_fence(atomic_release)  // atom_seq_cst - 维护优化后读写代码前后不动  #define atom_seq_cst()      atomic_fence(atomic_seq_cst)    #ifdef __gnuc__    #define atom_trylock(o)     (!__sync_lock_test_and_set(&(o), 1))    #define atom_lock(o)        while(__sync_lock_test_and_set(&(o), 1))    #define atom_unlock(o)      __sync_lock_release(&(o))    // 内存屏障, 维持代码顺序  #define atom_sync()         __sync_synchronize()    // v += a ; return v;  #define atom_add(v, a)      __sync_add_and_fetch(&(v), (a))  // type tmp = v ; v = a; return tmp;  #define atom_set(v, a)      __sync_lock_test_and_set(&(v), (a))  // v &= a; return v;  #define atom_and(v, a)      __sync_and_and_fetch(&(v), (a))  // return ++v;  #define atom_inc(v)         __sync_add_and_fetch(&(v), 1)  // return --v;  #define atom_dec(v)         __sync_sub_and_fetch(&(v), 1)  // bool b = v == c; b ? v=a : ; return b;  #define atom_cas(v, c, a)   __sync_bool_compare_and_swap(&(v), (c), (a))    #endif    #ifdef _msc_ver    #include   #include     /* interlocked intrinsic mapping for _nf/_acq/_rel */  #if defined(_m_arm) || defined(_m_arm64)  #define _acquire(x) atomic_concat(x, _acq)  #else /* defined(_m_arm) || defined(_m_arm64) */  #define _acquire(x) x  #endif /* defined(_m_arm) || defined(_m_arm64) */    #define atom_trylock(o)     (!_acquire(_interlockedbittestandset)(&(o), 0))    #define atom_lock(o)        while(_acquire(_interlockedbittestandset)(&(o), 0))    inline void store_release(atom_t * x) {      /* store _value atomically with release memory order */  #if defined(_m_arm) || defined(_m_arm64)      __dmb(0xb /* _arm_barrier_ish or _arm64_barrier_ish*/);      __iso_volatile_store32((volatile int *)x, 0);  #else      _readwritebarrier();      *x = 0;  #endif  }    #define atom_unlock(o)      store_release(&(o))    // 保证代码优化后不乱序执行  #define atom_sync()         memorybarrier()    // v 和 a 都是 long 这样数据  #define atom_add(v, a)      interlockedadd((volatile long *)&(v), (long)(a))  #define atom_set(v, a)      interlockedexchange((volatile long *)&(v), (long)(a))  #define atom_and(v, a)      interlockedand((volatile long *)&(v), (long)(a))  #define atom_inc(v)         interlockedincrement((volatile long *)&(v))  #define atom_dec(v)         interlockeddecrement((volatile long *)&(v))  //  // 对于 interlockedcompareexchange(v, c, a) 等价于下面  // long tmp = v ; v == a ? v = c : ; return tmp;  //  // 咱们的 atom_cas(v, c, a) 等价于下面  // long tmp = v ; v == c ? v = a : ; return tmp;  //  #define atom_cas(v, c, a)   ((long)(c) == interlockedcompareexchange((volatile long *)&(v), (long)(a), (long)(c)))    #endif    #endif//_h_atom