夏天匆匆2过

C/C++常用方法

- C/C++开发常用github开源项目
- C++表示二进制，八进制，十进制和十六进制
- 两个结构体一起new
- 函数传指针和指针引用
- 1字节对齐
- 四字节转int
- C++十六进制字符串转换为十进制
- 模拟main函数传参
- 模拟main函数传参2
- va_list可变参数列表
- fork()多进程
- 指针类型占多少字节
- 指针一维数组和二维数组的分配与释放
- 负数的二进制表示法
- C++位运算
- 打印当前系统时间
- 睡眠sleep
- C++生成随机数
- C++取模均匀分配下标
- fprintf()中的stdout、stderr
- 打印进程ID和线程ID
- char*与string相互转换
- 字符串和数字相互转换
- 获取可执行文件绝对路径
- int、short、long、long long、 unsigned int、unsigned short、unsigned long、unsigned long long字节数，取值范围，打印方式
- 纯C语言tcp客户端
- 纯C语言tcp服务端

C/C++开发常用github开源项目

C++流媒体服务器SRS
https://github.com/ossrs

C++流媒体服务器ZLM
https://github.com/ZLMediaKit/ZLMediaKit

C/C++/QT音视频客户端
https://github.com/metartc/metaRTC

SocketIO
https://github.com/socketio/socket.io-client-cpp

C++操作JSON库：jsoncpp和picojson
https://github.com/open-source-parsers/jsoncpp/tree/master/src/jsontestrunner
https://github.com/kazuho/picojson/tree/master

云风写的C语言协程库
https://github.com/cloudwu/coroutine

京东青龙
https://github.com/6dylan6/jdpro

C++连接redis数据库
https://github.com/redis/hiredis
https://github.com/sewenew/redis-plus-plus

C语言实现traceroute功能
https://github.com/bgylde/traceroute.git

C语言实现ping
https://github.com/coding-fans/linux-network-programming/blob/master/src/c/icmp/ping/ping.c

C语言实现netstat命令功能
https://github.com/LipiLee/netstat/blob/master/netstat.c

C++表示二进制，八进制，十进制和十六进制

十进制，必须以非零数字开头。
八进制，任何以 0 开头的数字(包括普通 0)。
二进制，需要前缀 0b 或 0B。
十六进制，需要前缀 0x 或 0X。
demo：

int aa = 1001;//十进制
printf("aa=%d\n",aa);
    
int bb = 0b1001;//二进制
printf("bb=%d\n",bb);

int cc = 040;//八进制
printf("cc=%d\n",cc);

int dd = 0x20;//十六进制
printf("dd=%d\n",dd);

打印

aa=1001
bb=9
cc=32
dd=32

两个结构体一起new

两个结构体分配的空间是连续的，可以共用一个起始地址指针pBuff 。

struct HeadDef{
    int      MsgType;
    int      TotalLen;
    uint8_t     pData[0];	//地址指针标识，不占用空间
};

struct MsgDef{
    char        name[64];
    int         age;
};

    void *pBuff = new char(sizeof(HeadDef) + sizeof(MsgDef));
    HeadDef *pMsg = (HeadDef*)pBuff;
    pMsg->MsgType = 102;
    pMsg->TotalLen = sizeof(HeadDef) + sizeof(MsgDef);

    MsgDef *pMsg_body = (MsgDef*)pMsg->pData;
    pMsg_body->age = 20;
    std::string strname = "chw";
    memcpy(pMsg_body->name,strname.c_str(),strname.size());

    printf("pMsg->MsgType=%d\n",pMsg->MsgType);
    printf("pMsg->TotalLen=%d\n",pMsg->TotalLen);
    printf("pMsg_body->age=%d\n",pMsg_body->age);
    printf("pMsg_body->name=%s\n",pMsg_body->name);

打印：

pMsg->MsgType=102
pMsg->TotalLen=76
pMsg_body->age=20
pMsg_body->name=chw

函数传指针和指针引用

//传指针
//传的指针是行参，pNum指针自己的地址和实参指针地址不同，但指针指向的地址相同，因此可以使用行参改变指向地址的内容
//在这里对行参pNum做赋值操作是不会改变实参的
void testformal(int *pNum)
{
    printf("行参,指针自己的地址:%p\n",&pNum);
    printf("行参,指针指向的地址:%p\n",pNum);
    pNum = nullptr;//不会改变实参
}

