sstream及按格式字符分割字符串

1)按’,'逗号字符分割案例

//字符串按','逗号分割，（分割带逗号的字符串）案例如下：
typedef std::vector<std::string>  myStrList;
myStrList splitString(const string& str,char tag)
{
    myStrList strlist;
    std::string substr;
    for(size_t i = 0; i < str.length(); i++)
    {
        if(tag == str[i])
        {
            if(!substr.empty())
            {
                strlist.push_back(substr);//把字符串追加到字符串vector中
                substr.clear();
            }
        }
        else
        {
            substr.push_back(str[i]);//按字符字符追加字符串
        }
    }

    if(!substr.empty())　//最后一次判断是否完成字符串追加,如"aa,bb"格式时，追加；"aa,bb,",则不执行这条语句，说白了就是判断最后一个字符是否是逗号；
    {
        strlist.push_back(substr);
    }

    return strlist;
}

int main(int argc, char** argv)
{
    string teststr("ade,df,aaa,456,sd3");
    auto ret = splitString(teststr,',');
    for(auto e : ret)
    {
        cout<<e<<endl;
    }
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

２）字符追加生成字符串

//以字符形式追加空字符串：
int main(int argc, char** argv)
{
    string str;
    str.push_back('a');
    str.push_back('a');
    str.push_back('a');
    cout<<str<<endl;　//输出字符串"aaa"
    return 0;
}
1
2
3
4
5
6
7
8
9
10

３）sstream的使用
//sstream的使用场景介绍：
最近学习dbc文件数据解析，遇到解析信号时，需要字符串转换为其他dbc信号，dbc信号中包括很多类型，所以源码中
用到了sstream，实现类型转换，经过学习和验证，sstream果然是个好东西。sstream这是一个字符串流，经常用于格式转换！！！
sstream里面包括三个类:istringstream,ostringstream,stringstream三个类；
案例中，只写了字符串输入流的案例，输出流照猫画虎，肯定也是没问题，不在赘述！

int main(int argc, char** argv)
{
    std::string line("a22ts,**");
    std::istringstream sstream(line); //字符串输入流定义
    int a;
    sstream.ignore(1); //如果不忽略第一个字母'a',则下面的格式转换不会正确执行；
    sstream >> a;
    printf("a is %d\r\n",a); //输出为a is 22
    string str2;
    sstream >> str2; //输出：ts,**
    cout<<str2<<endl;
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

４）std::move()移动语义算法的使用

int main(int argc, char** argv)
{
    std::vector<int> c = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    std::vector<int> result;
    result.resize(10);
    //把c中元素逐个移动到result中
    std::move(c.begin(), c.end(), result.begin()); //使用移动语义算法
    //输出
    for (auto var : result)
    {
        std::cout << var << ",";
    }
    cout<<endl;
    //打印结果：0,1,2,3,4,5,6,7,8,9,
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

５）//时间戳案例

int main(int argc, char** argv)
{
    time_t start_time;
    time_t end_time;
    start_time = time(NULL);
	printf("start_time is %d\r\n",(int)start_time);
    sleep(3);
    end_time = time(NULL);
	printf("end_time is %d\r\n",(int)end_time);
	printf("process run_time is %d\r\n",(int)(end_time - start_time));    
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

//2023年九月２８日学习

1)
//cmakelist.txt的环境变量的打印区分大小写
message("dir is = ${project_source_dir}") #小写不能打印
message("dir is = ${PROJECT_SOURCE_DIR}") #大写能打印
include_directories(${PROJECT_SOURCE_DIR}/inc)  #PROJECT_SOURCE_DIR必须大写

2)
printf %-5s
printf函数中用到格式符%-5s,其中数字5表示输出的字符串占用5列,如果字符串长度小于5,则输出按方式从左起输出该字串,右补空格;
测试代码：printf("%-10s,%d\r\n","abc",10); //输出结果“abc       ,10"
    printf("%-10s,%d\r\n","abc",10); //带有'-'的是向后空10个字符；"abc       ,10",相当于负号，反方向从后往前
    printf("%10s,%d\r\n","abc",10); //没有'-'的是前面的输出占位符，"            abc,10",相当于正号;

3)
__VA_ARGS__ 是可变参数宏
#define Debug(...) printf(__VA_ARGS__)
Debug("Y = %s\n", "aaaa");
3.1)
##__VA_ARGS__ 宏前面加上##的作用在于，当可变参数的个数为0时，这里的##起到把前面多余的","去掉的作用，否则会编译出错
#define my_print1(...)      printf(__VA_ARGS__)
#define my_print2(fmt,...)  printf(fmt, __VA_ARGS__)  
#define debugTest(format,...) printf(format, ##__VA_ARGS__)



