Zebrafish's questions

我想从父进程启动一个可执行文件。等到该进程完成，然后读回它写入 stdout 的内容。事实证明，您不能等待程序完成然后读取 FILE* 流，因为等待它完成意味着调用 pclose(FILE*)，到那时文件流将被销毁。在 Windows 文档中，它说要这样做：

char psBuffer[128];
    FILE* pPipe;

    /* Run DIR so that it writes its output to a pipe. Open this
     * pipe with read text attribute so that we can read it
     * like a text file.
     */

    if ((pPipe = _popen("dir *.c /on /p", "rt")) == NULL)
    {
        exit(1);
    }

    /* Read pipe until end of file, or an error occurs. */

    while (fgets(psBuffer, 128, pPipe))
    {
        puts(psBuffer);
    }

    int endOfFileVal = feof(pPipe);
    int closeReturnVal = _pclose(pPipe);

    if (endOfFileVal)
    {
        printf("\nProcess returned %d\n", closeReturnVal);
    }
    else
    {
        printf("Error: Failed to read the pipe to the end.\n");
    }

它打开管道，然后立即从流中读取。由于读取是在启动子进程后立即执行的，所以它很可能会读取流，但流为空或到达文件末尾，这种情况不是吗？为什么这是有效的？

在我的直觉中，甚至经过一番思考之后，如果我想将一个规范化的浮点值转换回定点数，我会将其乘以定点格式能够容纳的最大值。所以乘以 255 或 65535，或其他什么。然而在某些情况下，我看到一些人或代码坚持认为正确的方法是乘以 255 - 1 或 65535 - 1。我不知道为什么会这样或为什么应该这样。这是为了处理溢出吗？我不知道如果将 1.0f * 255 相乘会发生什么不好的事情。即使 1.0f 不能在 IEEE 754 中完美表示并且乘法得出 255.0001，那么当将其转换为整数时它仍然为 255，没有溢出。

编辑：抱歉，我的问题中有两个错误。我的意思是 2 ^ bit_width - 1，而不是 bit_width ^ 2 - 1。这大概是正确的，因此对于 8 位整数，您需要乘以 255，对于 16 位整数，您需要乘以 65535。我的问题是，我很确定我见过乘以 255 - 1（即 254）的代码。有什么理由乘以 254 而不是 255？

我正在使用 usampler2D 在着色器中对 R16_UINT 图像进行采样。我这样做：

uvec4 upix_color = texture(usampler2D(utextures[nonuniformEXT(idx_of_height_map)], samplers[0]), result.uvs);

但看起来这些值并没有经过过滤/插值，如下图所示：

我知道 R16 灰度图像也可以是 R16_UNORM，在这种情况下它被读取为规范化浮点数，并且我知道整数可能更难插值，但 0 到 65,535 范围内的整数应该能够被插值。

如果我在变量旁边有一个减号，例如：

int a;
int b = -a; // UNARY OPERATOR
b = - a; // UNARY OPERATOR

'a' 之前的减号被视为一元运算符，并取 a 的负值。然而，在这个：

int a, b;
a -b; // SUBTRACTION
a - b; // SUBTRACTION

因此我由此推断：

1. 运算符和操作数之间是否有空格隔开是无关紧要的。
2. 判断它是减法还是一元运算符取决于前一个操作数的存在，并且与上下文高度相关。

有人可以简单总结一下编译器如何决定这一点的规则吗？

根据我听到的信息，如果你有一个如下变量：

inline int a_var;

或者

struct Foo
{
     static inline int a_var;
};

在头文件中并将该头包含在静态库 library2 中的某个位置，然后将其包含在库 Library2 中，然后每个库都会有该变量的副本。

所以我测试了一下。我制作了一个可执行文件并链接到静态库 1 和静态库 2。

我在一个公共头中的结构中声明一个变量：

struct MyStruct
{
    static inline int static_var = 0;
};

在我的可执行文件/main()中我执行：

void library_one_function();
void library_two_function();

#include "common_header.h"
#include <iostream>

int main()
{
    MyStruct::static_var = 1;
    std::cout << "Value from executable = " << MyStruct::static_var << "\n"; // I GET 1
    library_one_func(); // LIBRARY ONE FUNCTION CHANGES IT TO 7
    std::cout << "Value from executable = " << MyStruct::static_var << "\n"; // I GET 7
    library_two_function(); // LIBRARY TWO FUNCTION CHANGES IT TO 100
    std::cout << "Value from executable = " << MyStruct::static_var << "\n"; // I GET 100

}

每次我引用该变量时，都没有迹象表明每个库都有自己的副本。总是一样。那么为什么人们说内联变量有自己的副本呢？

Boostunordered_flat_map非常好，比 快得多std::unordered_map。我尝试将它与异构键类型一起使用：

boost::unordered::unordered_flat_map<std::string, int> my_map;
my_map.emplace(std::string("Hello"), 1);
my_map.find(std::string_view("Hello")); 
// no instance of overloaded function matches the argument list
            argument types are: (std::string_view)