//传指针引用
//传的是指针的引用，pNum指针地址、指针指向的地址均和实参一致
//在这里，不但可以改变实参指向地址的值，也可以改变实参本身
void testquote(int *&pNum)
{
    printf("引用,指针自己的地址:%p\n",&pNum);
    printf("引用,指针指向的地址:%p\n",pNum);
    pNum = nullptr;//会改变实参
}

    int *p = new int;
    printf("实参:指针自己的地址:%p\n",&p);
    printf("实参:指针指向的地址:%p\n",p);
    testformal(p);
    printf("%s\n",p == nullptr ? "p == nullptr" : "p != nullptr");
    testquote(p);
    printf("%s\n",p == nullptr ? "p == nullptr" : "p != nullptr");

打印

实参:指针自己的地址:0x7ffd0fe22f30
实参:指针指向的地址:0x562c56ea1e00
行参,指针自己的地址:0x7ffd0fe22f08
行参,指针指向的地址:0x562c56ea1e00
p != nullptr
引用,指针自己的地址:0x7ffd0fe22f30
引用,指针指向的地址:0x562c56ea1e00
p == nullptr

1字节对齐

当数据用于网络发送时，需要进行字节对齐

#pragma pack(push, 1)
//struct{...}
#pragma pack(pop)

四字节转int

int byte2int(uint8_t *data)
{
    int value = (int)((data[3] & 0xFF)
        | ((data[2] & 0xFF) << 8)
        | ((data[1] & 0xFF) << 16)
        | ((data[0] & 0xFF) << 24));
    return value;
}

调用

    char arr[4];
    arr[0] = 1;
    arr[1] = 1;
    arr[2] = 1;
    arr[3] = 1;

    int num = byte2int((uint8_t *)arr);
    printf("num=%d\n",num);

打印

num=16843009

C++十六进制字符串转换为十进制

    char *str = (char*)"0xff";//不区分大小写，0x可以不写
    int n = strtol(str, NULL, 16);
    printf("%d\n", n);

打印输出：255

模拟main函数传参

void parse_param(int argc, char **argv)
{
    for(int index=0;index<argc;index++)
    {
        printf("the %d param is [%s]\n",index,argv[index]);
    }
}

int argc = 2;
char *argv[2];
argv[0] = (char*)"chw";
argv[1] = (char*)"192.168.1.108";

parse_param(argc, argv);

打印：

the 0 param is [chw]
the 1 param is [192.168.1.108]

模拟main函数传参2

#include 
    int argc = 3;
    char *argv[3];
    argv[0] = (char*)"testPro";
    argv[1] = (char*)"-b";
    argv[2] = (char*)"chw";

    int opt;
    char *c;
    while ((opt = getopt(argc, argv, "b:p")) != EOF)
    {
        switch (opt)
        {
        case 'b':
            c = strdup(optarg);
            printf("b=%s\n",c);
            free(c);
            break;
        }
    }

打印

b=chw

va_list可变参数列表

va_list：一个字符指针，可以理解为指向当前参数的一个指针，取参必须通过这个指针进行。
va_start：对ap进行初始化，让ap指向可变参数表里面的第一个参数。第一个参数是 ap 本身，第二个参数是在变参表前面紧挨着的一个变量，即“…”之前的那个参数；
va_arg: 获取参数。它的第一个参数是ap，第二个参数是要获取的参数的指定类型。按照指定类型获取当前参数，返回这个指定类型的值，然后把 ap 的位置指向变参表中下一个变量的位置；
va_end：释放指针，将输入的参数 ap 置为 NULL。通常va_start和va_end是成对出现。

void test_printf1(char *headData, char *format,...)
{
    char buff[4096];
    va_list args;

    memcpy(buff, headData, strlen(headData));
    va_start(args, format);
    //将格式化数据从可变参数列表写入缓冲区
    vsnprintf(buff+strlen(headData), 1024, format, args);
    va_end(args);

    printf("%s\n", buff);
}

