C++ 中文周刊 第5期

从reddit/hackernews/lobsters/meetingcpp摘抄一些c++动态。

每周更新

周刊项目地址 github，在线地址 ｜知乎专栏

欢迎投稿，推荐或自荐文章/软件/资源等，请提交 issue

资讯

编译器信息最新动态推荐关注hellogcc公众号

本周周报github直达

三月提案汇总

其中，有个std::colony提案，就是https://github.com/mattreecebentley/plf_colony，设计了一个更大的容器。未见的能进，不过设计的挺有意思的。有时间可以看看设计文档

文章

没啥说的，解释概念

看代码

#include <iostream>
#include <variant>
#include <vector>
// Forward Declaration
struct Node;
// Simple
using Int = int;
using String = std::string;
using Null = std::monostate;
// Composite
using Sequence = std::vector<Node>;
using Data = std::variant<Int, String, Null, Sequence>;
struct Node {
std::string m_name;
Data m_data;
explicit Node(std::string&& name, Data&& data) : m_name(std::move(name)), m_data(std::move(data)) {}
explicit Node(Data&& data) : m_data(data) {}
};
template<typename Stream>
Stream& operator<<(Stream& stream, const Null& null) {
stream << "null";
return stream;
}
template<typename Stream>
Stream& operator<<(Stream& stream, const Data& data) {
std::visit([&](auto& val) {
stream << val;
}, data);
return stream;
}
template<typename Stream>
Stream& operator<<(Stream& stream, const Node& node) {
std::cout
<< "Node{ name='" << node.m_name
<< "' data=" << node.m_data << " }";
return stream;
}
template<typename Stream>
Stream& operator<<(Stream& stream, const Sequence& data) {
std::cout << "Sequence[ ";
for(const auto& d : data) {
std::cout << d << ' ';
}
std::cout << ']';
return stream;
}
template<typename T, typename Func>
Sequence vecToSeq(const std::vector<T>& vec, Func func) {
Sequence result;
for(const auto& v : vec) {
result.push_back(func(v));
}
return result;
}
int main() {
auto root =
Node("addUserRequest",
Sequence({
Node("userId", 123),
Node("name", "Charles"),
Node("age", 424),
Node("sessionInfo", Sequence({
Node("signOnId", "f1f133112"),
Node("bannerId", Null())
}))}));
std::cout << root << std::endl;
auto root2 =
Node("test",
Sequence({
Node("name", "Herbert"),
Node("age", 55)}));
std::cout << root2 << std::endl;
struct Custom {
int id;
std::string name;
};
std::vector<Custom> vec = {
{12, "Johnny"}, { 344, "Filber"}, {999, "Jennifer"}
};
auto root3 =
Node("data", Sequence({
Node("customThings", vecToSeq(vec, [](const Custom& c) {
return Node("custom", Sequence({
Node("id", c.id),
Node("name", c.name)})); })),
Node("requestId", 232324)}));
std::cout << root3 << std::endl;
return 0;
}
view raw recursive_data_composition.cpp hosted with ❤ by GitHub

gist这个脚本嵌入非常优雅，方便写博客但是可能会有访问问题。所以后面还是会贴源码

还是magic_get/boost.pfr的技巧。温故知新一下。可能未来reflection就这么实现了

看这段代码

#include <numeric>
constexpr int naiveSum(unsigned int n) {
auto p = new int[n];
std::iota(p, p+n, 1);
auto tmp = std::accumulate(p, p+n, 0);
delete[] p;
// 如果这里注释掉delete，会报错
// error: '(naiveSum(10) == smartSum(10))' is not a constant expression because allocated storage has not been deallocated
// 4 | auto p = new int[n];
// 如果改成delete p也会报错
// error: non-array deallocation of object allocated with array allocation
return tmp;
}
constexpr int smartSum(unsigned int n) {
return (n*(1+n))/2;
}
int main() {
static_assert(naiveSum(10) == smartSum(10));
static_assert(naiveSum(11) == smartSum(11));
return 0;
}
view raw gistfile1.cpp hosted with ❤ by GitHub

这里的new会转到编译期检查！！

如果遗漏了delete会报错！

这样就可以写个非常安全的类了，有点像rust那种初级检查了，很不错

template <typename T>
class Buffer {
public:
    constexpr Buffer(size_t n) noexcept : size_(n), mem_(new T[n]) { }
    constexpr ~Buffer() noexcept { delete [] mem_; }

    constexpr Buffer(const Buffer& other) noexcept : size_(other.size_) {
          // ...
    }

    constexpr Buffer(Buffer&& other) noexcept {
        // ...
    }