现在，因为我创建了一个具有键类型 std::string 的映射，所以有一个接受 std::string 的 find 函数，但也有一个接受 K 的模板化 find 函数，并且通常这些东西应该在容器下工作：

1. 知道如何对异构类型进行哈希处理，并且
2. 知道一个将异构类型作为右侧的相等运算符。

即使我这样做：

auto equal_to = [](auto& lhs, auto& rhs) { return lhs == rhs; };

并将这个相等类传递给容器我仍然收到错误：

boost::unordered::unordered_flat_map<std::string, int, decltype(equal_to)> my_map;

我该如何让它工作呢？

我现在的做法是，据我所知，每个新图像都必须使用 LAYOUT_UNDEFINED 创建。然后我放置一个障碍将其转换为 TRANSFER_DST_OPTIMAL。现在我可以传输图像了。除非您想使用 LINEAR TILING，否则这至少是您要做的。

现在我需要将数据传输到缓冲区。在我的例子中，主机可见内存不是设备本地的，因此我将图像数据写入暂存缓冲区，然后发出缓冲区以进行图像复制并从 DST_SRC 转换为 READ_OPTIMAL。如果主机可见内存不是设备本地的，这是最有效的方法。

现在考虑主机可见内存也是设备本地的。我觉得我应该能够立即写入 GPU 设备本地缓冲区，但我不知道如何或甚至不知道是否可行，因为我认为您总是需要一个缓冲区来复制图像。对吗？

我尝试过：

#ifdef USE_CPP20_MODULES
#define IMPORT_OR_INCLUDE(module_name, include_filepath) \
import module_name;
#else
#define IMPORT_OR_INCLUDE(module_name, include_filepath) \
#include include_filepath
#endif

但是没有一个编译器可以编译它：