void test_printf2(int num,...)
{
    va_list args;
    va_start(args,num);
    for(int i = 0; i < num; i++)
        printf("%d\n", va_arg(args, int));
    va_end(args);
}

    test_printf1((char *)"data", (char *)"len is %d, data is %s", 10, "helloworld");
    test_printf2(3,100,200,300);

打印

datalen is 10, data is helloworld
100
200
300

fork()多进程

fork是复制进程的函数，通过系统调用创建一个与原来进程几乎完全相同的进程，也就是两个进程可以做完全相同的事，也可以根据传入参数的不同，做不同的事。

pid_t  fork(void);

函数返回值pid_t，就是int型。

在父进程中，返回新建子进程的进程ID；
在子进程中，返回0；
创建失败，返回负值。

多进程特点
1、fork 子进程后，一般情况是子进程先调度。
2、子进程和父进程共享代码段，堆栈数据和全局数据是独立的，进程空间的各段采用了写时复制技术。
3、父子进程之间可通过信号通信，比如退出时会发信号。

测试代码，循环创建10个子进程。

#include 
#include 
int main()
{
    int pid = 0;
    int cnt = 10;
    do
    {
        pid = fork();
        if(pid < 0)
        {
            continue;
        }

        if(pid == 0)
        {
            break;
        }

        if(pid > 0)
        {
            cnt --;
        }
    }
    while(cnt > 0);
    printf("pid=%d,rpid=%d\n",pid,getpid());

    while(1){}
}

打印

pid=0,rpid=3622
pid=3628,rpid=3618
pid=0,rpid=3628
pid=0,rpid=3623
pid=0,rpid=3619
pid=0,rpid=3627
pid=0,rpid=3624
pid=0,rpid=3625
pid=0,rpid=3621
pid=0,rpid=3626
pid=0,rpid=3620

指针类型占多少字节

内存是由字节组成的，每个字节都有一个地址编号。
指针变量主要是存放相同数据类型的变量的首地址，这里的地址就是指内存中某个字节的编号，而这个编号的确定是由地址总线决定的，操作系统的位数决定了指针变量所占的字节数。
如果是32位操作系统，也就是地址总线是32位，则它的寻址范围就是02^32（4GB，所以32位系统最多配4G内存，多了也没有用）,每一个字节的编址就会由32个0或者1组成。
例：第1个字节的编址是32个0，最后1个的编址是32个1。一个字节有8位，32位则需要4个字节。
64 位 CPU 寻址范围则很大，理论最大的寻址空间为 2^64。

不管是什么数据类型：
1、在32位操作系统下，指针是占4个字节空间大小。
2、在64位操作系统下，指针是占8个字节空间大小。

指针一维数组和二维数组的分配与释放

以int型指针为例。

    //1.int型指针
    int *p=new int;
    *p = 12;
    printf("*p=%d\n",*p);
    //释放
    delete p;
    p = nullptr;

    //2.int型一维数组
    int iArrNum = 5;
    int *pArr=new int [iArrNum];//只动态分配空间，未初始化
    memset(pArr,0,iArrNum*sizeof(int));
    for(int index=0;index<iArrNum;index++)
        printf("pArr[%d]=%d\n",index,pArr[index]);
    //释放
    delete []pArr;
    pArr = nullptr;

    //3.int型二维数组
    int row = 3;//行
    int col = 4;//列
    //分配一个指针数组，首地址保存在pInt
    int  **pInt=new int* [row];
    //为指针数组的每个元素分配一个数组
    for(int i=0;i<row;i++)
    {
        pInt[i]=new int [col];
    }
    //遍历
    int n = 0;
    for(int i=0;i<row;i++)
        for(int j=0;j<col;j++)
            pInt[i][j] = n++;
    for(int i=0;i<row;i++)
        for(int j=0;j<col;j++)
             printf("pInt[%d][%d]=%d\n",i,j,pInt[i][j]);
    //释放
    for(int i=0;i<row;i++)
    {
        delete []pInt[i];
    }
    delete []pInt;

打印

*p=12
pArr[0]=0
pArr[1]=0
pArr[2]=0
pArr[3]=0
pArr[4]=0
pInt[0][0]=0
pInt[0][1]=1
pInt[0][2]=2
pInt[0][3]=3
pInt[1][0]=4
pInt[1][1]=5
pInt[1][2]=6
pInt[1][3]=7
pInt[2][0]=8
pInt[2][1]=9
pInt[2][2]=10
pInt[2][3]=11

