小编ide*_*n42的帖子

使用一个突破循环的宏工作,但我想传入一个标签,以便能够定义哪个外部循环突破.

将参数作为表达式传递给出了语法错误,我设法让它工作的唯一方法是传入一个block但是这不是很优雅,例如:

my_macro({ break 'outer; });

有没有办法通过:

my_macro('outer);

...这可以写在宏中,因为break $my_label;它扩展到break 'outer;？

是否可以声明一个元组结构，其中除声明外，出于所有意图和目的隐藏成员？

// usize isn't public since I don't want users to manipulate it directly
struct MyStruct(usize); 

// But now I can't initialize the struct using an argument to it.
let my_var = MyStruct(0xff)
//                    ^^^^
//                    How to make this work?

有没有一种方法可以使成员保持私有状态，但仍然允许使用上面的参数初始化新结构？

作为一种替代方法，MyStruct::new可以实现诸如之类的方法，但是我仍然想知道是否有可能避免在类型上使用方法，因为它更短，并且对于包装单个变量的类型来说很好。

背景

无需过多讨论细节，此类型的唯一目的是包装单个类型（隐藏一些细节，添加一些功能并在编译时进行完全优化的帮助器），在这种情况下，它并没有完全暴露出要使用的隐藏内部结构在Struct(value)风格初始化。此外，由于包装器的开销为零，因此使用new通常与分配/创建而不是强制转换相关联的方法会产生一些误导。

就像它是方便键入(int)v或int(v)，而不是int::new(v)一样，我想针对自己的类型进行此操作。

它经常使用，因此使用短表达式的功能非常方便。当前，我正在使用一个宏，该宏调用一个new方法，它的方法还可以，但是有点尴尬/间接，因此这个问题出现了。

编写API时,通常会有一个方法的可变和不可变版本.

我希望标准库有关于如何命名这些的明确约定,但它并不完全一致¹:

以下方法的命名约定有哪些？

pub fn foo****(&self) -> &Bar { ... }
pub fn foo****(&mut self) -> &mut Bar { ... }

• foo() | foo_mut()

  这似乎是最常见的,可以在Vec.iter和中看到Vec.iter_mut.

• foo_ref() | foo_mut()

  用于Any.downcast_ref和Any.downcast_mut.

似乎第一种情况更常见,那么_ref在命名API函数时使用后缀的原因是什么？

1:这可能是一致的,我只是没有注意到推理.

由于Rust尚不支持concat_identsstable,因此可能需要传入多个类似的标识符作为参数.

这允许意外传递错误的位置参数.

有没有办法检查标识符是否匹配一些基本规则,如"包含文本","以...开头","以...结尾"等.

struct_bitflag_flag_fn_impl!(
    MyStructType, my_struct_flag::SELECT,
    select_test, select_set, select_clear, select_set_bool, select_toggle);
struct_bitflag_flag_fn_impl!(
    MyStructType, my_struct_flag::HIDDEN,
    hidden_test, hidden_set, hidden_clear, hidden_toggle, hidden_set_bool);

//  Humans make mistakes, how to prevent?     ->  ^^^^^^         ^^^^^^^^
//  (arguments may be transposed by accident)

在分配内存并且已知它(几乎肯定/可能)长时间不使用的情况下,标记此内存以更积极地移动到交换空间可能是有用的.

是否有一些命令告诉内核这个？

如果不这样做,最好将这些文件转储到临时文件中,但我对发送到交换(或类似的东西)的能力感到好奇.

当然,如果没有交换空间,这将无能为力,在这种情况下,写入临时文件可能会更好.

我有一个宏,它需要2个参数,一个值被修改,并得到一个我必须投射的偏移量.

#define MY_MACRO(dst, src) \
    do_something((char *)dst + offset, (char * )src + offset)

在上面的示例中,dst将进行修改,但是如果值为const,则强制转换(char *)将隐藏此值.

但是,我不希望这个宏默默地隐藏const成员.

static void my_function(const float *a, const float *b)
{
    MY_MACRO(a, b);  /* <-- this should warn because 'a' is const */
}

我想知道是否有一种很好的方法可以确保宏中的变量不会隐藏const.

将示例解决方案移至自己的答案 - /sf/answers/1755107581/

我想知道在C中是否有某种方式来反省一种类型的最大值.

所以,比如我有一个变量叫a这是一个unsigned short...

{
    unsigned short a;
    long long max = TYPEOF_MAX(a);
    /* now max will be USHRT_MAX */
}

{
    signed char a;
    long long max = TYPEOF_MAX(a);
    /* now max will be CHAR_MAX */
}

哪个TYPEOF_MAX宏使用某种方法来获取基于类型的范围(这是静态的).

其他资格赛......

• 如果仅限于几种类型,则可以 char/short/int/long/long long/float/double
• 这可能需要使用一些C扩展,GCC或甚至C11,但更喜欢更便携的方法.

注:这是要生成的代码中使用,显然包括<lmits.h>使用USHRT_MAX,并CHAR_MAX在几乎所有情况下正常工作.

分配多个变量的常用方法通常在编程语言(如C或Python)中表示为:

a = b = c = value;

在Rust中是否有相同的功能,或者你需要写出来吗？

a = value;
b = value;
c = value;

如果这是显而易见的道歉,但我的所有搜索都会导致有关元组分配的问答.

是否可以在 Rust 宏中多次使用一个参数，只将参数实例化一次？

举这个简单的例子：

macro_rules! squared {
    ($x:expr) => {
        $x * $x
    }
}

虽然这有效，但如果调用 like squared!(some_function() + 1)，该函数将被多次调用。有没有办法避免这种情况？

非工作示例：

macro_rules! squared {
    ($x:expr) => {
        let y = $x;
        y * y
    }
}

给出编译错误：

 error: expected expression, found statement (`let`)

在Rust中,extern C函数可以在外部作用域中声明:

#[link(name = "some_lib")]
extern "C" {
    pub fn foo(path: *const c_char);
    pub fn bar(path: *const c_char);
    pub fn baz(path: *const c_char);
    pub fn fez(path: *const c_char);
}

虽然可以接受,但每个功能都需要直接访问foo() bar()...等.

是否可以使用公共前缀来访问它们？

封装如何工作的示例:

namespace some_lib {
    #[link(name = "some_lib")]
    extern "C" {
        pub fn foo(path: *const c_char);
        // ... etc ...
    }
}

fn some_rust_function() {
    unsafe {
        some_lib::foo();  // <-- example usage
    }

}

这样的事情可能吗？