小编use*_*170的帖子

这两个循环在 C++ 和 Rust 中应该是等效的：

#include <cstdint>

std::uint64_t sum1(std::uint64_t n) {
    std::uint64_t sum = 0;
    for (std::uint64_t j = 0; j <= n; ++j) {
        sum += 1;
    }
    return sum;
}

pub fn sum1(num: u64) -> u64 {
    let mut sum: u64 = 0;
    for j in 0u64..=num {
        sum += 1;
    }
    return sum;
}

然而 C++ 版本生成一个非常简洁的汇编：

sum1(unsigned long):                               # @sum1(unsigned long)
        xor     eax, eax
.LBB0_1:                                # =>This Inner Loop Header: Depth=1
        add     rax, 1
        cmp     rax, …

如果 along int和 aint在平台上的表示相同，它们是否严格相同？根据 C 标准，这些类型在平台上的行为是否有任何不同？

例如。这是否总是有效：

int int_var;
long long_var;

void long_bar(long *l);
void int_bar(int *i);

void foo() 
{
    long_bar(&int_var); /* Always OK? */
    int_bar(&long_var);
}

我想同样的问题适用于 short 和 int，如果它们碰巧是相同的表示。

在讨论如何为int32_t没有 stdint.h 的嵌入式 C89 编译器定义一个-like typedef时出现了问题，即 as intorlong以及是否重要。

我有一个Animal带有虚拟析构函数的类和一个派生类Cat。

#include <iostream>

struct Animal
{
    Animal() { std::cout << "Animal constructor" << std::endl; }
    virtual ~Animal() { std::cout << "Animal destructor" << std::endl; }
};

struct Cat : public Animal
{
    Cat() { std::cout << "Cat constructor" << std::endl; }
    ~Cat() override { std::cout << "Cat destructor" << std::endl; }
};

int main()
{
    const Animal *j = new Cat[1];
    delete[] j;
}

这给出了输出：

动物构造函数
猫构造函数
动物析构函数

我不明白Cat当我的基类析构函数是虚拟的时，为什么不调用 的析构函数？

我在阅读 Avalonia 源代码时发现了这句话：

return new MenuFlyoutPresenter
{
    [!ItemsControl.ItemsProperty] = this[!ItemsProperty],
    [!ItemsControl.ItemTemplateProperty] = this[!ItemTemplateProperty]
};

我从未见过这样的语法。如果没有索引属性或 this[] 访问器，这些括号会做什么？如果它们引用的属性不是 bool，为什么它们会用感叹号否定？也许是某种空检查？

代码本身包含在以下 cs 文件中：

https://github.com/AvaloniaUI/Avalonia/blob/master/src/Avalonia.Controls/Flyouts/MenuFlyout.cs

我跟踪了代码，但无法理解该语法的作用。

我知道编译器通常是代码中错误的最后一个责任，但我没有看到对以下 C++ 代码的以下行为的任何其他解释（从实际项目中提炼出来）：

#include <iostream>
#include <map>

int main()
{
    auto values = { 1, 3, 5 };
    std::map<int, int> valMap;

    for (auto const & val : values) {
        std::cout << "before assignment: valMap.size() = " << valMap.size();
        valMap[val] = valMap.size();
        std::cout << " -> set valMap[" << val << "] to " << valMap[val] << "\n";
    }
}

该代码的预期输出是：

before assignment: valMap.size() = 0 -> set valMap[1] to 0
before assignment: valMap.size() = 1 -> set valMap[3] to 1 …

你能猜出这个简单程序的输出吗？

#include <vector>\n#include <string>\n#include <exception>\n#include <iostream>\n\nint main()\n{\n    try { \n        struct X {\n            explicit X(int) {}\n            X(std::string) {} // Just to confuse you more...\n        };\n        std::vector<X>{"a", "b"};\n    } catch (std::exception& x) {\n        std::cerr << x.what();\n    }\n}\n

好吧，我不能，这花了我一天的时间“研究”，然后才登陆这里，最终从一些复杂的现实生活代码中提取出来（到处都是类型别名，匿名。与非 POD 成员的联合以及手工 -精心策划的演员/导演等，只是为了营造氛围）。

而且……我还是看不出发生了什么！有人可以给一个温柔的提示吗？（希望只是一个盲点。我不再专业地从事 C++ 工作。）

注意：使用（最新的）MSVC/W4和 GCC进行干净编译* -Wall；两者的输出相同（语义上）。

_{* 即使没有“迷惑读者”这句话。我想我会做噩梦。}

（请耐心等待我尽量不将所有内容拼写得更多 \xe2\x80\x94 毕竟，这确实是不言自明的，对吧？除了，对我来说完全相反......）

众所周知，throw可以作为C++三元运算符的第二个或第三个操作数放置?:。但是它可以在操作数的逗号子表达式中吗？看起来编译器在这方面存在分歧。请考虑一个例子：

#include <iostream>

void foo(bool b) {
    int i = b ? 1 : (throw 0); //ok everywhere
    if ( !b )
        (std::cout << "smth\n", throw 0); //ok everywhere
    i = b ? 2 : (std::cout << "smth\n", throw 0); //ok in MSVC only
};

这个例子被 MSVC 接受，但被 GCC 和 Clang 拒绝，演示：https : //gcc.godbolt.org/z/6q46j5exP

虽然错误信息：

#include <iostream>

void foo(bool b) {
    int i = b ? 1 : (throw 0); //ok everywhere
    if ( !b …

嵌套的 for、while 和 if 语句的时间复杂度相同吗？假设a是一个长度为 的数组n。

for _ in range(len(a)):\n    for _ in range(len(a)):\n        do_something\n

上面的 for 语句的复杂度为 O(n\xc2\xb2)。

i = 0\nwhile i < len(a) * len(a):\n    do_something\n    i += 1\n

乍一看，上面的循环可以认为是 O(n)，但最终我认为也是 O(n\xc2\xb2)。

我对吗？

Perl 有一个未定义函数的概念。已声明但未定义的函数。

sub foo;
foo(); # Undefined subroutine error
bar(); # Undefined subroutine error

该函数foo现在存在于符号表中，可用于解析方法调用。但为什么这个“功能”会存在呢？在 C 中，这是因为函数是类型检查的，有时您希望在定义之前进行调用（例如解决循环依赖）。但 Perl 没有这样的功能，所有函数符号都是在运行时而不是编译时解析的。

• 如果是为了原型，那么如果没有原型，为什么还要存在未定义的函数呢？

• 如果它不是为了原型，它为什么存在？

• 为什么在方法解析中使用未定义的子例程？为什么不完全忽略它们——你不能调用它们，而且据我所知（最多）它们是内部实现细节？这就是为什么如果函数没有定义，我们就不能像它不存在一样继续方法解析（看起来不会那么混乱）。

该特征的文档Index说该方法返回对关联类型（link.index() ）的引用：Output

fn index(&self, index: Idx) -> &Self::Output;

对于Vec<T>和usize索引，Output是T。因此，我希望以下代码片段中的变量a具有类型&i32。

let v = vec![0];
let a = v[0];

然而， 的类型a是i32. 为什么？我正在学习 Rust，据我了解，Rust 要求你在任何地方都必须明确，并且从不value<->reference隐式执行转换。因此就有了这个问题。