C++ 中文周刊 第86期

consteval auto to_number(auto str) {
    int value;{} 
    std::from_chars(std::cbegin(str), std::cend(str), value);
    return value;
}
static_assert(42 == to_number(std::string_view{"42"}));

switch (Foo foo; foo.getValue()) {
    case 1: //...
            break;
    case 2: //...
            break;
    case 3: //...
            break;
    default:
            //...
            break;
}
...
if (int val = getValue(); val<10) {
    std::cout << "val smaller than 10: " << val << '\n';
} else if (val < 5) {
    std::cout << "val smaller than 5: " << val << '\n';
} else {
    std::cout << "val is bigger than 10: " << val << '\n';
} 

try
{
    Block1;
}
catch (Type1 ex1)
{
    Block2;
}
catch (Type2 const& ex2)
{
    Block3;
}

#include <string>
#include <iostream>
#include <exception>
#include <type_traits>
#include <functional>
#include <fstream>

//The generic implementation also takes care of the return type of Callable being different than T
template<typename T, typename Callable>
auto operator|(T&& val, Callable&& fn) -> typename std::result_of<Callable(T)>::type {
    return std::forward<Callable>(fn)(std::forward<T>(val));
}

//Pre-C++17 code without std::optional
//Code relies on special values like empty string, kafka_config to be convertible to bool and return bools to determine success of a step
namespace
{
    struct env_error : public std::exception {};
    struct file_error : public std::exception {};
    struct json_error : public std::exception {};
    struct creation_error : public std::exception {};
    struct connect_error : public std::exception {};
    struct subscribe_error : public std::exception {};

    std::string get_env(std::string&& varname) {
        if (/* varname not set OR value is empty */false) { throw env_error{}; }
        return "/config/kafka.json";
    }

    std::string get_file_contents(std::string&& filename) {
        std::ifstream file(filename, std::ios::in);
        if (!file && false) { throw file_error{}; }
        return "file-contents-blah-blah";
    }

    struct kafka_config
    {
        /* url etc. */
        operator bool() { return true; }
    };

    enum config_type { json, xml, yaml, config_map };

    template<config_type format>
    kafka_config parse_kafka_config(std::string&& config) {
        if (/* parsing fails == */ false) { throw json_error{}; }
        return kafka_config{};
    }

    struct kafka_consumer
    {
        kafka_consumer(const kafka_config& config) {}
        kafka_consumer(kafka_config&& config) {}

        bool connect() { return true; }
        bool subscribe() { return true; }

        operator bool() { return true; }
    };

    kafka_consumer create_kafka_consumer(kafka_config&& config) {
        return kafka_consumer{std::move(config)};
    }

    kafka_consumer connect(kafka_consumer&& consumer) {
        if (!consumer.connect()) { throw connect_error{}; }
        return consumer;
    }

    auto subscribe = [](kafka_consumer&& consumer) {
        if (!consumer) { throw subscribe_error{}; }
        consumer.subscribe();
        return consumer;
    };

    //Invoking an operation taking more than 1 argument
    //std::bind solution
    kafka_consumer init_kafka() {
        //using namespace std::string_literals;
        //Can use "kafka-config-filename"s as they need C++14
        return std::string("kafka-config-filename")
                | get_env
                | get_file_contents
                | parse_kafka_config<xml>
                | create_kafka_consumer
                | connect
                | subscribe;
    }
}

int main(int argc, char** argv) {
    auto consumer = init_kafka();
    if (consumer) { std::cout << "Consumer creation successful\n"; }
    else { std::cout << "Consumer creation failed\n"; }

    return 0;
}

const std::string elem_str = get_element_str(div(span("first"), img("src=test.jpg"_att)));

<div>
  <span>first</span>
  <img src="test.jpg" />
</div>

     This site is open source. [Improve this page](https://github.com/wanghenshui/cppweeklynews/edit/dev/posts/086.md).