小编Mar*_*son的帖子

请考虑以下代码段:

struct A
{
  auto foo(), bar();
};

auto A::foo() { return 1; }
auto A::bar() { return 'a'; }

int main()
{

}

它在Clang ++ 3.7.0中编译得很好.

它在G ++ 5.2.0中失败:

main.cpp: In member function 'auto A::bar()':
main.cpp:7:24: error: inconsistent deduction for 'auto': 'int' and then 'char'
auto A::bar() { return 'a'; }

自动返回类型推导是否强制在单个语句中声明的多个函数具有相同的返回类型？

我有以下String字符.

string s = "\\u0625\\u0647\\u0644";

当我打印上面的序列时,我得到:

\u0625\u0647\u062

如何获得真正可打印的Unicode字符而不是此\ uxxxx表示？

我找到了答案:

s = System.Text.RegularExpressions.Regex.Unescape(s);

C++ 03的显式模板的实例化定义和C++ 11的显式模板的实例化声明之间有什么区别？

我的意思是为什么实例化定义不足以阻止编译器为其他类型生成实现？下面的例子有什么问题:想象一下我将模板声明和定义分成两个单独的文件:

啊

#pragma once

template<typename T>
class A
{
public:
    A(T t);

private:
    T _t;
};

A.cpp

#include "A.h"

template<typename T>
A<T>::A(T t) : _t(t) {}

template class A<int>; // explicit instantiation

main.cpp中

#include "A.h"

int main()
{
    A<int> a(5); // fine, compiler generates header file,
                 // linker links with implementation from A.cpp file

    // A<float> b(3.14f); // linker error, as expected
}

上面的示例中是否有任何编译时间开销？如果我理解正确,在这种情况下,在单独的*.cpp文件中使用显式实例化定义(以及模板的实现),我使编译器无法使用任何其他类型隐式实例化模板.因此,为什么显式实例化声明有单独的语法？

如果我已经使用显式实例化定义隐藏了A.cpp文件中的实现,并且阻止编译器为其他类型生成主体,那么显式实例化声明如何加快编译时间."显式实例化声明"是否与"显式实例化定义"有某种关联,我的意思是我应该同时使用它们,还是这些是完全独立的特性(例如,只有在未使用显式实例化定义时才能使用显式实例化声明)？

我是否正确,明确的实例化定义只是在没有其他翻译单元使用给定类型实例化模板的情况下触发错误？

请考虑以下以下代码段:

template <class T>
using identity = T;

template <class T>
void foo(identity<T>&&) {}

int main()
{
  int i{};
  foo(i);
}

i是一个左值,因此如果foo声明一个转发引用参数,它应该编译.但是,如果identity<T>&&转为int&&,则应该引发错误.

该代码在GCC 6.0.0(演示)中编译.

代码无法在Clang 3.7.0(演示)中编译,并显示错误消息:

error: no known conversion from 'int' 
to 'identity<int> &&' (aka 'int &&') for 1st argument

哪一个是对的？

首先,请考虑以下代码:

#include <iostream>
#include <functional>

struct Noisy
{
  Noisy() { std::cout << "Noisy()" << std::endl; }
  Noisy(const Noisy&) { std::cout << "Noisy(const Noisy&)" << std::endl; }
  Noisy(Noisy&&) { std::cout << "Noisy(Noisy&&)" << std::endl; }
  ~Noisy() { std::cout << "~Noisy()" << std::endl; }
};

void foo(Noisy n)
{
  std::cout << "foo(Noisy)" << std::endl;
}

int main()
{
  Noisy n;
  std::function<void(Noisy)> f = foo;
  f(n);
}

以及它在不同编译器中的输出:

Visual C++ (现场直播)

Noisy()
Noisy(const Noisy&)
Noisy(Noisy&&)
foo(Noisy)
~Noisy()
~Noisy()
~Noisy()

Clang(libc ++)(见现场直播)

Noisy() …

在Segmentation Fault错误之后,是否可以恢复C程序的正常执行流程？

struct A {
    int x;
};
A* a = 0;

a->x = 123; // this is where segmentation violation occurs

// after handling the error I want to get back here:
printf("normal execution");
// the rest of my source code....

我想要一个类似于NullPointerException的机制,它存在于Java,C#等中.

