小编get*_*ubl的帖子

是否有任何规则可以以最有效的方式设置 unsynchronized_pool_resource 中块中的块数 (max_blocks_per_chunk) 和最大所需块 (largest_required_pool_block)？

如何避免不必要的内存分配？

例如，看看这个 演示。

如何尽可能减少分配次数？

我写了下面这段代码

#include <iostream>
const int N = 5;
class X
{
  public:
  int array[N];
  void foo()
  {
     std::cout << "array size:"<<sizeof(array)/N << std::endl;   
  }
  enum
 {
   N = 3    
  };
};

int main()
{
  X x;
  x.foo();
} 

上述代码不能与GCC一起编译:

<source>:13:8: error: declaration of 'N' [-fpermissive]
    N = 3
        ^
<source>:2:11: error: changes meaning of 'N' from 'const int N' [-fpermissive]
 const int N = 5;
           ^

从我在编译时的观点来看,数组被定义为一个包含五个整数的数组,N被定义为5.如何编译器解析变量的名称声明？

我正在研究C++17中的多态内存分配。我修改了一个使用 monotonic_buffer_resource 进行向量分配的示例，以使用synchronous_pool_resource。我发现了一种奇怪的行为。具体来说，有很多内存分配，只是为了向量中的两次加法。我没有运行基准测试，但我认为这对性能造成了巨大的损失

该程序是使用 O2 g++ -std=c++17 -O2 -Wall -pedantic编译的

下面是代码

class debug_resource : public std::pmr::memory_resource {

public:
    explicit debug_resource(std::string name,
        std::pmr::memory_resource* up = std::pmr::get_default_resource())
        : _name{ std::move(name) }, _upstream{ up }
    { }

    void* do_allocate(size_t bytes, size_t alignment) override {
        std::cout << _name << " do_allocate(): " << bytes << '\n';
        void* ret = _upstream->allocate(bytes, alignment);
        return ret;
    }
    void do_deallocate(void* ptr, size_t bytes, size_t alignment) override {
        std::cout << _name << " do_deallocate(): " << bytes << '\n'; …

我仔细阅读了本书的C ++模板独特之处，并尝试理解推论指南的std::array工作原理。关于标准的定义，以下是声明

template <class T, class... U>
array(T, U...) -> array<T, 1 + sizeof...(U)>;

例如，如果在主数组创建为

std::array a{42,45,77} 

扣除如何进行？

谢谢

跟进类似的问题以前的帖子关于向下转换和类型安全，不知下面的示例创建未定义的行为。

已创建 Base 类的实例。不会发生动态绑定。
但是，在 Base::interface 函数中， Base 类的实例被转换为 Derived 类的实例。这安全吗？如果是，为什么？请在下面找到一段代码。

#include <iostream>
template <typename Derived>
struct Base{
  void interface(){
    static_cast<Derived*>(this)->implementation();
  }
};

struct Derived1: Base<Derived1>{
  void implementation(){
    std::cout << "Implementation Derived1" << std::endl;
  }
};
        
int main(){
  
  std::cout << std::endl;
  Base<Derived1> d1;
  d1.interface();
  std::cout << std::endl;
}

我正在阅读一种用于在同一对象中存储左值或右值的技术。请在此处找到对此的描述 。重载技巧已实现。

然而，当定义重载结构体时，会定义一个加法重载构造函数，其中将 lambda 衰减时生成的函数指针作为参数传递

template<typename... Functions>
struct overload : Functions...
{
    using Functions::operator()...;
    overload(Functions... functions) : Functions(functions)... {}
};

为什么需要显式定义这个构造函数？

这里有一个现场演示。

使用cppinsights分析代码，上述代码的模板实例化如下

inline overload(__lambda_39_13 __functions0, __lambda_40_13 __functions1, __lambda_41_13 __functions2)
  : __lambda_39_13(__functions0)
  , __lambda_40_13(__functions1)
  , __lambda_41_13(__functions2)
  {
  }

我不清楚这个模板实例化是如何生成的。

使用显式自定义推导指南无法编译

看看下面修改后的演示

产生以下错误

:38:9: 错误: 没有匹配的函数来调用 'overload&) [with T = ...