    constexpr Buffer& operator=(const Buffer& other) noexcept {
        // ...
    }

    constexpr Buffer& operator=(Buffer&& other) noexcept {
        // ...
    }

    constexpr T& operator[](size_t id) noexcept { return mem_[id]; }
    constexpr const T& operator[](size_t id) const noexcept{ return mem_[id]; }

    constexpr T* data() const noexcept { return mem_; }
    constexpr size_t size() const noexcept { return size_; }

private:
    T *mem_ { nullptr };
    size_t size_ { 0 };
};

//使用
constexpr int naiveSumBuffer(unsigned int n) {
    Buffer<int> buf(n); // almost a vector class!
    std::iota(buf.data(), buf.data()+n, 1);
    return std::accumulate(buf.data(), buf.data()+n, 0);
}

缺点是constexpr相关的内存，别的操作不能直接用，只能拷贝

qsort在glibc2.13之前不是线程安全的。针对这个场景，作者讨论了一下glibc的修改方案

要注意这个坑，以及理解memory_barrier

就是这段代码

class iapi {
 public:
  virtual ~iapi() = default;
  virtual auto call() const -> int { return 42; }
};

class app_interface {
 public:
  constexpr explicit(true) app_interface(const iapi& api) : api_{api} {}
  auto run() const -> int { return api_.call(); }

 private:
  const iapi& api_;
};

template<class TApi>
class app_template {
 public:
  constexpr explicit(true) app_template(const TApi& api) : api_{api} {}
  auto run() const -> int { return api_.call(); }

 private:
  const TApi& api_;
};

template<class T>
concept api = requires(T t) {
  t.call();
};

template<api TApi>
class app_concept {
 public:
  constexpr explicit(true) app_concept(const TApi& api) : api_{api} {}
  auto run() const -> int { return api_.call(); }

 private:
  const TApi& api_;
};

int main() {
  // interface injection
  {
    struct : iapi {
      auto call() const -> int override { return 42; }
    } fake_api;
    app_interface app{fake_api};
    assert(42 == app.run());
  }

  // template injection
  {
    iapi api{};
    app_template app{api};
    assert(42 == app.run());
  }

  // concept injection
  {
    iapi api{};
    app_concept app{api};
    assert(42 == app.run());
  }
}

利用co_yield 来做generator，如果你了解python的yield，可以类比一下，概念是一样的

视频

考虑这段代码

struct base {
  virtual base* get() = 0;
};

struct derived : public base {
  virtual derived* get() {
    return &d;
  }
  derived d;
};

如果改成返回共享指针怎么修改接口？

已知std::shared_ptr<base>和std::shared_ptr<derived>完全是不同的类型，不能互相转, 下面这样写肯定编不过的

struct base {
  virtual std::shared_ptr<base> get() = 0;
};

struct derived : base {
  std::shared_ptr<derived> get() override{
    return d;
  }
  std::shared_ptr<derived> d;
};

通过引入一个转换层，实现统一的接口

template <typename Contained, typename Base=void> 
struct covariant_ptr : public covariant_ptr<Base, void>{
  std::shared_ptr<Contained> value;
};

// 给基类用的特化
template <typename Contained> 
struct covariant_ptr<Contained, void>{
};

struct base {
  virtual covariant_ptr<base> get() = 0;
};

struct derived : base {
  covariant_ptr<derived, base> get() override{
    return d;
  }
  covariant_ptr<derived, base> d;
};

讲静态检查的，非常长

讲嵌入式场景，作者实现了avr芯片上的libcxx

讲qt 测试的

问题

1 用discord还是飞书做讨论组？

主要需求

我之前调研发现discord支持webhook，所以使用discord，但是国内被屏蔽，登不上

现在发现飞书也支持，所以加上了飞书

哪种更通用一些？qq群微信群？据我了解qq不支持webhook通知，可能需要自己搞机器人。微信个人版不提供webhook

目前用qq频道。交流群基本半死不活。所以不折腾了.webhook我问腾讯的说2022年底支持，他妈的都2023了还不支持

飞书和discord用过一段时间，根本没人加。可能是传播广度不够或者没人用

2 代码片用gist托管还是直接贴出来？

gist可能被屏蔽，就看不到代码，但是比较好整理

直接贴链接。godbolt还好，如果挂了就再见了。没办法

欢迎讨论

本文永久链接

看到这里或许你有建议或者疑问或者指出错误，请留言评论! 多谢! 你的评论非常重要！也可以帮忙点赞收藏转发！多谢支持！ 觉得写的不错那就给点吧, 在线乞讨 微信转账
This site is open source. Improve this page.