Zebrafish's questions

以下是 Vulkan Capability 查看器在我的计算机上显示的内容：

MEMORY HEAP 0
    DEVICE SIZE 8321499136
    FLAGS
        DEVICE_LOCAL_BIT
        MULTI_INSTANCE_BIT

    MEMORY TYPE 0
        DEVICE_LOCAL_BIT
    MEMORY TYPE 1
        DEVICE_LOCAL_BIT

MEMORY HEAP 1
    DEVICE SIZE 16760438784
    FLAGS
    NONE

    MEMORY TYPE 0
        HOST_VISIBLE_BIT
        HOST_COHERENT_BIT
    MEMORY TYPE 0
        HOST_VISIBLE_BIT
        HOST_COHERENT_BIT

堆 0 是我的 GPU 设备，有 8GB 内存。堆 1 应该是我的 CPU 内存。我的 CPU 内存是 32GB，在 Windows 的任务管理器中也显示为 32GB，但在 Vulkan 的内存堆描述中，只有一半（16GB）显示。我查找了原因，并在 Microsoft 页面上的“计算图形内存”页面中找到了：

在 VidMm 向客户端报告准确的数据之前，它必须首先计算显存的总量。VidMm 使用以下内存类型和公式来计算显存数量：

系统总内存

This value is the total amount of system memory accessible to the operating system. Memory that the BIOS allocates doesn't appear in this number. For example, a computer with a 1 GB DIMM (1,024 MB) that has a BIOS that reserves 1 MB of memory appears to have 1,023 MB of system memory.

可供图形使用的总系统内存

This value is the total amount of system memory that is dedicated or shared to the GPU. This number is calculated as follows:
C++ 

图形可用系统内存总量 = MAX((系统内存总量 / 2), 64MB)

链接在这里。

我在想这是为什么。你的内存只有一半可以同时使用 Vulkan 和 DirectX，或者图形 API？这显然是 VidMm 报告的。我不知道 VidMm 是什么，但 DirectX 或 Vulkan 都会参考这个来查看有多少可用内存，结果它总是报告只有一半的内存？

就我而言，我有一个 8GB 的​​独立显卡，报告显示内存正确，但系统内存显示只有实际内存的一半，也就是 32GB 除以 2。如果是核显会怎么样？设备只能使用系统内存的一半？也就是说只能使用一半的设备内存？这种情况只在 Windows 上出现，现在也出现在其他操作系统上了？

关于竞争条件发生的原因，给出的例子是，一个线程可能访问非最新版本的内存，因为另一个线程可能已经修改了它，或者正在同时修改它。因此，我们使用同步原语或原子变量来保护内存区域。我想知道的是，以下说法是否正确：

任何时候，当单个进程中有多个线程访问同一内存位置时，在任何情况下都必须明确同步。

我明确指的是像互斥锁、原子变量、屏障之类的东西。是这样吗？我之所以问这个问题，是因为当给出线程间同步的例子时，总是以线程在短时间内访问某个内存区域为例，而解释通常是“我们不知道线程 2 是否会看到线程 1 写入的值”。但是，请考虑以下情况：

int some_global_var = 0; // INITIALIZED BEFORE STARTUP

Thread 1:

some_global_var = 1;

Thread 2:

sleep_for(/* 5 days */);
print("%d", some_global_var);

这仍然是一种竞争条件，必须同步，对吧？换句话说，规则很简单，如果它被一个进程中的多个线程访问，没有“如果”、“并且”或“但是”，就必须使用原子变量或互斥锁？

解释如下：

Ccache 是一个编译器缓存。它通过缓存之前的编译并检测何时再次执行相同的编译来加快重新编译的速度。

我不明白。当我使用 Ninja 或 Makefile 之类的构建系统时，例如，当我修改源文件时，构建系统会记录哪些文件是哪些翻译单元的依赖项，并根据这些信息避免重新编译这些翻译单元，据我所知，我将其描述为缓存。另外，我注意到，当我修改一个翻译单元时，它不仅避免了将所有翻译单元重新编译成目标文件，而且不知何故（我不知道具体是怎么做到的）避免了将所有内容重新链接到可执行文件中。因此，在一个非常大的项目中，我可以修改翻译单元中的代码，重新编译，然后整个项目就可以在我的快速多核计算机上在 2 秒内再次执行了。

