假设我有一个名为的结构体Particle，我想让它按 32 位对齐，alignas我在指定结构体定义时是否应该使用关键字，如下面的代码：
struct alignas(32) Particle {
// Total size: 16 bytes, but alignas(32) ensures 32-byte alignment
float x; // 4 bytes
float y; // 4 bytes
float z; // 4 bytes
float w; // 4 bytes
};
或者我应该在结构所在的布局定义中指定它，如下所示：
alignas(32) Particle particles[8]; // Array of 8 particles, 32-byte aligned
或者我应该两者都做？
在我的开发环境中，存在一个将标准输出写入特定文件的别名。
它使用带三通的管道，例如du -h | & tee /tmp/diskUsage。
我理解 AND 运算符会使其前面的内容成为文件描述符而不是文件名，比如2>&1我们将 stderr 重定向到 stdout，而不是当前目录中名为“1”的文件。
但是，对于用法来说| & tee，在'&'之后和“tee”之前没有任何有意义的内容，在这种情况下它起什么作用？
我最近正在学习一些 HPC 主题，并且了解到现代 C/C++ 编译器能够检测有权进行优化的地方，并使用相应的技术（如 SIMD、循环展开等）进行优化，尤其是在标志下-O3，在运行时性能与编译时间和目标文件大小之间进行权衡。
然后我立即想到 CPython 是即时解释和执行的，所以我认为它无法承担这些编译器功能，因为它的编译时间相当于运行时，所以我做了下面的一个玩具实验：
import time, random
n = 512
A = [[random.random() for _ in range(n)] for _ in range(n)]
B = [[random.random() for _ in range(n)] for _ in range(n)]
C = [[0] * n for _ in range(n)]
def matMul( A, B, C ):
""" C = A .* B """
for i in range(0, n - 4, 4):
for j in range(0, n - 4, 4):
for k in range(0, n - 4, 4):
C[i][j] = A[i][k] * B[k][j]
C[i + 1][j + 1] = A[i + 1][k + 1] * B[k + 1][j + 1]
C[i + 2][j + 2] = A[i + 2][k + 2] * B[k + 2][j + 2]
C[i + 3][j + 3] = A[i + 3][k + 3] * B[k + 3][j + 3]
C[i + 4][j + 4] = A[i + 4][k + 4] * B[k + 4][j + 4]
# return C
start = time.time()
matMul( A, B, C )
end = time.time()
print( f"Elapsed {end - start}" )
循环展开后，程序在 3 秒内完成，如果不展开，则需要将近 20 秒。
这是否意味着在编写 Python 代码时需要注意并手动实现这些 opt 技术？或者 Python 是否在任何特殊设置下提供优化？
我最近了解到 fork 甚至在寄存器上也应用 COW（写时复制）。
我玩了一个简单的玩具盒来验证：
(gdb) info inferiors
Num Description Connection Executable
* 1 process 59316 1 (native) /home/Drew/mycode/a.out
2 process 59386 1 (native) /home/Drew/mycode/a.out
(gdb) print( $rdi )
$1 = 18874385
(gdb) set $rdi=42
(gdb) print( $rdi )
$2 = 42
(gdb) inferior 2
[Switching to inferior 2 [process 59386] (/home/Drew/mycode/a.out)]
[Switching to thread 2.1 (process 59386)]
#0 0x00002aaaab090291 in fork () from /lib64/libc.so.6
(gdb) print( $rdi )
$3 = 18874385
正如你们看到的，修改父进程中的 rdi 不会干扰子进程。
我想知道它是怎么做到的？现代 CPU 是否专门为多进程提供多个相同的寄存器？
编辑：
感谢各位的评论。我会在这里集体回答评论中的问题，希望这有助于澄清。
我正在使用的参考资料是这份讲稿。
我一般想弄清楚：
我想知道为什么下面的代码打印“错误”。
double x = 0x8000000000000000;
signed long long v1 = (signed long long)(x);
signed long long v2 = *(signed long long *)(&x);
printf( v1 == v2? "correct\n" : "wrong\n" );
我尝试通过以下代码分别打印出 v1 和 v2 的二进制表示形式：
printf( "v1 = 0b" );
for ( int i = 63; i > 0; i-- ) {
printf( "%d", ( ( v1 >> i ) & 1 ) );
}
printf( "\n" );
printf( "v2 = 0b" );
for ( int i = 63; i > 0; i-- ) {
printf( "%d", ( ( v2 >> i ) & 1 ) );
}
printf( "\n" );
事实证明 v1 是正确的，但 v2 是0b010000111110000000000000000000000000000000000000000000000000000。
有谁能好心地告诉我这里发生了什么吗？
另外，我想知道 C 标准是否提供了任何打印出二进制或十六进制底层表示的方法，以便我的打印方案可以用一行函数调用来代替？
如果 nth 超出范围 [first, last)，我找不到任何与处理 std::nth_element(first, nth, last) 相关的官方定义。
为了弄清楚这一点，我对我的机器进行了一个玩具测试：
std::vector<int> arr{ 7, 3, 9, 6, 4 };
std::nth_element( arr.begin() + 1, arr.begin(), arr.end() );
for (int num : arr) {
printf("%d", num);
}
MSVC 在 vector 的 stl src 代码中给出断言失败，提示“vector iterator range transposed”。这是未定义的行为吗？
假设现在我已经为 unordered_set 准备好了 hash 和 equal 函数
auto equalFunc = [](...){...};
auto hashFunc = [](...){...};
如果单独使用 unordered_set，我知道我可以执行以下操作来指定我的 DIY 哈希和相等：
std::unordered_set<std::pair<int,int>, decltype( hashFunc ), decltype( equalFunc )> mySet( 0, hashFunc, equalFunc );
但是，现在假设 unordered_set 要用作 std::unordered_map 的值，我该如何指定哈希和相等？
std::unordered_map<int, std::unordered_set<std::pair<int,int>, decltype( hashFunc ), decltype( equalFunc )>> myMap( ...how? );
在 GDB 中我可以执行以下操作并获取字符串文字的地址：
(gdb) p &"aaa"
$3 = (char (*)[4]) 0x614c20
据我了解，字符串文字是一个没有绑定符号的右值，但为什么我可以获取它的地址？
这是什么样的地址？它是存储所有字符串文字的地方吗？但是字符串文字是无限的，这是否意味着字符串文字是按需“创建并放入内存”的？
假设我有一个任意容器，并询问其中是否有一个元素，如下所示。
D = {(1, 2): "whatever"}
if (2, 1) in D:
print( "Impossible" )
就底层代码而言，到底发生了什么？是否调用了任何特定的成员函数（例如 find()）？
此外，我可以使用定制的 cmp/hash 吗？比如说，如果我只想比较元组的键中每个数字的出现次数，如代码片段所示，我该怎么做才能实现呢？
D = {(1, 2, 1): "whatever"}
if (2, 1, 1) in D:
print( "As expected" ) # How to make it happen?
如果能提供一份官方的 Py 文档我将非常感激，我认为这是相当基础的信息，但在任何地方都找不到官方介绍。
在 Linux 中（不确定是否适用于 Windows，任何相关知识都值得赞赏），当只需要一小部分共享库时，使用一种名为延迟绑定的技术来提高性能，想象一下当您使用 -h --help arg 等调用程序时。
我想知道它是如何实现的？它是否与操作系统虚拟内存管理的惰性分配技术有关？即，不是将所有指令加载到内存中，而是首先进行到未映射内存的映射，并且仅在运行时真正需要/引用时才加载有效内存。