负数的二进制表示法

正数的表示法，先转换成二进制，在前面补0。
例如5的表示法：
00000000 00000000 00000000 00000101

在计算机中，负数以原码的补码形式表达
1、原码
用符号位和数值表示带符号数，正数的符号位用“0”表示，负数的符号位用“1”表示，数值部分用二进制形式表示。
例如

00000000 00000000 00000000 00000101 是 5的原码。
10000000 00000000 00000000 00000101 是-5的原码。

2、反码
正数的反码与原码相同，负数的反码为对该数的原码除符号位外各位取反。
例如

正数00000000 00000000 00000000 00000101 的反码还是 00000000 00000000 00000000 00000101
负数10000000 00000000 00000000 00000101 的反码则是 11111111 11111111 11111111 11111010。

3、补码
正数的补码与原码相同，负数的补码为对该数的原码除符号位外各位取反，然后在最后一位加1。
例如

10000000 00000000 00000000 00000101 的反码是：11111111 11111111 11111111 11111010
补码为：
11111111 11111111 11111111 11111010 + 1 = 11111111 11111111 11111111 11111011
-5 在计算机中表达为：11111111 11111111 11111111 11111011。转换为十六进制：0xFFFFFFFB。

举例，int类型-1在计算机中表示法：

-1的原码：10000000 00000000 00000000 00000001
得反码： 11111111 11111111 11111111 11111110（除符号位按位取反）
得补码： 11111111 11111111 11111111 11111111

C++位运算

位是数据存储的最小单位，简记为b,也称为比特，每个0或1就是一个位(bit)。
位运算操作符：& (按位与)、| (按位或)、^ (按位异或)、~ (按位取反)、>> (按位右移)、<< (按位左移)。

&（按位与）
如果两个相应的二进制位都为１，则该位的结果值为1；否则为0。

| (按位或)
如果两个相应的二进制位只要有一个是1，结果就是1；否则为0。

~（按位取反）
每一位进行取反运算，1变成0，0变成1。

^(按位异或)
两个相同的数会变成0，反之是1

>>（按位右移）
把二进制位整体向右移动，右移等于除以2的N次方，N为右移的位数。

<<（按位左移）
把二进制位整体向左移动，左移等于乘以2的N次方，N为左移的位数

demo

    int aa = 0b1001;//9
    int bb = 0b1110;//14

    int yu    = aa & bb;//1000,8
    int huo   = aa | bb;//1111,15
    int fei   = ~aa;    //-10
    int yihuo = aa ^ bb;//111,7
    int youyi = aa >> 1;//100,4
    int zuoyi = aa << 1;//10010,18

    printf("aa=%d\n",aa);
    printf("bb=%d\n",bb);
    printf("yu=%d\n",yu);
    printf("huo=%d\n",huo);
    printf("fei=%d\n",fei);
    printf("yihuo=%d\n",yihuo);
    printf("youyi=%d\n",youyi);
    printf("zuoyi=%d\n",zuoyi);

打印

aa=9
bb=14
yu=8
huo=15
fei=-10
yihuo=7
youyi=4
zuoyi=18

打印当前系统时间

linux系统

#include 
/* 获取时间,1970年1月1日到现在的时间 */
struct timeval time;
gettimeofday(&time, NULL);
printf("s: %ld, ms: %ld\n", time.tv_sec, (time.tv_sec*1000 + time.tv_usec/1000));

windows系统

#include 
SYSTEMTIME timenow;
GetLocalTime(&timenow);   printf("hour=%u,minute=%u,second=%u,Milliseconds=%d\n",timenow.wHour,timenow.wMinute,timenow.wSecond,timenow.wMilliseconds);

睡眠sleep

linux

#include 
#include 
#include 
int sleep_time = 5;
cout << "sleep before time: " << time(NULL) << endl;
sleep(sleep_time);//睡眠单位，秒
cout << "sleep after time:  " << time(NULL) << endl;

