在Rust中解释C声明

Question

I need to rewrite these C declarations in Go and Rust for a set of practice problems I am working on. I figured out the Go part, but I am having trouble with the Rust part. Any ideas or help to write these in Rust?

1. double *a[n];
2. double (*b)[n];
3. double (*c[n])();
4. double (*d())[n];

Answer 1

The answer depends on what, exactly, the * is for. For example, is the first one being used as an array of pointers to double s, or is it an array of arrays of double s? Are the pointers nullable or not?

Also, is n a constant or not? If it is, then you want an array; if it's not, you want a Vec .

Also also, are these global or local declarations? Are they function arguments? There's different syntax involved for each.

Frankly, without more context, it's impossible to answer this question with any accuracy. Instead, I will give you the following:

• The Rust documentation contains all the information you'll need, although it's spread out a bit. Check the reference and any appropriate-looking guides. The FFI Guide is probably worth looking at.

• cdecl is a website that will unpick C declarations if that's the part you're having difficulty with. Just note that you'll have to remove the semicolon and the n or it won't parse.

• The floating point types in Rust are f32 and f64 , depending on whether you're using float or double . Also, don't get caught: int in Rust is not equivalent to int in C. Prefer explicitly-sized types like i32 or u64 , or types from libc like c_int . int and uint should only be used with explicitly pointer-sized values.

• Normally, you'd write a reference to a T as &T or &mut T , depending on desired mutability (default in C is mutable, default in Rust is immutable ).

• If you want a nullable reference, use Option<&T> .

• If you are trying to use these in a context where you start getting complaints about needing "lifetimes"... well, you're just going to have to learn the language. At that point, simple translation isn't going to work very well.

• In Rust, array types are written as brackets around the element type. So an "array of double s" would be [f64] , an array of size n would be [f64, ..n] . Typically, however, the actual equivalent to, say, double[] in C would be &[f64] ; that is, a reference to an array, rather then the actual contents of the array.

• Use of "raw pointers" is heavily discouraged in Rust, and you cannot use them meaningfully outside of unsafe code. In terms of syntax, a pointer to T is *const T or *mut T , depending on whether it's a pointer to constant or mutable data.

• Function pointers are just written as fn (Args...) -> Result . So a function that takes nothing and returns a double would be fn () -> f64 .

Answer 2

Assuming n is a constant:

let a: [*mut f64, ..n];           // double *a[n];
let b: *mut [f64, ..n];           // double (*b)[n];
let c: [fn() -> f64, ..n];        // double (*c[n])();
fn d() -> *mut [f64, ..n];        // double (*d())[n];

These are rather awkward and unusual types in any language. Rust's syntax, however, makes these declarations a lot easier to read than C's syntax does.

Note that d in C is a function declaration. In Rust, external function declarations are only allowed in extern blocks (see the FFI guide ).