小编ein*_*ica的帖子

前提:

#include <iostream>
using namespace std;

class ABC {
 public:

   ABC() {
     cout << "Default constructor ..\n";
   }

   ABC(const ABC& a) {
     cout << "In copy constrcutor ..\n";
   }
   ABC(ABC&& aa) = delete;
};

int main(int argc, char* argv[]) {
  ABC b{ABC{}};
  return 0;
}

用GCC vs Clang编译它

Clang - Apple LLVM version 8.1.0 (clang-802.0.42)

Gcc - 5.4.0 ubuntu

观察 Clang抱怨删除了Move构造函数.

Gcc完全不抱怨.并将正确输出.

问题为什么？

对于gcc,我知道如果你只是初始化lvalue和rvalue,它会优化并且实际上不会调用复制构造函数并将临时值复制到左值.

为什么Clang有所不同？我认为(不确定,因此问题)这是在C++标准中,哪一个偏离(或不)？或者我做错了什么.

编译命令:g++ --std=c++11 -O3 file.cpp

为了更多的乐趣,删除花括号,并添加括号;)

ABC b{ABC{}};to,ABC b(ABC());与此问题无关. …

任务

给定n个金条,找到适合容量W的金的最大重量

输入

第一行包含背包的容量W和金条的数量n.下一行包含n个整数

产量

适合容量为W的背包的最大黄金重量.

约束

1 <= W <= 10000; 1 <= n <= 300; 0 <= w0,w1,w2,...,w(n-1)<= 100000

码

#include <iostream>
#include <vector>
using std::vector;

