C++17的改变

今天药忘吃喽~ 2022-08-29 00:26 142阅读 0赞

[原文地址][Link 1]

# 如初化 #

{ 
       if (Foo * ptr = get_foo())
          use(*ptr);
       more_code();
    }

不能转为`极`:

{ 
       { //用这个包含
          QVariant var = getAnswer();
          if (var.isValid())
             use(var);
       }
       more_code();
    }

`17版本`:

{ 
       if (QVariant var = getAnswer(); var.isValid())use(var);
       more_code();
    }

`猜语句`:

{ 
       switch (Device dev = get_device(); dev.state())
       { 
       case sleep: /*...*/ break;
       case ready: /*...*/ break;
       case bad: /*...*/ break;
       }
    }

`结构绑定`:

tuple<int, string> func();
    auto [ i, s ] = func();
    use(s, ++i);

编译成:

pair<int, string> func();
    
    auto __tmp = func();//副本
    auto & i = get<0>(__tmp);
    auto & s = get<1>(__tmp);
    //i,s不完全是引用,而是`编译器`的`符号`.
    
    use(s, ++i);

即使`auto [i,s] = func();`没`&`,也是引用.如:

#include <string>
    #include <iostream>
    
    struct Foo
    { 
       int x = 0;
       std::string str = "world";
       ~Foo() {  std::cout << str; }
    };
    
    int main()
    { 
        auto [ i, s ] = Foo();
        std::cout << "你好";
        s = "结构绑定";
    }
    //编译为
    #include <string>
    #include <iostream>
    
    struct Foo
    { 
       int x = 0;
       std::string str = "world";
       ~Foo() {  std::cout << str; }
    };
    
    int main()
    { 
        auto __tmp = Foo();
        std::cout << "你好";
        __tmp.str = "结构绑定";
    }

输出为`你好结构绑定`.注意`s = "结构绑定";`在`临变量内部`修改`Foo::str`,所以析构器打印`结构绑定`.`&`用来应用至`隐藏的临时变量`.

struct X {  int i = 0; };
    X makeX();
    X x;
    auto [ b ] = makeX();
    b++;
    auto const [ c ] = makeX();
    c++;
    auto & [ d ] = makeX();
    d++;
    auto & [ e ] = x;
    e++;
    auto const & [ f ] = makeX();
    f++;
    //编译为
    struct X {  int i = 0; };
    X makeX();
    X x;
    
    auto __tmp1 = makeX();
    __tmp1.i++;
    auto const __tmp2 = makeX();
    __tmp2.i++; //不能修改常
    auto & __tmp3 = makeX(); //非常引用不能绑定临
    
    auto & _tmp3 = x;
    x.i++;
    auto const & _tmp4 = makeX();
    __tmp4.i++; //不能修改常

编译器尽量用`get<N>()`,所以可直接同`构`用.

struct Foo { 
        int x;
        string str;
    };
    
    Foo func();
    auto [ i, s ] = func();
    use(s, ++i);
    //编译为
    struct Foo { 
        int x;
        string str;
    };
    Foo func();
    Foo __tmp = func();
    auto & i = __tmp.x;
    auto & s = __tmp.str;
    
    use(s, ++i);

实现自己的`get()`,`tuple_size`,`tuple_element`,对默认情况下不行的任何`类/构`,要实现自己的自定义`get<>()`并且还要实现`tuple_size`和`tuple_element`.

class Foo { 
          // ...
       public:
          template <int N> auto & get() /*常?*/ {  /*...*/ }
    };
    //或在类外部取
    template<int N> auto & get(Foo /*常?*/ & foo) {  /*...*/ }
    //...
       
       // 特化tuple_size/element
       // 是的,在标名字空间
    namespace std { 
      //Foo有多少元素
      template<> struct tuple_size<Foo> {  static const int value = 3; }
      //N的类型
      template<int N> struct tuple_element<N, Foo> {  using type = 加代码; }
    }
       
    Foo func();
    auto [ i, s ] = func();
    use(s, ++i);

数组.

int arr[4] = {  /*...*/ };
    auto [ a, b, c, d ] = arr;//相当于绑定
    auto [ t, u, v ] = std::array<int,3>();
    // 映射
    for (auto && [key, value] : my_map)
    { 
        //...
    }

`如常式`.

