小编ein*_*ica的帖子

C register关键字为编译器提供了一个提示,希望将变量存储在寄存器中,而不是存储在堆栈中.如果喜欢,编译器可以忽略它.我知道,当你打开优化编译时,它几乎没用了,但它完全没用吗？

更具体地说:对于{gcc,clang,msvc} x {-Og,-O,-O2,-O3}的任何组合:register在决定是否实际分配寄存器时会被忽略？如果没有,是否存在使用它有用的麻烦？

笔记:

• 我不是问关键字是否有效果 ; 当然它确实 - 它阻止你使用该变量的地址; 如果你根本没有进行优化,它将为变量的寄存器赋值或内存赋值之间的区别.
• 只有一个编译器/一些上述组合的答案是非常受欢迎的.

在使用nvprof分析应用程序时,我发现了两者PtoP和DtoDmemcpy.我不确定这两者之间的区别.

我malloc()出于某种原因包装.我希望有一些(系统特定的,运行时)信息,而不仅仅是调用它.例如:

• malloc()用于分配的最小对齐是什么？
• 在分配特定范围的内存时,它实际分配了多少(理论上这可能超过请求的数量)？
• 是否(假设没有其他并发操作)a realloc()将使用相同的原始地址成功或需要移动.

注意:我希望尽可能的方便,但特定于平台的答案仍然相关:Linux,Windows,MacOs,Un*x.

CUDA Runtime API 文档告诉我们，如果设备不支持优先级，则优先级范围可能是 0-0。但是 - 不同的设备实际上有不同的优先级范围吗？

我有一个函数foo通过引用获取参数,我希望它在rvalue和左值引用上采取不同的行为.(它不会改变引用的值,我可以添加)我知道如果我写:

template <typename T> foo(T&& x);

我已经声明了转发引用,而不是rvalue引用,这意味着:

template <typename T> foo(const T& x);
template <typename T> foo(T&& x);

可能不会得到我想要的东西.

所以,我的问题是:影响两种引用之间不同行为的正确方法是什么？

我在64位寄存器的低位部分有一个32位值；顶部部分是 0。让我们X用信息来表示一个位，并用从 LSB 到 MSB 列出的位来表示，如下所示：

X X X  ...  X 0 0 0 0 ... 0

现在，我想用信息“间隔”这些位，这样我就有了

X 0 X 0 X 0 ... X 0

（或者如果你想把 0 放在前面，那么

0 X 0 X 0 X 0 ... X

也很好。）

有什么快速的方法可以做到这一点？

与多 CPU 架构相关的答案会很好，但特定于 Intel x86_64 和/或 nVIDIA Pascal SM 的答案将是最相关的。

我有一个用RAII编写的Array类(为了这个例子的目的,超简化):

struct Array
{
    Array(int size) {
        m_size = size;
        m_data = new int[m_size];
    }

    ~Array() {
        delete[] m_data;
    }

    int* m_data = nullptr;
    int  m_size = 0;
};

然后我有一个函数,它接受一个数组的引用并对它进行一些操作.我使用临时数组temp来执行处理,因为有几个原因我不能直接使用引用.完成后,我想将数据从临时数据传输到真实数据:

void function(Array& array)
{
    Array temp(array.m_size * 2);

    // do heavy processing on `temp`...

    array.m_size = temp.m_size;
    array.m_data = temp.m_data;
}

显而易见的问题是temp在函数末尾超出范围:它的析构函数被触发,而后者又删除了内存.这种方式array将包含不存在的数据.

那么将数据所有权从一个对象"移动"到另一个对象的最佳方法是什么？

在CUDA中，我们不能抛出异常；但是 - 我们可以并且确实偶尔会遇到无法继续的异常情况，并且在主机上我们会抛出异常。

因此，作为第二好的，我们至少可以触发运行时错误以停止做不合理的工作并表明出现问题。

在 CUDA 内核中这样做有什么好处，它：

1. 不会导致未定义的行为
2. 一旦达到将停止内核执行
3. 不会触发编译器警告/错误

?

我想在我的 lambda 表达式中捕获一个本地指针。目前我的代码看起来像这样

MYButton* button;
button->onPress = [index,&](control*){
            button->foobar(x, y);
    };

我收到错误

错误：(835, 13) 变量“button”无法在未指定捕获默认值的 lambda 中隐式捕获

我的印象是&在捕获子句中使用意味着通过引用捕获本地范围内的所有内容。在这种情况下，为什么我会收到此错误？

我有一个指向由new操作员初始化的类的指针。然后，我使用此指针设置一个std::unique_ptr。现在，据我所知，以下代码具有双重删除功能：一次是手动调用delete运算符，然后是唯一指针超出范围。该代码如何“正确”运行，即没有运行时异常？

#include <iostream>
#include <memory>

class A
{
public:
    A()
    {
        std::cout<<"In A::A()\n";
    }
    ~A()
    {
        std::cout<<"In A::~A()\n";
    }
    void printMyStr()
    {
        std::cout<<"In A::printMyStr()\n";
    }
};

int main()
{
    std::cout<<"hello world!\n";
    A * pa = new A();
    std::unique_ptr<A> upa(pa);
    pa->printMyStr();
    upa->printMyStr();
    delete pa;  // How does this not create problems?
    return 0;
}

输出：

hello world!
In A::A()
In A::printMyStr()
In A::printMyStr()
In A::~A()
In A::~A()

显然，即使只创建了一个对象，析构函数也会运行两次。这怎么可能？

注意：我在64位linux上使用gcc 7.3.0。