现代C++、STL、QTL的使用

C++ insight：https://cppinsights.io/
bilibili 高效CPP：C++泛型编程
bilibili 合集·[现代C++基础]

0、现代C++中最重要的是：

右值引用&&、移动语义std::move、完美转发std::forward、万能引用T&&

void Func(int& x) { cout << "左值引用" << endl; }
void Func(const int& x) { cout << "const左值引用" << endl; }
void Func(int&& x) { cout << "右值引用" << endl; }
void Func(const int&& x) { cout << "const右值引用" << endl; }
 
template<typename T>
void PerfectForward(T&& t)  // 万能引用
{
    Func(std::forward<T>(t));  // 根据参数t的类型去匹配合适的重载函数
}
 
int main()
{
    int a = 4;  // 左值
    PerfectForward(a);
 
    const int b = 8;  // const左值
    PerfectForward(b);
 
    PerfectForward(10); // 10是右值
 
    const int c = 13;
    PerfectForward(std::move(c));  // const左值被move后变成const右值
 
    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

1、std::vector、QVector

1.1 求最大值

//平均值
double getAverage(QVector<double> data) {
    return std::accumulate(data.begin(), data.end(), 0.0) / data.size();
}
 
//最大值
double getMax(QVector<double> data) {
    return *std::max_element(std::begin(data), std::end(data));
}
 
//最小值
double getMin(QVector<double> data) {
    return *std::min_element(std::begin(data), std::end(data));
}
 
//标准差, 也称均方差, 是方差的算术平方根
double getStd(QVector<double> data) {
    double mean = getAverage(data);
    double accum = 0.0;
    std::for_each (std::begin(data), std::end(data), [&](const double d) {
        accum += (d-mean) * (d-mean);
    });
    return sqrt(accum / data.size()); //除以n-1是无偏估计方差, 除以n是概率分布方差
}

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

QVector <double> data {11.0, 44.0, 22.0, 33.0, 10.0,65.0};

//求最大值最小值：返回的是迭代器QVector::iterator max
auto max = std::max_element(std::begin(data), std::end(data));
auto min = std::min_element(std::begin(data), std::end(data));
double biggest = *max;
double smallest = *min;

//最大值和最小值的位置：
auto positionmax = std::distance(std::begin(data),max);
auto positionmin = std::distance(std::begin(data),min);
int posmax = positionmax;
int posmin = positionmin;

qDebug()<<"biggest = "<<biggest;
qDebug()<<"smallest = "<<smallest;
qDebug()<<"pos ="<<posmax;
qDebug()<<"posmin = "<<posmin;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

2、std::list、QList

3、std::map、QMap

4、std::multimap、QMultiMap

5、std::tuple

（1）创建：

std::tuple<T1, T2, TN> t1;  				//创建一个空的tuple对象（使用默认构造），它对应的元素分别是T1和T2...Tn类型，采用值初始化。
std::tuple<T1, T2, TN> t2(v1, v2, ... TN);  //创建一个tuple对象，它的元素分别是T1和T2 ...Tn类型; 要获取元素的值需要通过tuple的成员get(obj)进行获取(Ith是指获取在tuple中的第几个元素，请看后面具体实例)。
std::tuple<T1&> t3(ref&); 					// tuple的元素类型可以是一个引用
std::make_tuple(v1, v2); 					// 像pair一样也可以通过make_tuple进行创建一个tuple对象
1
2
3
4

（2）取值： std::get()
tuple不支持迭代，只能通过元素索引(或tie解包)进行获取元素的值。

{
    int n = 1;
    auto t = std::make_tuple(10, "Test", 3.14, std::ref(n), n);
    // get尖括号中的值必须是一个整型常量表达式。从0开始计数，意味着get<0>是第一个成员。
    std::cout << "The value of t is "  << "("
               << std::get<0>(t) << ", " << std::get<1>(t) << ", "
               << std::get<2>(t) << ", " << std::get<3>(t) << ", "
               << std::get<4>(t) << ")\n";
    // 由于get返回指定元素的引用，所以可用来修改指定位置的元素的值。此处因为第4个元素是引用类型，所以被引用的值也会改变
    std::get<3>(t) = 9;
    std::cout << n << std::endl;
}
1
2
3
4
5
6
7
8
9
10
11
12

（3）解包： std::tie()

int myint;
char mychar;
std::tuple<int, float, char> mytuple;
mytuple = std::make_tuple(10, 2.6, 'a');          // packing values into tuple

std::tie(myint, std::ignore, mychar) = mytuple;   // unpacking tuple into variables
std::cout << "myint contains: " << myint << '\n';
std::cout << "mychar contains: " << mychar << '\n';
1
2
3
4
5
6
7
8

（4）元素个数： std::tuple_size<>()

std::tuple<int, char, double> mytuple (10, 'a', 3.14); 
int count = std::tuple_size<decltype(mytuple)>::value;		//3
1
2

（5）元素类型： std::tuple_element

std::tuple<int, std::string> third(9, std::string("ABC"));       
std::tuple_element<1, decltype(third)>::type  val_1;		// 得到元组第1个元素的类型，用元组第一个元素的类型声明一个变量
1
2

（6）拼接

std::tuple<char, int, double> first('A', 1, 2.2f);
auto second = std::tuple_cat(first, std::make_tuple('B', std::string("-=+")));
std::tuple<char, int, double, char, std::string> third = std::tuple_cat(first, std::make_tuple('B', std::string("-=+")));

1
2
3
4

（7）Qt中的实际应用
实际应用：

#include 
#include 
std::tuple<quint16, quint16, quint16, QVector<quint16>, QVector<quint16>> myFunction()
{
    quint16 data1 = 10;
    quint16 data2 = 20;
    quint16 data3 = 30;
    QVector<quint16> array1{1, 2, 3};
    QVector<quint16> array2{4, 5, 6};
    return std::make_tuple(data1, data2, data3, array1, array2);
}
int main()
{
    auto result = myFunction();
    quint16 returnedData1 = std::get<0>(result);
    quint16 returnedData2 = std::get<1>(result);
    quint16 returnedData3 = std::get<2>(result);
    QVector<quint16> returnedArray1 = std::get<3>(result);
    QVector<quint16> returnedArray2 = std::get<4>(result);
    // 使用返回的数据进行后续操作...
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

6、std::future、std::async、std::promise

C/C++开发基础——std::future与async异步编程