class Foo { 
      int myInt;
      string myString;
    public:
      int const & refInt() const
      {  return myInt; }
      string const & refString() const
      {  return myString; }
    };
    
    namespace std
    { 
       template<> class tuple_size<Foo>
           : public integral_constant<int, 2>
       {  };//继承.
       template<int N> class tuple_element<N, Foo>
       { 
       public:
          using type =
          conditional_t<N==0,int const &,string const &>;//整,串.
       };
    }
    
    template<int N> auto & get(Foo const & foo)
    { 
      static_assert(0 <= N && N < 2, "仅有2成员");
    
      if constexpr (N == 0)  // 
         return foo.refInt();
      else if constexpr (N == 1)//
         return foo.refString();
    }//常式.

`如 常式(式)`,`式`必须为`常式`,否则编译不过.  
推导:

pair<int, string> is1 = pair(17, "hello");
    auto is2 = pair(17, "hello"); // !!pair<int, char const *>
    auto is3 = pair(17, string("hello"));
    auto is4 = pair(17, "hello"s);

`隐式/显式`推导.`显式`:

template<typename T>
    struct Thingy
    { 
      T t;
    };
    
    // !! 看这里 !!
    Thingy(const char *) -> Thingy<std::string>;
    //加上该句
    Thingy thing{ "串"}; // thing.t是个`标::串`.

`元<类 T, 类 U, ...> 构/类...`隐式推导类型  
`元<动>`.

template <auto v>
    struct integral_constant
    { 
       static constexpr auto value = v;
    };//自动
    integral_constant<2048>::value
    integral_constant<'a'>::value

`折叠表达式`

auto x = sum(5, 8);
    auto y = sum(a, b, 17, 3.14, ...);
    //如何写sum函数.
    template <typename... Args>
    auto sum(Args&&... args) { 
       return (args + ... + 0);
    }

`嵌套名字空间`

namespace A::B::C { 
       struct Foo {  };
          //...
    }

单参输出:

static_assert(sizeof(short) == 2)

内联变量:

// foo.h
    inline int foo = 10;
    // foo.h
    struct Foo { 
       static inline int foo = 10;//内联
    };

保证省略复制

// header <mutex>
    namespace std
    { 
       template <typename M>
       struct lock_guard
       { 
          explicit lock_guard(M & mutex);
          //不可复制,不可移动
          lock_guard(lock_guard const & ) = delete;
          //...
       }
    }
    
    //你代码
    lock_guard<mutex> grab_lock(mutex & mtx)
    { 
       return lock_guard<mutex>(mtx);
    }
    
    mutex mtx;
    
    void foo()
    { 
       auto guard = grab_lock(mtx);
       /*持锁*/
    }

新`[[属性]]`,直降

switch (device.status())
    { 
    case sleep:
       device.wake();
       [[fallthrough]];//直降
    case ready:
       device.run();
       break;
    case bad:
       handle_error();
       break;
    }

`不丢`:

struct SomeInts
    { 
       [[nodiscard]] bool empty();//不丢.
    //不应丢弃返回值.
       void push_back(int);
       //等等
    };
    
    void random_fill(SomeInts & container,
          int min, int max, int count)
    { 
       container.empty(); // 先清理掉
    //警告,忽略返回值.
       for (int num : gen_rand(min, max, count))
          container.push_back(num);
    }

`类/构`上:

struct [[nodiscard]] MyError { 
      std::string message;
      int code;
    };//不丢
    
    MyError divide(int a, int b) { 
      if (b == 0) { 
        return { "除0", -1};
      }
    
      std::cout << (a / b) << '\n';
    
      return { };
    }
    
    divide(1, 2);//警告,忽略了不丢返回值.

要小心使用`不丢`.

[[maybe_unused]] bool res = step1();
    //可能未用该res,
    assert(res);
    step2();
    etc();

`可能未用`函数:

[[maybe_unused]] void f()
    { 
        /*...*/
    }
    int main()
    { 
    }

`std::string_view`串视,标准化现有实践.  
假设编写了某种解析器:

Foo parseFoo(std::string const & input);

但是后来一些用户用`char *`并创建了个`string`来传递给解析器,所以`加(或改为)`这个接口:

Foo parseFoo(char const * str);

`该接口太有用`,用户加至自己的,且最后`无尾`.

Foo parseFoo(char const * str, int length);

我们又用了自定义的串:

Foo parseFoo(MyString const & str);

如何维护这些接口呢?

Foo parseFoo(std::string_view input);
    
    //不要提供该接口,而是
    Foo parseFoo(char const * str, int length)
    { 
       return parseFoo(string_view(str,length));
    }
    
    class MyString { 
       //...
       operator string_view() const
       { //符号.串视().
          return string_view(this->data, this->length);
       }
    };