#define PR(level, val, fmt, ...)  \
    do {                                                    \
            if( level <= pr_level )                         \
                printf("%s,%s:%d"fmt,val, __FUNCTION__, __LINE__,##__VA_ARGS__);   \
    } while(0)


4)atomic的用法，load,fetch_add;
load函数用于获取原子变量的当前值。
fetch_add函数添加到包含的值并返回它在操作之前具有的值;两者等价：加法：a += n或者a.fetch_add(n)
std::memory_order_relaxed //内存序
-fdump-class-hierarchy的使用，打印类的siz及对齐大小;

5)chrono::steady_clock::now函数,duration_cast等的使用，计算成员运行时间：
#include
int main()
{
    auto start = std::chrono::steady_clock::now();
    usleep(2000);
    auto end = std::chrono::steady_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
    printf("%ld\r\n",duration.count());
    return 0;
}

6)需要包含#include <time.h>头文件
localtime和asctime的使用方法；　struct tm *localtime(const time_t *clock);
Localtime是一个 C/C++ 标准库函数，用于将时间戳（time_t 类型）转换为本地时间的结构体
asctime是把本地时间的结构体转换为时间字符串;
#include 
#include 
#include 
int main(void)
{
  time_t timer;//time_t就是long int 类型
  struct tm *tblock;
  timer = time(NULL); //时间戳
  tblock = localtime(&timer); 
  printf("Local time is: %s\n",asctime(tblock));
std::time_t time = std::time(NULL);
cout<<time<<endl; //时间戳
struct tm* tblock = localtime(&time); //用于将时间戳转换为本地时间的结构体
printf("%s\r\n",asctime(tblock));
  return 0;
}


7)sprintf和snprintf:把格式化的数据写入某个字符串缓冲区
但sprintf没有字节限制，不会注意缓冲区大小，而snprintf会注意缓冲区大小，建议用snprintf这个函数；

    char buf[50];
    int num = sprintf(buf,"name:%s,age:%d,sex:%c","jianghuaiwei",23,'N'); //num是写的长度
    cout<<buf<<endl;

#include 

int main(void) 
{ 
	char str[50]; 
	int num = 123;	
	snprintf(str, 50, "The number is %d", num); printf("%s\n", str);
	return 0; 
} 


8) va_list定义，va_start,va_arg,va_end的使用；主要和vsprintf函数结合使用；
va_list是一个变量类型，和三个宏va_start,va_arg,va_end;
#include
int add(int n,...) //n是代表几个参数的意思？
{
    int sum = 0;
    va_list ap; //首先声明一个char类型的变量指针
    va_start(ap,n); //将指针指向第二个参数，没错就是函数的第二个参数，函数的第一个参数是n;
    for(int i = 0; i < n; i++) //获取当前函数的值，并且指针+1（指针指向下一个参数）
    {
        sum += va_arg(ap,int);
    }
    va_end(ap);
    return sum;
}
int main(int argc,char** argv)
{
    printf("通过库函数实现的add(3,10,20,30) = %d\n",add(3,10,20,30));
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112