einpoklum's questions

我正在用 Rust 构建以下程序：

fn main() {
    println!("Hello, world!\n");
}

在 Devuan Excalibur 系统上（类似 Debian Trixie，但没有 systemd；rustc 版本 1.84）。构建后（使用cargo build --release），我有：

$ ldd target/release/hello
    linux-vdso.so.1 (0x00007fff356f5000)
    libgcc_s.so.1 => /lib/x86_64-linux-gnu/libgcc_s.so.1 (0x00007f0b073c5000)
    libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f0b071cf000)
    /lib64/ld-linux-x86-64.so.2 (0x00007f0b0749c000)

这有点奇怪，就像一个 hello-world C 程序一样：

#include <stdio.h>
int main() {
    printf("Hello world\n");
    return 0;
}

和 GCC 14.2（gcc -O3），我得到：

$ ldd hello
    linux-vdso.so.1 (0x00007fff1d573000)
    libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f8f1649f000)
    /lib64/ld-linux-x86-64.so.2 (0x00007f8f166e5000)

也就是说，没有libgcc_s依赖项。Rust 编译器在需要额外依赖项的可执行文件中放入了什么？为什么？

注意：我首先对可执行文件的大小差异感到疑惑；但这个问题已经解决了。

我正在编写一个 C++ 库，它处理包含一些时间值的数据 - 这些值不是源自运行该库的系统。我想将这些值放入 中std::chrono::time_point（将向库的用户公开）。

现在，要做到这一点，我需要指定一个Clock类型。好的，那应该不是问题，对吧？我可以满足所有的要求，不是吗？...嗯，不，不是真的，我有一个障碍：now()功能。我无法now()为生成我正在查看的时间点值的系统提供值！我无法访问它，也许它不再存在；它可能已经停止，或被重置，或完全不复存在。

这是否意味着我不应该使用std::chrono类型？或者我应该创建一个时钟类型，其now()函数返回一个固定的虚拟值？或者人为增加值？

在执行某个进程时，后续调用的结果是否会clGetPlatformIds()改变？例如，平台是否会消失、出现、改变顺序或改变句柄（“id”）？

我问的当然是 OpenCL 标准保证什么或要求什么。

在 CUDA 中，启动内核意味着指定其参数，通过指针数组进行编组：

CUresult cuLaunchKernel ( 
    CUfunction f, 
    /* launch config stuff */, 
    void** kernelParams,
    /* snip */ );

CUresult cuLaunchKernelEx ( 
    const CUlaunchConfig* config, 
    CUfunction f, 
    void** kernelParams, 
    /* snip */ ) ;

启动后 - 您仍然拥有指向参数值的指针数组，您可以用它做任何您想做的事情：再次启动，修改然后启动等等。

然而，在 OpenCL 中，内核参数是逐个设置的，并且不透明：

cl_int clSetKernelArg(
    cl_kernel kernel,
    cl_uint arg_index,
    size_t arg_size,
    const void* arg_value);

因此，您需要设置、设置、设置几次，然后启动内核（使用clEnqueueNDRangeKernel()）。有趣的是，它cl_kernel不仅仅代表一段设备端可执行代码，而是额外的状态，包括您设置的参数。

我的问题是：启动内核后，我可以对此状态和我设置的参数做出哪些假设？我可以假设一切都和启动前一样吗？我可以只更改一些参数，保留其余参数，以便再次启动同一个内核吗？或者 - 它们是否以某种方式失效/丢失，必须重新完全设置？...也许这取决于实现？

我想在 C 中可移植地使用 64 位有符号类型。但是 - 我知道int64_t不能保证定义。我可以在构建系统生成中使用一些预处理器魔法（例如 CMake 的check_type_size()）来获取预处理器定义，告诉我是否可以使用它。但是 - 我们确实有PRId64格式说明符，我们将使用它来将int64_t值传递给printf()类似函数。因此，我可以使用的定义PRId64作为确定是否int64_t可用的代理吗？

CMake 现在已经有一种称为“CMake 文件 API”的东西：

CMake 提供了一个基于文件的 API，客户端可以使用该 API 获取有关 CMake 生成的构建系统的语义信息。客户端可以通过将查询文件写入构建树中的特定位置来使用该 API，以请求零个或多个对象类型。当 CMake 在该构建树中生成构建系统时，它将读取查询文件并编写回复文件供客户端读取。

我不明白这个 API 应该何时使用，由谁使用。因此，我不明白，作为使用 CMake 的项目维护者，我是否需要担心这个 API 并“迎合”使用它来满足请求。我需要吗？

