小编Nic*_*ori的帖子

我正在使用一个外部库，它提供了一个用于自动代码生成的 CMake 函数，用于我的 CMakeLists.txt 文件。问题是，每当我修改 CMakeLists 时，该函数都会再次运行，从而触发重新编译新生成但未更改的源代码。我需要像 add_custom_command 这样的东西，可以将 CMake 函数指定为 COMMAND 而不是可执行文件，以便仅在自动生成的文件不存在时运行该函数。这可行吗？如果没有，是否存在另一种获得相同结果的方法？谢谢。

我std::unordered_map使用insertoremplace方法和移动语义填充了一个。当发生关键冲突时，元素不会插入到地图中，但移动的元素无论如何都会被删除：

#include <unordered_map>
#include <iostream>

int main(){
    std::unordered_map<int, std::string> m;
    m.insert(std::make_pair<int, std::string>(0, "test"));
    std::string s = "test";
    
    // try insert
    auto val = std::make_pair<int, std::string>(0, std::move(s));
    if(m.insert(std::move(val)).second){
        std::cout << "insert successful, ";
    }else{
        std::cout << "insert failed, ";
    }
    std::cout << "s: " << s << ", val.second: " << val.second <<  std::endl;
    
    // try emplace
    s = "test";
    if(m.emplace(0, std::move(s)).second){
        std::cout << "emplace successful, ";
    }else{
        std::cout << "emplace failed, ";
    }
    std::cout …

我有一个简单的结构,包含一个定义为char数组的字符串.我认为使用赋值运算符将结构的实例复制到另一个实例只会复制存储在char指针中的内存地址.相反,似乎复制了字符串内容.我把一个非常简单的例子放在一起:

#include <stdio.h>
#include <string.h>

struct Test{
  char str[20];
};

int main(){

  struct Test t1, t2;
  strcpy(t1.str, "Hello");
  strcpy(t2.str, "world");
  printf("t1: %s %p\n", t1.str, (char*)(t1.str));
  printf("t2: %s %p\n", t2.str, (char*)(t2.str));
  t2 = t1;
  printf("t2: %s %p\n", t2.str, (char*)(t2.str));
  return 0;
}

使用gcc 4.9.2编译此代码我得到:

t1: Hello 0x7fffb8fc9df0
t2: world 0x7fffb8fc9dd0
t2: Hello 0x7fffb8fc9dd0

据我所知,在t2 = t1t2.str指向它在赋值之前指向的相同内存地址之后,但是现在在该地址内部,在t1.str中找到了相同的字符串.所以在我看来,字符串内容已经自动从一个内存位置复制到另一个内存位置,这是我认为C不会做的事情.我认为这种行为是由于我将str声明为a char[]而非a char*.实际上,尝试直接将一个字符串分配给另一个字符串t2.str = t1.str会出现此错误:

Test.c: In function ‘main’:
Test.c:17:10: error: assignment to expression with array type
   t2.str = t1.str; …

我需要为我的类编写一个构造函数,它将两个std :: vector作为参数.这些向量必须在私有成员中复制,我想在我的用户传递临时或右值引用时使用移动语义,否则使用复制语义.这是一个常见问题,导致编写一个副本和一个移动构造函数来处理从同一个类的对象开始的构造.但在我的情况下,我从两个不同的参数(向量)开始构建,每个参数可以是左值或左值; 所以我必须处理四种不同的情况:

MyClass(const std:vector<float> &v1, const std::vector<float> &v2):
  _v1(v1), _v2(v2) {};
MyClass(const std:vector<float> &v1, std::vector<float> &&v2):
  _v1(v1), _v2(std::move(v2)) {};
MyClass(std:vector<float> &&v1, const std::vector<float> &v2):
  _v1(std::move(v1)), _v2(v2) {};
MyClass(std:vector<float> &&v1, std::vector<float> &&v2): 
  _v1(std::move(v1)), _v2(std::move(v2)) {};

每个都需要相同构造函数逻辑的小变化,类似代码片段的令人不快的增加.如果添加其他向量参数,事情会变得更加指数.处理这种情况的最佳做法是哪种？谢谢.

我需要生成一个长时间运行的子进程，然后从父代码中终止它。目前我确实喜欢这样：

int PID = fork();
if (PID == 0) {
  execl("myexec", "myexec", nullptr);
  perror("ERROR");
  exit(1);
}
// do something in between and then:
kill(PID, SIGKILL);

从子进程停止的意义上来说，它完成了这项工作，但随后它仍然是僵尸进程。我试图通过添加以下内容来完全删除它：

kill(getpid(), SIGCHLD);

无济于事。我一定做错了什么，但我不知道是什么，所以任何帮助将不胜感激。谢谢。