铛：

    Output of x86-64 clang 19.1.0 (Compiler #1)

<source>:6:2: error: '#' is not followed by a macro parameter
    6 | #include include_filepath
      |  ^

海湾合作委员会（GCC）：

<source>:5:56: error: '#' is not followed by a macro parameter
    5 | #define IMPORT_OR_INCLUDE(module_name, include_filepath) \

我不明白预处理器为何会失败。
我猜你不能将其用作#include宏的定义/替换？

假设我有一堆工作线程在等待，直到队列中有任务。
通常，您让生产者调用生产函数，然后notify_one工作线程就可以解除阻塞并继续。
但是，假设当生产者生产时，没有线程在等待condition_variable。生产者将通知，这将不执行任何操作。然后消费者到达和condition_variable，wait但它错过了之前的通知。
现在您在队列中有一个任务，直到生产者再次调用通知，此时队列中将有两个任务。

我的问题是，当有可用线程时，如何防止队列中有作业在等待？

例子：

struct ThreadPool
{
    static inline std::mutex mutex;
    static inline std::condition_variable condition_var;

    static inline int number_of_things_to_consume = 0;

    static void consume()
    {
        std::unique_lock lock{ mutex };

        /* THE WORKER THREAD COULD BE WAITING HERE WITH SOMETHING IN THE QUEUE
        - BECAUSE THE PRODUCER CALLED NOTIFY ONE BUT NO THREAD WAS WAITING YET */
        condition_var.wait(lock, []() {return number_of_things_to_consume > 0; });

        /* CONSUME */
    }

    static void produce()
    {
        std::unique_lock lock{ mutex };
        ++number_of_things_to_consume;
        condition_var.notify_one();
    }
};

我有一个组件注册表，用于注册组件（类/类型）。我成功地做到了，如果您尝试将其与未注册的类一起使用，系统将无法工作。但是，即使它只在一种注册表中注册过一次，它也可以与所有注册表一起使用，因为有：

template <typename T> static inline component_id;

它通过宏放置在类内部。

template <typename name>
struct ComponentRegistry
{
    using this_type = ComponentRegistry;

    template <typename component_t>
    static char register_new_component(const char* name)
    {
        static int counter = 0;
        component_t::template component_id<this_type> = counter++;
        /* REGISTER THE COMPONENT HERE*/
        
        return char(); /* ANYTHING. THE ONLY ONLY REASON THE DUMMY EXISTS IS TO TRIGGER THIS FUNCTION CALL ON PROGRAM INITIALIZATION */
    }
    template <typename component_t>
    int getComponentID()
    {
        /* IF THE COMPONENT WASN'T REGISTERED WITH ANY REGISTRY AT ALL, THEN THE template component_id DOESN'T EXIST AND SO IT WORKS
        - THE PROBLEM IS THAT EVEN IF IT WAS REGISTERED WITH ANOTHER REGISTRY THIS WILL STILL INSTANTIATE THE TEMPLATE
        - HOW DO I THROW A COMPILE ERROR? */
        return component_t::template component_id<this_type>; 
    }
};



#define REGISTER_COMPONENT_WITH_REGISTRY(comp_name, ecs_registry_type, comp_type) \
static inline char dummy_assignee_##ecs_registry_type = ecs_registry_type::register_new_component<comp_type>(comp_name); \
template <typename T> \
static inline int component_id;



struct ComponentRegistryName {}; // JUST USED TO DISTINGUISH. EACH TYPE CAN HAVE ITS OWN SET OF COMPONENTS

using ComponentRegistryType = ComponentRegistry<ComponentRegistryName>;

struct MyComponentType
{
    REGISTER_COMPONENT_WITH_REGISTRY("MyComponentTypeName", ComponentRegistryType, MyComponentType)

};

struct MyComponentType2
{
    /* NOT REGISTERED */
};

int main()
{
    ComponentRegistryType component_registry;

    component_registry.getComponentID<MyComponentType>(); // THIS SUCCEEDS BECAUSE IT WAS REGISTERED
    //component_registry.getComponentID<MyComponentType2>(); // THIS FAILS TO COMPILE BECAUSE THE COMPONENT WASN'T REGISTERED

}

这可以很好地检查组件是否已注册，因为如果没有注册：

但问题是，如果我想将组件注册到另一个注册表类型，就不再进行限制检查，因为当我这样做时：

component_t::template 组件 ID

根本不存在。但是，即使使用已注册到任何注册表的组件的模板参数调用 getComponentID，它也会成功。我希望使用可以作为成员检查的宏在类中放置一个 typedef，如果它存在，那么就很好了。

我知道所有编译文件（翻译单元）都会被编译为目标文件，然后链接器会通过查看这些目标文件来解析编译器在编译阶段找不到的符号。但这也是链接到静态库时发生的情况。那么链接到预编译的静态库和链接到目标文件有什么区别呢？我有一个大约 300k 行的 c 文件（sqlite），我想知道我是否应该将其编译为静态库，而不是仅将 c 文件作为编译单元传递给编译器。我知道在这两种情况下，编译器直到链接阶段才会“看到”该文件中的代码。我想有一次我在试验这些东西时，我看到了最终二进制大小的差异，但我不记得我是否正确设置了优化设置（即函数级链接 -ffunction-sections -fdata-sections）。

所以我从 NoIP 获得了我的域名，名字是 XYnet。所以当我获得域名时，它包含一个子域，对吗？因此，当您在一台物理主机上有多个 Web 服务时，我通常会看到人们使用子域来区分服务，并以此为基础路由到另一台服务器，但在这种情况下，映射到我的家庭 ISP 提供的 IP 的域名已经有一个子域（XYnet 中的 X）。那么我可以使用 Nginx 等反向代理来使用树中更深层的另一个子域来路由到不同的服务，例如 AXYnet 和 BXYnet 吗？

因为我从 NoIP 获得的域名是 XYnet，所以它是一个子域名，而不是域名，对吗？我的意思是，当 DNS 查找完成时，是 Y.net 映射到我的 IP 地址，而 X 子域名只是在您收到 HTTP 请求等时作为主机名附加到它，还是 DNS 查找将整个 (XYnet) 映射到我的 IP 地址？

在 ASIO C++ 网络库中，您可以通过创建查询对象来解析地址，该对象的构造函数接受（可选的是 ip4 或 ip6）、“主机”参数和“服务”参数。“主机”是您想要解析为 IP 号的站点的名称，“服务”（我猜）是端口号。所以这会执行 DNS 查找/请求，但我的理解是 DNS 查询用于查找名称和 IP 号码之间的关联，我根本不明白端口是如何参与其中的。

asio::ip::tcp::resolver::query query{"www.google.com", "80"};

更让我困惑的是，有一个“查询”构造函数只接受“服务”。评论给出了一点解释：

此构造函数通常用于执行本地服务绑定的名称解析

我不明白，我认为 DNS 查找严格用于（名称 -> IP 号码）映射。如果我解析端口 109 的名称，然后解析端口 400 的相同名称，我是否会得到相同的 IP 号码？

在类定义下方的函数定义中，根据 GCC 和 Clang，后两个“typename”不应该存在，但它可以在 Visual Studio 上编译。有人知道为什么吗？当 Visual Studio 在很多方面似乎不符合规范时，在不同的编译器上编译我的代码非常困难。

#include <iostream>

class BaseClass { };

/* CLASS DEFINITION */
template <typename getter_t, typename setter_t>
class MyClass : public BaseClass
{
public:

    using getter_return_t = int;
    void reset_value_to(const getter_return_t&, const char* to_append);
};


/* FUNCTION DEFINITION */
template <typename getter_t, typename setter_t>
void MyClass<typename getter_t, typename setter_t>::reset_value_to(const getter_return_t& value, const char* to_append)
{
    std::cout << "Yo";
}


int main()
{
    MyClass<int, int> c;
    c.reset_value_to(5, nullptr);
}

显然这是错误的，但它在 C++20 上的 Visual Studio 上编译，并且我已禁用语言扩展。我可以设置其他选项来使 Visual Studio 编译器更加一致吗？