注意：如果答案取决于我维护哪种 CMake 项目 - 请选择几个示例（因为我在多种项目中使用 CMake）。

假设我有一个函数，它接受一些指针参数 - 一些非常量，可以通过它们写入，一些常量，只能通过它们读取。示例：

void f(int * a, int const *b);

还假设该函数不会以其他方式写入内存（即不使用全局变量，固定地址，将 const 指针重铸为非常量以及诸如此类的技巧）。

现在，是否足以（按照 C 语言标准）实现restrict内所有读取的好处f()，而仅restrict输出参数？即在示例中，限制a但不限制b？

一个简单的测试（GodBolt）表明这种限制应该足够了。此来源：

int f(int * restrict a, int const * b) {
    a[0] += b[0];
    return a[0] + b[0];
}

int all_restricted(int * restrict a, int const * restrict b) {
    a[0] += b[0];
    return a[0] + b[0];
}

int unrestricted(int * a, int const * b) {
    a[0] += b[0];
    return a[0] + b[0];
}

为 x86_64 生成相同的目标代码：

f:
        mov     eax, DWORD PTR [rsi]
        mov     edx, DWORD PTR [rdi]
        add     edx, eax
        mov     DWORD PTR [rdi], edx
        add     eax, edx
        ret
all_restricted:
        mov     eax, DWORD PTR [rsi]
        mov     edx, DWORD PTR [rdi]
        add     edx, eax
        mov     DWORD PTR [rdi], edx
        add     eax, edx
        ret
unrestricted:
        mov     eax, DWORD PTR [rsi]
        add     eax, DWORD PTR [rdi]
        mov     DWORD PTR [rdi], eax
        add     eax, DWORD PTR [rsi]
        ret

但这并非普遍的保证。

动机

数组参数可以互为别名，编译器必须小心考虑这种可能性。例如：GodBolt

int foo(int a[10], int b[10]) {
    a[0] += b[0];
    return a[0] + b[0];
}

int bar(int *a, int *b) {
    a[0] += b[0];
    return a[0] + b[0];
}

int baz(int * __restrict a, int * __restrict b) {
    a[0] += b[0];
    return a[0] + b[0];
}

的编译代码foo()必须与 的类似bar()，而不是 的类似baz()。

问题

我想在我的函数中使用数组参数 - 甚至可能是多维数组（不是指针数组；那种用一对方括号声明并衰减为指向第一个元素的简单一级指针的数组）。我还想让编译器假定没有别名，即我想将我的数组参数标记为restrict'ed。

我怎样才能用 C 语言做到这一点？如果我不能做到这一点 - 那是什么原因？

当将构造函数标记为已删除时，即

class MyClass {

   // ... 

   MyClass(int x) = delete;

   // ... 

};

将已删除的构造函数标记为 有什么影响吗explicit？即

   explicit MyClass(int x) = delete;

？

我正在使用 MSVC 16 2019，并打开了许多警告，包括 C4127：条件表达式是常量。但是，我的代码如下所示：

template <bool B>
void foo(int x) {
    if (B && x == 0) { do_stuff(); }
    do_other_stuff();
}

...当 B 为 false 时会触发警告。

我想一般保留此错误，但我不希望它在条件表达式的常量性仅由于模板实例化时无缘无故地发出警告。

注意：这个问题是相关的，但是 - 代码不会（显着）改变，所以这不是我要问的。C++17 中也没有。

考虑以下代码片段（改编自 cppreference.com）：

constexpr std::string_view text{"Hello-+-C++-+-23-+-!"};
constexpr std::string_view delim{"-+-"};
std::ranges::for_each(text | std::views::lazy_split(delim), act_on_substring);

我想对流做同样的事情 - 比如说std::cin- 而不是text. 我试过了：

auto isv = std::views::istream<std::string>(std::cin);
constexpr std::string_view delim{"-+-"};
std::ranges::for_each(isv | std::views::lazy_split(delim), act_on_substring);

但这段代码无法编译：

<source>:21:31: error: invalid operands to binary expression ('basic_istream_view<basic_string<char, char_traits<char>, allocator<char>>, char, char_traits<char>>' and '_Partial<_LazySplit, decay_t<const basic_string_view<char, char_traits<char>> &>>' (aka '_Partial<std::ranges::views::_LazySplit, std::basic_string_view<char, std::char_traits<char>>>'))
   21 |     std::ranges::for_each(isv | std::views::lazy_split(delim), act_on_substring);
      |                           ~~~ ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

为什么？