int optimal_weight(int W, vector<int> w) {
  int n = w.size() + 1;
  int wt = W + 1;
  int array [n][wt];
  int val = 0;

  for(int i = 0; i < wt; i++) array [0][i] = 0;
  for(int i = 0; i < n; i++) array …

我正在尝试使用OpenMP复制虚假共享的效果,正如Tim Mattson在OpenMP简介中所解释的那样.

我的程序执行简单的数值集成(参见数学细节的链接),我已经实现了两个版本,第一个应该是缓存友好的,每个线程保持一个局部变量来累积它的索引空间部分,

const auto num_slices = 100000000; 
const auto num_threads = 4;  // Swept from 1 to 9 threads
const auto slice_thickness = 1.0 / num_slices;
const auto slices_per_thread = num_slices / num_threads;

std::vector<double> partial_sums(num_threads);

#pragma omp parallel num_threads(num_threads)
{
  double local_buffer = 0;
  const auto thread_num = omp_get_thread_num();
  for(auto slice = slices_per_thread * thread_num; slice < slices_per_thread * (thread_num + 1); ++slice)
    local_buffer += func(slice * slice_thickness); // <-- Updates thread-exclusive buffer
  partial_sums[thread_num] = …

我正在查看有关C ++ 14语言扩展的isocpp.org常见问题解答，内容decltype(auto)如下：

...

注意： decltype(auto)如上所示，主要用于推导转发函数和类似包装的返回类型，在此情况下，您希望该类型精确“跟踪”正在调用的某些表达式。但是，除此以外，decltype（auto）并不打算被广泛使用。特别是，尽管它可以用来声明局部变量，但是这样做可能只是一个反模式，因为局部变量的引用性不应该依赖于初始化表达式。另外，它对如何编写return语句也很敏感。这两个函数具有不同的返回类型：

decltype(auto) look_up_a_string_1() { auto str = lookup1(); return str;  }
decltype(auto) look_up_a_string_2() { auto str = lookup1(); return(str); }

Run Code Online (Sandbox Code Playgroud)

第一个返回字符串，第二个返回字符串，string &它是对局部变量的引用str。

我的问题：示例中的返回类型是否应该相反，我的意思是，括号应该形成一个表达式，其类型应该是非引用（或右值引用）？并且没有括号，说的str意思是“左值引用str”。我错了吗？

告诉我，C ++ 11/14/17 中是否存在以下内容：

1）使用时间后缀设置时间

double time1 = 1s; // time1 = 1.0
double time2 = 2m; // time2 = 120.0
double time3 = 7ms; // time3 = 0.007 

2）获取设置后缀的时间字符串值

std::cout << getTime(time1); // cout 1s
std::cout << getTime(time2); // cout 2s
std::cout << getTime(time3); // cout 7ms

std::ostream有一个flush()方法：

将未提交的更改写入基础输出序列。

这对 a 意味着什么std::stringstream？如果我理解正确，这意味着对于这样的流没有什么可做的。这是真的？

考虑以下来自 CUDA 的Inline PTX Assebly指南 (v10.2) 的摘录：

编译器假定asm()语句除了更改输出操作数之外没有副作用。为确保在生成 PTX 期间不会删除或移动 asm，您应该使用 volatile 关键字，例如：

asm volatile ("mov.u32 %0, %%clock;" : "=r"(x));

Run Code Online (Sandbox Code Playgroud)

通常写入的任何内存都将被指定为输出操作数，但如果对用户内存有隐藏的副作用（例如，通过操作数间接访问内存位置），或者如果您想停止任何内存优化在生成 PTX 期间执行的 asm() 语句周围，您可以在第三个冒号后添加“内存”clobbers 规范...

这听起来像是两者 volatile，:: "memory"旨在表明内存中的副作用。现在，当然，可能存在非记忆副作用（例如 for trap;）。但是 - 当我使用 时volatile，也指定:: "memory")不是没用/没有意义吗？

_{稍微相关：当使用内联 PTX asm() 指令时，'volatile' 有什么作用？}

假设我有一个与设备关联的活动 CUDA 上下文i，我现在调用cudaSetDevice(i). 发生什么了？：

1. 没有？
2. 主上下文替换堆栈顶部？
3. 主要上下文被推入堆栈？

实际上似乎是不一致的。我写了这个程序，在一台机器上运行一个设备：

#include <cuda.h>
#include <cuda_runtime_api.h>
#include <cassert>
#include <iostream>

int main()
{
        CUcontext ctx1, primary;
        cuInit(0);
        auto status = cuCtxCreate(&ctx1, 0, 0);
        assert (status == (CUresult) cudaSuccess);
        cuCtxPushCurrent(ctx1);
        status = cudaSetDevice(0);
        assert (status == cudaSuccess);
        void* ptr1;
        void* ptr2;
        cudaMalloc(&ptr1, 1024);
        assert (status == cudaSuccess);
        cuCtxGetCurrent(&primary);
        assert (status == (CUresult) cudaSuccess);
        assert(primary != ctx1);
        status = cuCtxPushCurrent(ctx1);
        assert (status == (CUresult) cudaSuccess);
        cudaMalloc(&ptr2, 1024);
        assert (status == (CUresult) cudaSuccess); …

printf()当我们在没有格式说明符的情况下向它提供多个参数时，它的行为是什么？

例子：

int main() 
{
    printf("hello", "hi");
    return 0;
}

为什么编译器在编译上述程序时会产生警告？：

warning: too many arguments for format [-Wformat-extra-args]

如果我们编译如下类似的程序：

int main() 
{
    char *s1 = "hello";
    char *s2 = "hi";
    printf(s1, s2);
}

不产生警告。这是什么原因？

另外，为什么两个程序hello都只输出而不打印hi？

我习惯使用dl_open()库函数动态加载共享对象/DLL：

void *dlopen(const char *filename, int flags);

...并且这还运行 ELF 格式中标有 ; 的所有函数.init。或者在C/C++代码中，用 标记__attribute__((constructor))：

__attribute__((constructor)) 到底是如何工作的？

然而 - 我只能确定这可以使用 GCC 和 GNU/Linux（也许在任何glibc可用的地方）上工作。

我的问题是：我怎样才能以更便携的方式做同样的事情？我对向其他编译器和其他平台的可移植性感兴趣。

注意：我标记了这个 C++，因为这就是我正在使用的，但显然 C-ish 解决方案是可以接受的 - 因为我上面描述的是 C-ish 解决方案。