小编use*_*729的帖子

我试图理解 C++ 中的生命周期延长保证。有人可以解释为什么下面不同类型括号的使用在调用临时对象析构函数时会产生不同的结果吗？

#include <iostream>
struct X  {
    X() { 
        std::cout << __PRETTY_FUNCTION__ <<"\n";
    }
    ~X() {
        std::cout << __PRETTY_FUNCTION__ <<"\n";
    }
};

struct Y {
    X &&y;
};
int main() { 
    Y y1(X{});    
    std::cout << "Here1\n";
    Y y2{X{}};
    std::cout << "Here2\n";
}

输出

X::X()
X::~X()
Here1
X::X()
Here2
X::~X()

我想了解为什么unique_ptr析构函数要求类型在销毁时完整，而shared_ptr. Howard Hinnant 的这篇博客简要提到它与静态删除器和动态删除器有关。我正在寻找更详细的解释，解释为什么会出现这种情况（可能是编译器实现特定的，在这种情况下，示例会有所帮助）。使用动态删除器，它是否限制析构函数被内联？

有关虚拟成员函数与非虚拟函数的 ptr 的信息如何编码在函数指针内。显然，这取决于编译器，但我想了解用于编码此信息的技术。

#include <cassert>

struct X {
    virtual void f() {
    }
    void f1() {        
    }    
};

struct Y : X {
    void f() {
        assert(0); // does trigger
    }
};

int main() {
    auto ptr = &X::f;
    X *p = new Y();
    (p->*ptr)();   
}

我正在尝试使用 来分析给定进程中的多个线程perf。尽管下面的代码确实显示，即使ispid的参数（这应该导致对整个进程进行分析？），硬件计数器值仅对应于执行线程（与跨线程内的性能计数器求和）过程），但不被计算在内。perf_event_open0inf_loop

perf_event_open我的问题是：如何分析进程中的所有线程与仅分析如下执行的线程？是否perf_event_attr需要设置一些其他配置来启用进程范围的分析？

static long perf_event_open(struct perf_event_attr *hw_event, pid_t pid,
        int cpu, int group_fd, unsigned long flags)
{
    int ret;
    ret = syscall(__NR_perf_event_open, hw_event, pid, cpu,
            group_fd, flags);
    return ret;
}

static int fd;

void setup()
{
   struct perf_event_attr pe;
   memset(&pe, 0, sizeof(pe));
   pe.type     = PERF_TYPE_HARDWARE;
   pe.size     = sizeof(pe);
   pe.config   = PERF_COUNT_HW_INSTRUCTIONS;
   pe.disabled = 1;
   pe.exclude_kernel = 1;
   pe.exclude_hv     = 1;
   pid_t pid = 0;
   int cpu   = -1;
   fd …

我想了解为什么模板参数U默认为T下面的动机，即什么时候不从函数参数推导出来？

template<class T, class U = T>
  constexpr T exchange(T& obj, U&& new_val)
{
    T old_val = std::move(obj);
    obj = std::forward<U>(new_val);
    return old_val;
}

根据 CPP 参考，std::is_function可以按如下方式实现。有人可以解释为什么它有效，因为它似乎不直接寻址可调用对象？

template<class T>
struct is_function : std::integral_constant<
    bool,
    !std::is_const<const T>::value && !std::is_reference<T>::value
> {};

我试图理解declval<T>()和之间的区别declval<T&>()？有T&可以使用而T不能使用的例子吗？

#include <type_traits>
#include <utility>

struct X {
  X() = delete;
  int func();
};

int main()
{
// works with both X as well as X& within declval
  static_assert(std::is_same_v<decltype(std::declval<X&>().func()), int>);
}

对于下面渲染三角形的简单顶点着色器，什么时候mvpMatrix从 CPU 更新统一是安全的（使用glUniformMatrix4fv）？可以安全地假设在抽奖之后，例如glDrawArrays可以为下一次抽奖更新制服吗？或者是否有同步机制来确保更新不会在顶点着色器应用矩阵的中途发生MVP。

#version 330
layout (location=0) in vec3 vert
uniform mat4 mvpMatrix;

void main(void)
{
    gl_Position = mvpMatrix * vec4(vert, 1.0);
}

我想了解为什么完全限定std::结果会导致下面的编译错误，使用std::transform.

#include <algorithm>
int main() {
    std::string str;
    std::transform(str.begin(), str.end(), str.begin(), std::tolower); // does not compile

    std::transform(str.begin(), str.end(), str.begin(), ::tolower); // OK
}

无法推导一元运算符的错误。

source>: In function 'int main()':
<source>:4:19: error: no matching function for call to 'transform(std::__cxx11::basic_string<char>::iterator, std::__cxx11::basic_string<char>::iterator, std::__cxx11::basic_string<char>::iterator, <unresolved overloaded function type>)'
    4 |     std::transform(str.begin(), str.end(), str.begin(), std::tolower);
      |     ~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from /opt/compiler-explorer/gcc-11.2.0/include/c++/11.2.0/algorithm:62,
                 from <source>:1:
/opt/compiler-explorer/gcc-11.2.0/include/c++/11.2.0/bits/stl_algo.h:4285:5: note: candidate: 'template<class _IIter, class _OIter, class _UnaryOperation> constexpr _OIter std::transform(_IIter, _IIter, _OIter, _UnaryOperation)'
 4285 | …

我试图更好地理解 std::decay 的工作原理。根据 cppreference ，它应该从类型中删除 const 和 volatile 分类，作为它所做的其他转换的一部分。然而，下面的函数显示“False”、“True”与“True”、“True”，正如人们所期望的那样。有人可以澄清为什么在与此处的腐烂类型匹配时需要 const 吗？

int main()
{
   const char *p = "testing";
   cout << "------------------" << endl;
   cout << boolalpha << is_same<char *, decay_t<decltype(p)>>::value << endl;
   cout << boolalpha << is_same<const char *, decay_t<decltype(p)>>::value << endl;
   cout << "------------------" << endl;
}