ArrayのSliceをすると所有権を保持ができない

Question

Rustのチュートリアルを終えたばかりです。rustc 1.34.0-nightly

ArrayをスライスしVectorにpushする部分があります。
しかし返り値が保持されない為にエラーが発生します。

use sha2::{Sha512, Digest};
use bigint::U512;
use byteorder::{LittleEndian, WriteBytesExt};

const HASH_LENGTH: usize = 64;

fn generator(address: String, nonce: u32) ->Vec<&[u8]> {
    let vector_length = address.as_bytes().len() + 4 + HASH_LENGTH * 64;
    let mut seed = Vec::with_capacity(vector_length);
    // seed [address 40bytes]-[nonce 4bytes]
    seed.extend_from_slice(address.as_bytes());
    seed.write_u32::<LittleEndian>(nonce).unwrap();
    println!("vec={} seed={:?}", vector_length, seed.len());

    // appends [address 40bytes]-[nonce 4bytes]-[hash0]-...-[hash(HASH_LENGTH)]
    // [hashN] = SHA512([address 40bytes]-[nonce 4bytes]-[hash0]-...-[hash(N-1)])
    let mut hasher = Sha512::new();
    let mut hash_ints = Vec::with_capacity(HASH_LENGTH);
    for _ in 0..HASH_LENGTH {
        hasher.input(&seed);
        let hash = hasher.result_reset();
        let hash = hash.as_slice();
        seed.extend_from_slice(hash);
        hash_ints.push(U512::from(hash));
    }
    let final_int = U512::from(hasher.result().as_slice());
    println!("seed={} len={}", seed.len(), hash_ints.len());

    // all hash_ints XOR with final_int
    let xor_hash: Vec<U512> = hash_ints.iter().map( |int| *int ^ final_int).collect();
    println!("{:?} == {:?} ^ {:?}", xor_hash[4], hash_ints[4], final_int);

    // 動かない場所
    let mut outputs = Vec::with_capacity(HASH_LENGTH * 2);
    for int in &xor_hash {
        let mut bytes = [0u8; 64];
        int.to_little_endian(&mut bytes);
        let low = &bytes[..32];
        let high  = &bytes[32..];
        outputs.push(low);
        outputs.push(high);
        //outputs.push(bytes);
    }
    return outputs;
}

fn main() {
    let outputs = generator("Test string".to_string(), 123456);
    for i in &outputs {
        println!("{:x?}", i.to_ascii_lowercase());
    }
}

error[E0106]: missing lifetime specifier
 --> src\main.rs:7:49
  |