请问 ccache 在此基础上做了什么，用实际的具体例子解释一下，比如“它缓存了代码的 x、y、z 部分”。

我问了一个在线法学硕士，它说：

是的，绝对如此。即使构建调用依赖库中函数的静态库，也需要链接到依赖库。

但是我尝试构建一个调用另一个函数的静态库，我所做的只是包含头文件，然后调用该函数。它在 Linux 上使用 GCC 构建，没有任何关于未定义引用或其他问题的提示。

假设：

我的静态库：

#include "MyExternalFunction.h"

void my_static_library_function()
{
     MyExternalFunction();
}

上述编译过程顺利，编译器没有任何抱怨。

然后我创建一个可执行文件，主要内容：

void my_static_library_function();

int main()
{
    my_static_library_function();
    return 0;
}

我将主可执行文件链接到我的静态库（显然，因为我调用了它的函数），然后它抱怨 MyExternalFunction 未定义，因此可执行文件必须链接该函数，但静态库则不需要。因此，静态库不必链接它调用的函数。其他符号，比如变量呢？也一样吗？静态库不需要链接任何东西，它只需要声明？

我之所以问这个问题是因为我正在构建一个静态库（libcurl），我想知道该库是否只需要包含目录到 MBedTLS（ssl 库后端）才能进行编译。

这似乎只是一个小问题，我只需包含<cmath>wherestd::floor的使用方法即可解决，但这仍然很奇怪，我想知道是否有人知道发生了什么。我有一个项目，我可以在 MSVC、GCC 和 Clang 上使用 C++20 和 C++23 进行编译，没有问题。在 Android Studio 中，我可以使用 C++20 进行编译，但如果我在 CMake 配置中设置 C++20 标准，则会收到以下错误：

错误：命名空间“std”中没有名为“floor”的成员

我在需要的地方添加了<math.h>，这在其他所有构建配置中都运行良好。我认为数学包含<cmath>。无论如何，我也可以通过在需要的地方也添加 来消除错误<cmath>，但是为什么在使用 C++23 编译的 Android 中会发生这种情况？例如，我已经有：

#include <math.h>

使用 Android Studio 中的 C++23 我必须包含：

#include <cmath>

为了能够std::floor被识别。函数被注释掉了。看起来很奇怪。

所以我想设置 Rust 编译器使用的作业数量，我听说应该把它放在 config.toml 中。此外，config.toml 应该放在：

$CARGO_HOME/config.toml 默认为：

Windows: %USERPROFILE%\.cargo\config.toml
Unix: $HOME/.cargo/config.toml

我所拥有的最接近的东西是三个这样的文件名：

/home/myname/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/cfg-expr-0.15.8/.cargo/config.toml

不是那个吧？我的理解是，Cargo 会在当前目录中查找 config.toml 文件，然后递归向上搜索一个文件夹，直到到达根目录。我甚至不知道它在用什么，因为我没有看到名为 config.toml 的文件，而且系统范围的搜索只显示了我上面粘贴的内容。这个 config.toml 文件在哪里？其中两个 config.toml 文件非常小，设置了几个标志，然后 cfg-expr-0.15.8/.cargo 下的那个文件看起来像这样：

