在 Python 中使用[]、使用()或不使用任何方式解包函数调用有什么区别？

def f():
    return 0, 1

a, b = f() # 1
[a, b] = f() # 2
(a, b) = f() # 3

在 C 中保持指针越界（不取消引用）以进行进一步的算术是否安全？

void f(int *array)
{
    int *i = array - 1;  // OOB

    while(...) {
        ++i;
        ...
    }
}

void g(int *array, int *end /* past-the-end pointer: OOB */)
{
    while(array != end) {
        ...
        ++array;
    }
}

我想象一些极端情况，如果地址是内存的第一个或最后一个......

一些 C++ hacks 使用转换运算符来获取有关构造函数的一些信息。我想知道，T在模板化转换运算符的解析中选择具体类型的过程是什么。

#include <iostream>
#include <type_traits>

using std::cout;
using std::endl;

struct A {
    A(int) { cout << "int" << endl; }
    A() { cout << "def" << endl; }
    A(const A&) { cout << "copy" << endl; }
    A(A&&) { cout << "move" << endl; }
};

struct B {
    template<typename T> operator T()
        { return {}; }
};

template<typename Except>
struct C {
    template<typename T,
             std::enable_if_t<!std::is_same_v<T, Except>>* = nullptr> operator T()
        { return {}; } …

我读过其他一些文章，这些文章move是不必要的，甚至对 NRVO 等机制进行了去优化。但在大多数情况下，这是关于当地领域的。

考虑这个例子：

\n
• 类在计算后存储临时字段。
\n
• 我想获取这个字段而不复制它（“消耗”它）。
\n

std::move在这种情况下，使用on是否合适return？\n具体来说，这些代码段是否等效？\n第二个更“通用”，让用户决定是否应该移动结果，第一个更严格\xe2\x80\x94 任何调用都会消耗结果。

选项1

\n// Option 1\n\n#include <utility>\n\ntemplate<typename T>\nclass TemporaryResultHolder\n{\npublic:\n    void doTask() { result = T(); }\n\n    T getResult() { return std::move(result); }\n    // Or return T&& ?\n\nprivate:\n    T result;\n};\n\nint main() {\n    TemporaryResultHolder<int> holder;\n    holder.doTask();\n    int res = holder.getResult();\n\n    return 0;\n}\n

选项2

\n// Option 2\n\n#include <utility>\n\ntemplate<typename T>\nclass TemporaryResultHolder\n{\npublic:\n    void doTask() { result = T(); }\n\n    T getResult() { …

如果我有一个值模板类

template<int... values>
class A {};

对于尾随 0 的不确定长度序列，我可以“轻松地”（没有模板递归）专门化它吗？

// Pseudo code
template<int... values>
class A<values..., 0...> {};

应该使用专用版本的示例（实际上应该最终匹配每个序列并带有零尾随 0）：

A<1, 0>{}; // use overloaded version with overloaded template values = <1>
A<1, 1>{}; // use with values=<1, 1>
A<1, 2, 3, 0, 0, 0>{}; // use with template values = <1, 2, 3>
A<1, 2, 3>{}; // use with values=<1, 2, 3>

我们可以使用,运算符一次声明多个函数吗？此代码在 gcc 上编译：

void f(), g();
void f() {}
void g() {}

int main() {
    f();
}

它是编译器的标准还是特殊性？

Rust 抱怨那场比赛并不详尽。这是 Rust 的限制还是我错过了什么？

fn main() {
  let x = 10;
  match x {
     1 => {},
     y if y < 1 => {},
     y if y > 1 => {}
  }
}

我有一个像素高度的不同灰度纹理，带有GL_LINEAR插值。纹理T(k)由从左到右k像素从0（黑）到255（白）的渐变组成。

例子 ：

T(2) = 0 255
T(3) = 0 128 255
T(4) = 0 85 170 255
T(256) = 0 1 2 ... 255

一些呈现的例子如下：

T(002)=

T(003)=

T(004)=

T(255)=

为什么纹理会有不同的结果？当使用更多像素时，渐变看起来排列得更好。

在实践中，如果我想要相同的结果，我不能使用更少的像素来渲染漂亮的渐变以节省内存。我认为“正确”的渐变是像素最多的渐变T(256)。

GCC 似乎总是按空格扩展源代码中的选项卡。它保留表达式内的空间。标准对此有何规定？

例如，c这个例子中将包含的内容（<TAB>代表\t源代码文件中的一个文字字符）。

#define X(a) #a

const char* c = X(<TAB>a<TAB>c<TAB>);
// c == "a c" ? (looks like what gcc does)
// c == "a\tc" ?