7 | fn generator(address: String, nonce: u32) ->Vec<&[u8]> {
  |                                                 ^ help: consider giving it an explicit bounded or 'static lifetime: `&'static`
  |
  = help: this function's return type contains a borrowed value with an elided lifetime, but the lifetime cannot be derived from the arguments

今度はライフタイム修飾子'staticを使用しました。しかし下記のｴﾗｰが目立ちます。
returns a value referencing data owned by the current function

ArrayのSliceの仕方が悪い為だと思いますが具体的な事がわかりませんでした。
どのようにすればよいのか解る方は回答をお願いします。

Answer 1

しかし返り値が保持されない為にエラーが発生します。

その通りです。スライス&[T]はポインタの一種で、参照先の値を所有しません。コード中のスライス&[u8]はgenerator関数内で作った固定長配列[u8; 64]を参照しています。しかしその固定長配列は generator関数を抜ける時に forループを回るごとに ライフタイムが尽きて破棄されます。関数から返されたスライスがダングリングポインタ（不正なアドレスまたは解放済みのアドレスを指すポインタ）になってしまうためにコンパイルエラーになるのです。つまりこのケースではスライスは返せません。

outputsにはスライスのような借用する値ではなく、所有する値であるVec<u8>か[u8; 32]を格納してください。たとえばVec<u8>なら以下のようになります。

fn generator(address: String, nonce: u32) ->Vec<Vec<u8>> {
    // ...
        let bytes = [0u8; 64];
        int.to_little_endian(&mut bytes);
        let low = (&bytes[..32]).to_vec();
        let high  = (&bytes[32..]).to_vec();

Comments

[tatsuya6502]

最初「関数を抜ける時にライフタイムが尽きて破棄されます」と書きましたが、Ekiさんがおっしゃっているとおり「forループを回るごとに...」が正しいですね。回答を修正しました。

[namuyan]

ループの途中でライフタイムが尽きるという感覚が次第にわかってきました。解答して頂き有難うございます。

Answer 2

結論

次のように Vec<Vec<u8>> を返すようにするとよいです。

fn generator(address: String, nonce: u32) -> Vec<Vec<u8>> {
    // ... 中略 ...
    let mut outputs = Vec::with_capacity(HASH_LENGTH * 2);
    for int in &xor_hash {
        let mut bytes = [0u8; 64];
        int.to_little_endian(&mut bytes);
        let low = bytes[..32].to_owned();
        let high = bytes[32..].to_owned();
        outputs.push(low);
        outputs.push(high);
        //outputs.push(bytes);
    }
}

理由

// 動かない場所
let mut outputs = Vec::with_capacity(HASH_LENGTH * 2);
for int in &xor_hash {
    let mut bytes = [0u8; 64];
    int.to_little_endian(&mut bytes);
    let low = &bytes[..32];
    let high  = &bytes[32..];
    outputs.push(low);
    outputs.push(high);
    //outputs.push(bytes);
}

まず bytes というのは、所有権が関数内に紐づいている変数です (スタック領域に確保されています) 。しかも for 文の中にいますので、 for ループの 一回分が終わるごとに消えてしまう 変数です。 low や high はこれに対する参照になっているので、そのようなものは関数を抜けるどころか for 文の一回のループが終わった時点でダングリングポインタということになります。 Rust はそういうことはさせず、エラーにします。

この例のように関数から結果を返したいときは、関数に依らず自分で所有権を持つデータ型を使う必要があります (つまりヒープ領域に確保するようなデータ型です) 。このようなデータ型の代表格としては、単一のものを扱う Box<T> と配列を扱う Vec<T> があります。この例では配列なので Vec<T> が最適です。

スライス [T] から Vec<T> へ変換する方法は、最初のコードのように slice.to_owned() を使うこともできますし、 Vec::from(slice) を使うことも、型が推論できる場合は slice.into() を使うこともできます。

Answer 3

やりたいことはエラーを解消するということで合っていますか？

&T はデータの参照であってデータそのものではないです。今回参照している bytes は関数内で作られ、関数を抜けると破棄されるのでその参照は返せません。参照ではなくデータそのものを返せば問題なくなります。例えば、 &[u8] ではなく Vec<u8> を使うとエラーは出なくなります。

use bigint::U512;
use byteorder::{LittleEndian, WriteBytesExt};
use sha2::{Digest, Sha512};

const HASH_LENGTH: usize = 64;
// 返り値を `Vec<Vec<u8>>` にする
fn generator(address: String, nonce: u32) -> Vec<Vec<u8>> {
    let vector_length = address.as_bytes().len() + 4 + HASH_LENGTH * 64;
    let mut seed = Vec::with_capacity(vector_length);
    // seed [address 40bytes]-[nonce 4bytes]
    seed.extend_from_slice(address.as_bytes());
    seed.write_u32::<LittleEndian>(nonce).unwrap();
    println!("vec={} seed={:?}", vector_length, seed.len());

    // appends [address 40bytes]-[nonce 4bytes]-[hash0]-...-[hash(HASH_LENGTH)]
    // [hashN] = SHA512([address 40bytes]-[nonce 4bytes]-[hash0]-...-[hash(N-1)])
    let mut hasher = Sha512::new();
    let mut hash_ints = Vec::with_capacity(HASH_LENGTH);
    for _ in 0..HASH_LENGTH {
        hasher.input(&seed);
        let hash = hasher.result_reset();
        let hash = hash.as_slice();
        seed.extend_from_slice(hash);
        hash_ints.push(U512::from(hash));
    }
    let final_int = U512::from(hasher.result().as_slice());
    println!("seed={} len={}", seed.len(), hash_ints.len());

    // all hash_ints XOR with final_int
    let xor_hash: Vec<U512> = hash_ints.iter().map(|int| *int ^ final_int).collect();
    println!("{:?} == {:?} ^ {:?}", xor_hash[4], hash_ints[4], final_int);

    // 動かない場所
    let mut outputs = Vec::with_capacity(HASH_LENGTH * 2);
    for int in &xor_hash {
        let mut bytes = [0u8; 64];
        int.to_little_endian(&mut bytes);
        // スライスではなくベクタを作る
        let low = bytes[..32].to_vec();
        let high = bytes[32..].to_vec();
        outputs.push(low);
        outputs.push(high);
        //outputs.push(bytes);
    }
    return outputs;
}

fn main() {
    let outputs = generator("Test string".to_string(), 123456);
    for i in &outputs {
        println!("{:x?}", i.to_ascii_lowercase());
    }
}

質問からは外れますが、質問の際は以下のことに気をつけていただけると回答がしやすくなります。

• そのコードで何をしようとしているのか書く
  • コンパイルエラーを取るだけなら複数のやり方があり得るので意図を書かないと正しい回答が得られるとは限らない
• cargoプロジェクトの場合、依存クレートの情報も載せる
  • 簡単にはCargo.tomlも貼る
• 出来る限り問題が起こる最小ケースで貼る
  • どこで困っているか分かりづらいですし、回答を見ても何を変えたのが重要なのか分かりづらいと思います。
• stableコンパイラ以外のコンパイラを使っている場合はその理由を書く
  • stableコンパイラがいわゆる普通のリリース版なので特別な事情なくnightlyを使うのは推奨されません。

Comments

[namuyan]

解答して頂き有難うございます。目標としているのはコンパイラーが出すエラーの意味を理解しコードを正常に動くよう修正する事です。これからは助言を参考にさせていただきます。