注意:请不要告诉我C++中有一个异常处理机制,因为我知道,不要告诉我在分配之前我应该​​检查每个指针.

我真正想要实现的是恢复正常的执行流程,如上例所示.我知道可以使用POSIX信号进行一些操作.应该怎么样？其他想法？

我有一个*.dmp崩溃的应用程序的(转储)文件.现在,我想在另一台机器上分析崩溃的进程.也就是说,应用程序在一台机器上崩溃,我在其他机器上安装了Visual Studio.

现在,我需要什么才能看到堆栈跟踪和我的应用程序的所有符号？为*.exe文件和*.dmp文件是否足够？

或者我还需要源代码和PDB文件？

如果是这样,源代码和可执行文件是否应该放在与进程运行的机器上相同的目录结构中？

如何将PDB文件附加到Visual Studio中的崩溃转储文件？

TL; DR - GCC(trunk)是否已支持OpenMP 4.0卸载到nVidia GPU？

如果是这样,我做错了什么？(以下描述).

我正在运行Ubuntu 14.04.2 LTS.

我查看了最近的GCC主干(2015年3月25日).

我根据Ubuntu入门指南安装了CUDA 7.0工具包.CUDA样品成功运行,即检测到我的GeForce GT 730.deviceQuery

我已按照https://gcc.gnu.org/wiki/Offloading以及https://gcc.gnu.org/install/specific.html#nvptx-x-none中的说明进行操作

我已经安装了nvptx工具和nvptx-newlib(configure,make,sudo make install),newlib还与海湾合作委员会的后备箱目录内的链接ln -s.

然后我构建了目标加速器nvptx-none编译器:

../../trunk/configure --target=nvptx-none --enable-as-accelerator-for=x86_64-pc-linux-gnu --with-build-time-tools=/usr/local/nvptx-none/bin --disable-sjlj-exceptions --enable-newlib-io-long-long
make -j 9
sudo make install DESTDIR=/install

...和主机GCC编译器本身:

../trunk/configure --build=x86_64-pc-linux-gnu --host=x86_64-pc-linux-gnu --target=x86_64-pc-linux-gnu --enable-offload-targets=nvptx-none=/install/prefix --with-cuda-driver=/usr/local/cuda --enable-languages=c,c++
make -j 9
sudo make install DESTDIR=/install

我已相应地设置了LD_LIBRARY_PATH …

在阅读了如何使这些std :: function参数明确无误后,我完全糊涂了？到目前为止,我认为我理解函数模板的部分排序是什么,但在阅读了这个问题后,我写了三个例子来检查编译器的行为,并且收到的结果很难让我理解.

示例#1

template <class T>
void foo(T) {}

template <class T>
void foo(T&) {}

int main()
{
  int i;
  foo<int>(i); // error: call is ambiguous! 
}

问题:这两个功能都是可行的,这是显而易见的,但不是那个T&比专业更专业的功能T？相反,编译器会引发模糊的调用错误.

例#2

#include <iostream>

template <class T>
struct X {};

template <>
struct X<int> 
{
  X() {}
  X(X<int&> const&) {} // X<int> is constructible from X<int&>
  // note: this is not a copy constructor!
};

template <>
struct X<int&> …

我们来看看nVidia Fermi Compute Architecture.它说:

第一款基于Fermi的GPU采用30亿个晶体管实现,具有多达512个CUDA内核.CUDA核心为每个线程执行浮点或整数指令.512个CUDA内核由16个SM组成,每个内核32个内核.

[...]

每个CUDA处理器都有一个完全流水线的整数算术逻辑单元(ALU)和浮点单元(FPU).

[...]

在Fermi中,新设计的整数ALU支持所有指令的完整32位精度,符合标准编程语言要求.整数ALU也经过优化,可有效支持64位和扩展精度操作.V

据我所知,以及对我来说不清楚的是,GPU在所谓的warp中执行线程,每个warp由~32个线程组成.每个warp只分配给一个核心(是真的吗？).这是否意味着,单个SM的32个内核中的每一个都是SIMD处理器,其中一条指令处理32个数据部分？如果是这样,那么为什么我们说warp中有32个线程,而不是单个SIMD线程？为什么内核有时被称为标量处理器,而不是矢量处理器？