工作C++语法积累

std::transform

要使用std::transform函数需要包含头文件。

std::transform在指定的范围内应用于给定的操作，并将结果存储在指定的另一个范围内。对于一元操作，将op应用于[first1, last1)范围内的每个元素，并将每个操作返回的值存储在以result开头的范围内。给定的op将被连续调用last1-first1次。op可以是函数指针或函数对象或lambda表达式。

template <class InputIterator, class OutputIterator, class UnaryOperation>
  OutputIterator transform (InputIterator first1, InputIterator last1,
                            OutputIterator result, UnaryOperation op);
	
template <class InputIterator1, class InputIterator2,
          class OutputIterator, class BinaryOperation>
  OutputIterator transform (InputIterator1 first1, InputIterator1 last1,
                            InputIterator2 first2, OutputIterator result,
                            BinaryOperation binary_op);

如op的一个实现 即将[first1, last1)范围内的每个元素加5，然后依次存储到result中。

int op_increase(int i) {return (i + 5)};

调用std::transform的方式如下：

std::transform(first1, last1, result, op_increase);

https://blog.csdn.net/fengbingchun/article/details/63252470

std::back_inserter(op)

back-inserter是一种用于为容器添加元素的迭代器，其设计目的是避免容器中的原元素被覆盖，在容器的末尾自动插入新元素。

if (options_description.external_description)
    {
        const auto & external_options = options_description.external_description->options();
        std::transform(external_options.begin(), external_options.end(), std::back_inserter(cmd_options), getter);
    }

Boost.ProgramOptions库

Boost.ProgramOptions是Boost中一个专门用来解析命令行的库，其目标是轻松的解析命令行选项。 要使用Boost.ProgramOptions解析命令行选项，需要执行以下三个步骤： 定义命令行选项。 可以为它们指定名称，并指定可以将哪些名称设置为值。

C++17 std::optional

optional是一个模板类

template <class T>
class optional;

它内部有两种状态，要么有值（T类型），要么没有值（std::nullopt）。有点像T*指针，要么指向一个T类型，要么是空指针(nullptr)。

构造：

#include 
#include 
using namespace std;
 
int main() {
    optional<int> o1;  //什么都不写时默认初始化为nullopt
    optional<int> o2 = nullopt;  //初始化为无值
    optional<int> o3 = 10;  //用一个T类型的值来初始化
    optional<int> o4 = o3;  //用另一个optional来初始化
    return 0;
}

是否有值

#include 
#include 
using namespace std;
 
int main() {
    optional<int> o1;
    if (o1) {
        printf("o1 has value\n");
    }
    if (o1.has_value()) {
        printf("o1 has value\n");
    }
    return 0;
}

取值

#include 
#include 
#include 
using namespace std;
 
int main() {
    optional<int> o1 = 5;
    printf("%d\n", *o1);
    optional<string> o2 = "hello";
    printf("%s\n", o2->c_str());
    printf("%s\n", o2.value().c_str());
    return 0;
}

将一个有值的optional变为无值，用.reset()。该函数会将已存储的T类型对象析构掉

#include 
#include 
using namespace std;
 
int main() {
    optional<int> o1 = 5;
    o1.reset();

解决问题：

#include 
using namespace std;
 
optional<bool> getBoolValue() {
    if (xxx) {
        return nullopt;  // 计算失败时返回
    }
    // do some work
    return false;  // 计算成功时返回的false
}

参考：https://blog.csdn.net/yuejisuo1948/article/details/118440275

std::string trim(按照规则剪裁string)

template <typename F>
std::string trim(const std::string & str, F && predicate)
{
    size_t cut_front = 0;
    size_t cut_back = 0;
    size_t size = str.size();

    for (size_t i = 0; i < size; ++i)
    {
        if (predicate(str[i]))
            ++cut_front;
        else
            break;
    }

    if (cut_front == size)
        return {};

    for (auto it = str.rbegin(); it != str.rend(); ++it)
    {
        if (predicate(*it))
            ++cut_back;
        else
            break;
    }

    return str.substr(cut_front, size - cut_front - cut_back);
}

向父类传递和父类多态

class TestReadWriteBufferFromHTTP : public detail::ReadWriteBufferFromHTTPBase<std::shared_ptr<UpdatableSession<PooledSessionFactory>>>
{
    using SessionType = UpdatableSession<PooledSessionFactory>;
    using Parent = detail::ReadWriteBufferFromHTTPBase<std::shared_ptr<SessionType>>;

public:
    explicit TestReadWriteBufferFromHTTP(
        Poco::URI uri_,
        const std::string & method_ = {},
        OutStreamCallback out_stream_callback_ = {},
        const ConnectionTimeouts & timeouts_ = {},
        const Poco::Net::HTTPBasicCredentials & credentials_ = {},
        size_t buffer_size_ = DBMS_DEFAULT_BUFFER_SIZE,
        const UInt64 max_redirects = 0,
        size_t max_connections_per_endpoint = DEFAULT_COUNT_OF_HTTP_CONNECTIONS_PER_ENDPOINT);
}

TestReadWriteBufferFromHTTP::TestReadWriteBufferFromHTTP(
    Poco::URI uri_,
    const std::string & method_,
    OutStreamCallback out_stream_callback_,
    const ConnectionTimeouts & timeouts_,
    const Poco::Net::HTTPBasicCredentials & credentials_,
    size_t buffer_size_,
    const UInt64 max_redirects,
    size_t max_connections_per_endpoint)
    : Parent(
        std::make_shared<SessionType>(uri_, max_redirects, std::make_shared<PooledSessionFactory>(timeouts_, max_connections_per_endpoint)),
        uri_,
        credentials_,
        method_,
        out_stream_callback_,
        buffer_size_)
{
}

.Parent和using Parent可以实现父类多态

re2::RE2

filtered = std::any_of(
source.includes.begin(),
source.includes.end(),
[&column](const re2::RE2 & re) { return !RE2::PartialMatch(column.name, re); });

路径读取

#include 
#include 

namespace fs = std::filesystem;

int main() {
    // 获取当前文件的路径
    fs::path currentFilePath = __FILE__;

    // 推导出其他文件的路径
    fs::path otherFilePath = currentFilePath.parent_path() / "../other_file.txt";

    // 输出其他文件的绝对路径
    std::cout << "Other file path: " << otherFilePath.lexically_normal() << std::endl;

    return 0;
}

c++ json

https://www.miaoerduo.com/2018/06/22/the-usage-of-cpp-boost-json/