sleep_time = 10*1000;
cout << "======================" << endl;
struct timeval tv;
gettimeofday(&tv,NULL);
cout << "usleep before time: " << tv.tv_sec<<"s,"<<tv.tv_usec<<" 微秒"<<endl;
usleep(sleep_time);//睡眠单位，微秒
gettimeofday(&tv,NULL);
cout << "usleep after time:  " << tv.tv_sec<<"s,"<<tv.tv_usec<<" 微秒"<<endl;

打印

sleep before time: 1675737566
sleep after time:  1675737571
======================
usleep before time: 1675737571s,340562 微秒
usleep after time:  1675737571s,351354 微秒

windows

#include 
#include 
SYSTEMTIME timenow;
GetLocalTime(&timenow);
printf("hour=%u,minute=%u,second=%u,Milliseconds=%d\n",timenow.wHour,timenow.wMinute,timenow.wSecond,timenow.wMilliseconds);
Sleep(10);//单位毫秒
GetLocalTime(&timenow);
printf("hour=%u,minute=%u,second=%u,Milliseconds=%d\n",timenow.wHour,timenow.wMinute,timenow.wSecond,timenow.wMilliseconds);

打印

hour=10,minute=32,second=23,Milliseconds=515
hour=10,minute=32,second=23,Milliseconds=526

C++生成随机数

方法1：rand()
使用srand()设置种子，rand()生成随机数，如果种子一样则会生成相同的随机数；如果不设置种子则默认初始种子为1，生成的随机数做为新种子用于下次生成随机数。rand()生成的是伪随机数。

struct timeval time;
gettimeofday(&time, NULL);
unsigned long ms = (time.tv_sec*1000 + time.tv_usec/1000);

srand(ms);//设置种子
int random = rand();
printf("random=%d\n",random);
usleep(100*10);

方法2：random_device
random_device 是标准库提供到一个非确定性随机数生成器，使用硬件作为随机数来源，故其调用代价较高，一般用来产生随机数种子。
random_device提供()操作符,用来返回一个min()到max()之间的一个高质量随机数，可以理解为真随机数。

std::random_device rd;//做为随机数种子

//下面几种是标准库提供的伪随机数生成器（种子相同则随机数相同），使用random_device生成的真随机数做为种子是常用方法。
///1.mt19937 是标准库提供的采用梅森旋转算法的伪随机数生成器，可以快速产生高质量到随机数。
std::mt19937 mt(rd());
for(int n = 0; n < 10; n++)
    std::cout << mt() << std::endl;

///2.default_random_engine 是标准库提供的默认随机数生成器，其实现和编译器有关。
std::default_random_engine r_eng(rd());
for (int i = 0; i < 10; ++i)
  std::cout << r_eng() << std::endl;

///3.minstd_rand 是标准库提供的采用线性同余算法的伪随机数生成器。
std::minstd_rand   r_minstd_rand(rd());
for (int i = 0; i < 10; ++i)
  std::cout << r_minstd_rand() << std::endl;

///4.ranlux24_base 是标准库提供的采用带进位减法的伪随机数生成器。
std::ranlux24_base  r_ranlux24_base(rd());
for (int i = 0; i < 10; ++i)
  std::cout << r_ranlux24_base() << std::endl;

C++取模均匀分配下标

    int _Index = -1;
    int _taskpoll = 6;
    for(int index=0;index<10;index++)
    {
        _Index++;
        _Index %= _taskpoll;
        printf("_Index=%d\n",_Index);
    }

打印

_Index=0
_Index=1
_Index=2
_Index=3
_Index=4
_Index=5
_Index=0
_Index=1
_Index=2
_Index=3

fprintf()中的stdout、stderr

#include
int printf(const char *restrict format, ...);
int fprintf(FILE *restrict fp, const char *restrict format, ...);

printf将格式化写到标准输出，fprintf写至指定的流，默认输出到屏幕。

#include 
setbuf(stdout,nullptr);//设置无缓存区，直接打印
setbuf(stderr,nullptr);
int day = 27;
fprintf(stdout, "Hello:%d \n",day);
const char *msg = "error hapd";
fprintf(stderr, "World!:%s\n",msg);

打印

Hello:27 
World!:error hapd

可以把流重定向到指定文件，下面运行可执行文件，输出流重定向到tmp.txt文件。

./fpint > tmp.txt

打印进程ID和线程ID