小编vbs*_*stb的帖子

使用有什么好处[[maybe_unused]]？考虑

int winmain(int instance, int /*prevInstance*/, const char */*cmdline*/, int show);

int winmain(int instance, [[maybe_unused]] int prevInstance, [[maybe_unused]] const char *cmdline, int show);

有些人可能会坚持使用评论是丑陋的,因为这个关键字是在这些情况下制作并打算使用的,我完全同意它,但maybe_unused关键字对我来说似乎有点太长,使得代码稍微难以阅读.

我想尽可能"严格"遵循标准,但值得使用吗？

struct X
{
    X() { std::cout << "default ctor" << std::endl; }

};

int main()
{
    X({});
}

打印出来

default ctor

这是有道理的,因为空括号值初始化对象(我认为).然而,

struct X
{
    X() { std::cout << "default ctor" << std::endl; }
    X(std::initializer_list<int>) { std::cout << "initializer list" << std::endl; }
};

int main()
{
    X({});
}

为此,我得到了

initializer list

我没有发现这种行为如此奇怪,但我并不完全相信.对此有什么规定？

这种行为是否写在标准的某些部分？

此代码在 C++ 中编译：

int x = 5;
int *const px = &x;
int *const *const ppx = &px;
int const *const *const cppx = ppx;

所以我尝试在 Rust 中做同样的事情：

let mut x: i32 = 5;
let px: &mut i32 = &mut x;
let ppx: &&mut i32 = &px;
let cppx: &&i32 = ppx;

但是，这无法编译：

error[E0308]: mismatched types
 --> src/main.rs:5:23
  |
5 |     let cppx: &&i32 = ppx;
  |               -----   ^^^ types differ in mutability
  |               |
  |               expected due to this …

当我尝试编译以下代码时：

struct A {
    void foo() & {
    }
};

int main()
{
    using F = void() &; // or 'typedef void F() &;'
    [[maybe_unused]] F A::*pf = &A::foo;
}

使用 clang 可以编译，但是使用 gcc 编译时会产生错误。

test.cc:9:37: error: cannot convert ‘void (A::*)() &’ to ‘void (A::*)()’ in initialization
    9 |     [[maybe_unused]] F A::*pf = &A::foo;

哪种行为是正确的？

我正在查看文档，发现了一个看起来不熟悉的示例代码。

std::cmp::Reverse - Rust

use std::cmp::Reverse;

let mut v = vec![1, 2, 3, 4, 5, 6];
v.sort_by_key(|&num| (num > 3, Reverse(num)));
assert_eq!(v, vec![3, 2, 1, 6, 5, 4]);

如何(num > 3, Reverse(num))定义它们之间的排序？

我查看了元组的文档，它说

元组的顺序性质适用于其各种特征的实现。例如，在 PartialOrd 和 Ord 中，元素按顺序进行比较，直到找到第一个不相等的集合。

这对于平等检查是有意义的，但在我看来，它没有解释如何>和<元组的作用。

我做了一些实验，但什么也没明白。

    println!("{}", (5, 5) > (3, 4)); // true
    println!("{}", (2, 2) > (3, 4)); // false
    println!("{}", (2, 5) > (3, 4)); // false
    println!("{}", (3, 5) > (3, 4)); // …

考虑一下这个

class Base { };

class Derived : public Base { };

Base *f1(Derived *) { return {}; }
Derived *f2(Derived *) { return {}; }   // covariant
Base *f3(Base *) { return {}; } // contravariant
Derived *f4(Base *) { return {}; } // covariant & contravariant

using Callback = Base *(*)(Derived *);

Callback pfunc1 = f1;   // works of course

// These won't work...
Callback pfunc2 = f2;
Callback pfunc3 = f3;
Callback pfunc4 = f4;


// So …