[target.'cfg(all())']
rustflags = [
    # BEGIN - Embark standard lints v6 for Rust 1.55+
    # do not change or add/remove here, but one can add exceptions after this section
    # for more info see: <https://github.com/EmbarkStudios/rust-ecosystem/issues/59>
    "-Dunsafe_code",
    "-Wclippy::all",
    "-Wclippy::await_holding_lock",
    "-Wclippy::char_lit_as_u8",
    "-Wclippy::checked_conversions",
    "-Wclippy::dbg_macro",
    "-Wclippy::debug_assert_with_mut_call",
    "-Wclippy::doc_markdown",
    "-Wclippy::empty_enum",
    "-Wclippy::enum_glob_use",
    "-Wclippy::exit",
    "-Wclippy::expl_impl_clone_on_copy",
    "-Wclippy::explicit_deref_methods",
    "-Wclippy::explicit_into_iter_loop",
    "-Wclippy::fallible_impl_from",
    "-Wclippy::filter_map_next",
    "-Wclippy::flat_map_option",
    "-Wclippy::float_cmp_const",
    "-Wclippy::fn_params_excessive_bools",
    "-Wclippy::from_iter_instead_of_collect",
    "-Wclippy::if_let_mutex",
    "-Wclippy::implicit_clone",
    "-Wclippy::imprecise_flops",
    "-Wclippy::inefficient_to_string",
    "-Wclippy::invalid_upcast_comparisons",
    "-Wclippy::large_digit_groups",
    "-Wclippy::large_stack_arrays",
    "-Wclippy::large_types_passed_by_value",
    "-Wclippy::let_unit_value",
    "-Wclippy::linkedlist",
    "-Wclippy::lossy_float_literal",
    "-Wclippy::macro_use_imports",
    "-Wclippy::manual_ok_or",
    "-Wclippy::map_err_ignore",
    "-Wclippy::map_flatten",
    "-Wclippy::map_unwrap_or",
    "-Wclippy::match_on_vec_items",
    "-Wclippy::match_same_arms",
    "-Wclippy::match_wild_err_arm",
    "-Wclippy::match_wildcard_for_single_variants",
    "-Wclippy::mem_forget",
    "-Wclippy::mismatched_target_os",
    "-Wclippy::missing_enforced_import_renames",
    "-Wclippy::mut_mut",
    "-Wclippy::mutex_integer",
    "-Wclippy::needless_borrow",
    "-Wclippy::needless_continue",
    "-Wclippy::needless_for_each",
    "-Wclippy::option_option",
    "-Wclippy::path_buf_push_overwrite",
    "-Wclippy::ptr_as_ptr",
    "-Wclippy::rc_mutex",
    "-Wclippy::ref_option_ref",
    "-Wclippy::rest_pat_in_fully_bound_structs",
    "-Wclippy::same_functions_in_if_condition",
    "-Wclippy::semicolon_if_nothing_returned",
    "-Wclippy::single_match_else",
    "-Wclippy::string_add_assign",
    "-Wclippy::string_add",
    "-Wclippy::string_lit_as_bytes",
    "-Wclippy::string_to_string",
    "-Wclippy::todo",
    "-Wclippy::trait_duplication_in_bounds",
    "-Wclippy::unimplemented",
    "-Wclippy::unnested_or_patterns",
    "-Wclippy::unused_self",
    "-Wclippy::useless_transmute",
    "-Wclippy::verbose_file_reads",
    "-Wclippy::zero_sized_map_values",
    "-Wfuture_incompatible",
    "-Wnonstandard_style",
    "-Wrust_2018_idioms",
    # END - Embark standard lints v6 for Rust 1.55+

编辑：好的，我发现 Cargo 还会查找名为“config”而没有“.toml”的文件，在我的 Cargo Home 中没有配置文件，只有一堆“config.yml”和“config.rs”，以及我提到的三个“config.toml”，但不在 Cargo Home 文件夹中，而是在一些冗长的路径中。

我知道变量/对象有内部和外部链接，但我不知道“类型”也有内部和外部链接。当我用 GCC 编译代码时，出现了以下警告：

'ShaderModuleObject' 有一个字段 'GFXAPIShaderModuleHandle ShaderModuleObject::handle'，其类型具有内部链接 [-Wsubobject-linkage]

这是代码，我将其粘贴到 Godbolt 中，但我没有看到相同的警告，或者即使 Godbolt 启用了警告：

#define GFX_API_NULL_HANDLE 0

template <typename T, void(*deleter)(T)>
struct MoveOnlyGFXAPIHandle
{
    MoveOnlyGFXAPIHandle() : handle(GFX_API_NULL_HANDLE) {}
    MoveOnlyGFXAPIHandle(T handle) : handle(handle) {}
    MoveOnlyGFXAPIHandle(const MoveOnlyGFXAPIHandle&) = delete;
    MoveOnlyGFXAPIHandle(MoveOnlyGFXAPIHandle&& other) : handle(other.handle) { other.handle = GFX_API_NULL_HANDLE; };
    MoveOnlyGFXAPIHandle& operator=(const MoveOnlyGFXAPIHandle&) = delete;
    MoveOnlyGFXAPIHandle& operator=(MoveOnlyGFXAPIHandle&& other)
    {
        this->reset();
        handle = other.handle;
        other.handle = GFX_API_NULL_HANDLE;

        return *this;
    }
    void reset() { 
        if (handle != GFX_API_NULL_HANDLE) 
        {
            deleter(this->handle); 
            handle = GFX_API_NULL_HANDLE; 
        }    
    }
    
    void assign(T handle) { reset(); this->handle = handle; }
    operator T() const { return handle; }

    T get() const { return handle; }
    ~MoveOnlyGFXAPIHandle() { 

        reset(); }
private:
    T handle;
};


using GFXAPIShaderModuleHandle = MoveOnlyGFXAPIHandle < int,
    +[](int handle) {

          //destroyShaderModule(handle);
    } > ;




struct ShaderModuleObject {

    GFXAPIShaderModuleHandle handle;
};


int main()
{

    ShaderModuleObject module_object;


    return 0;
}

什么是具有内部和外部链接的类型？为什么我的类型具有内部链接？为什么这是一件坏事，以至于 GCC 会发出警告？

当您将算法/函数/其他内容拆分为单独的线程运行时，假设我启动了 8 个线程，您不知道每个线程将在我的 8 个内核中的一个内核上运行，因为调度程序的工作是决定将哪些线程分配给哪些内核。不过，如果我有 8 个内核，并且我确实将作业拆分为 8 个线程，我几乎可以预料到会发生这种情况，我的 8 个内核中的每一个（大约）将承担八分之一的工作负载。对于具有 P 内核和 E 内核（性能和效率内核）的英特尔处理器，P 内核的时钟频率可能为 5.4Ghz，而 E 内核的时钟频率可能为 4.2Ghz。这种具有两种不同类型处理器的处理器是否会使多线程编程更加不可预测或更不受欢迎？两层系统在其他设备（如智能手机和 Apple CPU）中很常见，同样的问题也适用。作为一名程序员，你该如何解释这样一个事实：当你在不同的线程上运行某些东西时，比如你生成一个新线程，或者另一个线程在线程池中等待作业，它可能运行在性能核心或效率核心上？你有选择吗？

当我在调用 vkGetPhysicalDeviceFeatures 时给出要填写的扩展结构的指针时，rayTracingPipeline 标志为 1，这意味着它应该被支持，并且 VkPhysicalDeviceRayTracingPipelineFeaturesKHR 中的所有标志都设置为 1。但是，当我创建逻辑设备时，出现验证错误：

pCreateInfo->pNext 包含指向 VkPhysicalDeviceRayTracingPipelineFeaturesKHR 的指针，但是在创建 VkDevice 时，父扩展（VK_KHR_ray_tracing_pipeline）未包含在 ppEnabledExtensionNames 中。

公平地说，听起来我必须在创建逻辑设备时在启用的扩展列表中启用 VK_KHR_RAY_TRACING_PIPELINE_EXTENSION_NAME。所以我这样做了，但结果却出现了：

Vulkan 验证层回调：loader_validate_device_extensions：所选物理设备或启用的层不支持设备扩展 VK_KHR_ray_tracing_pipeline。

Vulkan 验证层回调：vkCreateDevice：无法验证列表中的扩展

当我使用 vkEnumerateDeviceExtensionProperties 检查扩展名时，它不在列表中。我正在使用 Radeon RX570。

我想从父进程启动一个可执行文件。等到该进程完成，然后读回它写入 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）。