# 2示例 #

解析`xml`,不断返回`串`,每个串都是分配,因而用`串视`.注意,`串视不拥有但指向`串内存.为`引用语义`.  
`标::可选<T>`

Foo parseFoo(std::string_view input);
    //解析失败怎么办.
    std::optional<Foo> parseFoo(std::string_view in);//一个可选搞定.

或者:

if (optional ofoo = parseFoo(str); ofoo)
       use(*ofoo);//这样
    optional<int> oi = parseInt(str);
    std::cout << oi.value_or(0);

`更完美联`:`std::variant<A,B,C,...>`.

struct Stuff
    { 
       std::variant<int, double, string> data;
    };

用法:

void handleData(int i);
    void handleData(double d);
    void handleData(string const & s);
    
    //...
    
    std::visit([](auto const & val) {  handleData(val); }, stuff.data);
    //访问(函数+数据)
    
    //也可switch(stuff.data.index())

用`λ`来搞:

struct ThatLambda
    { 
       void operator()(int const & i) {  handleData(i); }
       void operator()(double const & d) {  handleData(d); }
       void operator()(string const & s) {  handleData(s); }
    };
    
    ThatLambda thatLambda;
    std::visit(thatLambda, stuff.data);

if (holds_alternative<int>(data))
       int i = get<int>(data);
    
    // 非双精则抛
    double d = get<double>(data);
    //
    std::variant<Foo, Bar> var;  // 调用 Foo()
    //无Foo不编译
    
    Bar bar = makeBar();
    var = bar; // 调用~Foo()和Bar(Bar const &)
    // (万一Bar(Bar const & b)抛呢?)
    
    var = Foo(); // 调用~Bar()和移动构造器Foo(Foo &&)
    // (即使移动不应该抛,万一Foo(Foo && b)抛呢?)
    
    var = someFoo;//调用Foo::operator=(Foo const&)
    std::variant<Foo, std::string> foostr;
    
    foostr="hello";//char*不是Foo或string
    //但foostr有个std::string

`std::any`,任何.

std::any v = ...;
    if (v.type() == typeid(int)) { 
       //整
       int i = any_cast<int>(v);
    }

`std::any`不是模板,运行时更改类型.

std::vector<any> things;

上面可容纳`Circles,Squares,Triangles,ints,strings,...`等等.  
文系:

#include <filesystem>
    #include <iostream>
    namespace fs = std::filesystem;
    
    void copy_foobar() { //有个特殊的/操作符.
      fs::path dir = "/";
      dir /= "sandbox";
      fs::path p = dir / "foobar.txt";
      fs::path copy = p;
      copy += ".bak";
      fs::copy(p, copy);
      fs::path dir_copy = dir;
      dir_copy += ".bak";
      fs::copy(dir, dir_copy, fs::copy_options::recursive);
    }
    
    void display_contents(fs::path const & p) { 
      std::cout << p.filename() << "\n";
    
      if (!fs::is_directory(p))
        return;
    
      for (auto const & e: fs::directory_iterator{ p}) { 
        if (fs::is_regular_file(e.status())) { 
          std::cout << " " << e.path().filename()
                    << " [" << fs::file_size(e) << " 字节]\n";
        } else if (fs::is_directory(e.status())) { 
          std::cout << " " << e.path().filename() << "\n";
        }
      }
    }

大量并行算法(`69`)个:

<table> 
 <thead> 
  <tr> 
   <th align="left"><code>1</code></th> 
   <th align="left">2</th> 
   <th align="left">3</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>adjacent_difference</code></td> 
   <td align="left">is_heap_until</td> 
   <td align="left">replace_copy_if</td> 
  </tr> 
  <tr> 
   <td align="left"><code>adjacent_find</code></td> 
   <td align="left">is_partitioned</td> 
   <td align="left">replace_if</td> 
  </tr> 
  <tr> 
   <td align="left"><code>all_of</code></td> 
   <td align="left">is_sorted</td> 
   <td align="left">reverse</td> 
  </tr> 
  <tr> 
   <td align="left"><code>any_of</code></td> 
   <td align="left">is_sorted_until</td> 
   <td align="left">reverse_copy</td> 
  </tr> 
  <tr> 
   <td align="left"><code>copy</code></td> 
   <td align="left">lexicographical_compare</td> 
   <td align="left">rotate</td> 
  </tr> 
  <tr> 
   <td align="left"><code>copy_if</code></td> 
   <td align="left">max_element</td> 
   <td align="left">rotate_copy</td> 
  </tr> 
  <tr> 
   <td align="left"><code>copy_n</code></td> 
   <td align="left">merge</td> 
   <td align="left">search</td> 
  </tr> 
  <tr> 
   <td align="left"><code>count</code></td> 
   <td align="left">min_element</td> 
   <td align="left">search_n</td> 
  </tr> 
  <tr> 
   <td align="left"><code>count_if</code></td> 
   <td align="left">minmax_element</td> 
   <td align="left">set_difference</td> 
  </tr> 
  <tr> 
   <td align="left"><code>equal</code></td> 
   <td align="left">mismatch</td> 
   <td align="left">set_intersection</td> 
  </tr> 
  <tr> 
   <td align="left"><code>fill</code></td> 
   <td align="left">move</td> 
   <td align="left">set_symmetric_difference</td> 
  </tr> 
  <tr> 
   <td align="left"><code>fill_n</code></td> 
   <td align="left">none_of</td> 
   <td align="left">set_union</td> 
  </tr> 
  <tr> 
   <td align="left"><code>find</code></td> 
   <td align="left">nth_element</td> 
   <td align="left">sort</td> 
  </tr> 
  <tr> 
   <td align="left"><code>find_end</code></td> 
   <td align="left">partial_sort</td> 
   <td align="left">stable_partition</td> 
  </tr> 
  <tr> 
   <td align="left"><code>find_first_of</code></td> 
   <td align="left">partial_sort_copy</td> 
   <td align="left">stable_sort</td> 
  </tr> 
  <tr> 
   <td align="left"><code>find_if</code></td> 
   <td align="left">partition</td> 
   <td align="left">swap_ranges</td> 
  </tr> 
  <tr> 
   <td align="left"><code>find_if_not</code></td> 
   <td align="left">partition_copy</td> 
   <td align="left">transform</td> 
  </tr> 
  <tr> 
   <td align="left"><code>generate</code></td> 
   <td align="left">remove</td> 
   <td align="left">uninitialized_copy</td> 
  </tr> 
  <tr> 
   <td align="left"><code>generate_n</code></td> 
   <td align="left">remove_copy</td> 
   <td align="left">uninitialized_copy_n</td> 
  </tr> 
  <tr> 
   <td align="left"><code>includes</code></td> 
   <td align="left">remove_copy_if</td> 
   <td align="left">uninitialized_fill</td> 
  </tr> 
  <tr> 
   <td align="left"><code>inner_product</code></td> 
   <td align="left">remove_if</td> 
   <td align="left">uninitialized_fill_n</td> 
  </tr> 
  <tr> 
   <td align="left"><code>inplace_merge</code></td> 
   <td align="left">replace</td> 
   <td align="left">unique</td> 
  </tr> 
  <tr> 
   <td align="left"><code>is_heap</code></td> 
   <td align="left">replace_copy</td> 
   <td align="left">unique_copy</td> 
  </tr> 
 </tbody> 
</table>

`并行`使用方法:

std::for_each(std::execution::par, first, last,
        [](auto & x){  process(x); }
    );
    std::copy(std::execution::par, first, last, output);
    std::sort(std::execution::par, first, last);
    std::transform(std::execution::par_unseq, xfirst, xlast, yfirst,
        [=](double xi, double yi){  return a * xi + yi; }
    );
    //在前面加上并行执行.

执行策略,`下面的原文不好翻译,要注意`:

<table> 
 <thead> 
  <tr> 
   <th align="left"><code>策略</code></th> 
   <th align="left">意思</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>std::execution::seq</code></td> 
   <td align="left">调用线程<code>不确定有序</code>(线程内重排)</td> 
  </tr> 
  <tr> 
   <td align="left"><code>std::execution::par</code></td> 
   <td align="left"><code>多线程</code>调用,线程内(重排),<code>线程间</code>并行.</td> 
  </tr> 
  <tr> 
   <td align="left"><code>std::execution::par_unseq</code></td> 
   <td align="left">多线程<code>可能向量化</code>,调用间<code>无序</code>,且可能<code>交错</code>.这是<code>放松模式</code>.</td> 
  </tr> 
 </tbody> 
</table>

# 技规 #

在`std::experimental`里面.`概念`,现在已是`标准`.

template <RandomAccessIterator T>
    auto binarySearch(T first, T second)
    { 
       //...
    }

后面,没啥了.

[Link 1]: https://gitee.com/zjh6/cpp17_in_TTs/blob/main/ALL_IN_ONE.md