Que dois-je faire pour résoudre un “utilisation de déplacés valeur d'erreur”?

Je suis en train de calculer la 10,001 st le premier à Rust (Projet Euler 7), et comme une partie de cela, ma méthode pour vérifier si un entier est premier fait référence à un vecteur:

fn main() {
    let mut count: u32 = 1;
    let mut num: u64 = 1;
    let mut primes: Vec<u64> = Vec::new();
    primes.push(2);

    while count < 10001 {
        num += 2;
        if vectorIsPrime(num, primes) {
            count += 1;
            primes.push(num);
        }
    }
}

fn vectorIsPrime(num: u64, p: Vec<u64>) -> bool {
    for i in p {
        if num > i && num % i != 0 {
            return false;
        }
    }

    true
}

Quand j'essaie de référence du vecteur, j'obtiens l'erreur suivante:

error[E0382]: use of moved value: `primes`
 --> src/main.rs:9:31
  |
9 |         if vectorIsPrime(num, primes) {
  |                               ^^^^^^ value moved here, in previous iteration of loop
  |
  = note: move occurs because `primes` has type `std::vec::Vec<u64>`, which does not implement the `Copy` trait

Que dois-je faire pour primes afin d'être en mesure d'accéder à l'intérieur de la vectorIsPrime fonction?

InformationsquelleAutor mjkaufer | 2015-03-01
  1. 36

    Avec la définition actuelle de votre fonction vectorIsPrime(), la fonction spécifie qu'il nécessite de la propriété du paramètre parce que vous passer en valeur.

    Lorsqu'une fonction nécessite un paramètre par valeur, le compilateur se chargera de vérifier si la valeur peut être copié en vérifiant si elle met en œuvre le trait Copy.

    • Si c'est le cas, la valeur est copiée (avec un memcpy) et donnée à la fonction, et vous pouvez continuer à utiliser votre valeur d'origine.
    • Si elle ne le fait pas, alors la valeur est déplacé à la fonction donnée, et que l'appelant ne peut pas l'utiliser par la suite

    C'est le sens du message d'erreur que vous avez.

    Cependant, la plupart des fonctions ne nécessitent pas la propriété de l'paramètres: ils peuvent travailler sur le "emprunté références", ce qui signifie qu'ils ne possèdent pas réellement de la valeur (et ne peut pas par exemple le mettre dans un conteneur ou de la détruire).

    fn main() {
    let mut count: u32 = 1;
    let mut num: u64 = 1;
    let mut primes: Vec<u64> = Vec::new();
    primes.push(2);

    while count < 10001 {
        num += 2;
        if vector_is_prime(num, &primes) {
            count += 1;
            primes.push(num);
        }
    }
}

fn vector_is_prime(num: u64, p: &[u64]) -> bool {
    for &i in p {
        if num > i && num % i != 0 {
            return false;
        }
    }
    true
}

    La fonction vector_is_prime() précise maintenant qu'il a seulement besoin d'un tranche, c'est à dire un emprunt pointeur vers un tableau (y compris sa taille) que vous pouvez obtenir à partir d'un vecteur à l'aide de l'emprunter de l'opérateur &.

    Pour plus d'informations sur la propriété, je vous invite à lire la partie de l'ouvrage traite avec la propriété.

    • Pourquoi ne i dans for &i in p{ besoin d'un & en face de lui? Le code génère une erreur de compilation sans elle, et je suis curieux de savoir pourquoi.
    • cela signifie que i est une référence, et par conséquent, dans la boucle, je vais être la valeur, plutôt qu'une référence. si vous le laissez, vous auriez besoin d' *i quand on fait des comparaisons.
    InformationsquelleAutor Vaelden
  2. 33

    La rouille est, je dirais, une “valeur” axée sur la langue. Cela signifie que si vous définissez des nombres premiers comme ce

    let primes: Vec<u64> = …

    c'est pas une référence à un vecteur. Il est pratiquement une variable qui stocke un valeur de type Vec<u64> comme tout u64 variable stocke un u64 valeur. Cela signifie que si vous passez à une fonction définie comme ceci

    fn vec_is_prime(num: u64, vec: Vec<u64>) -> bool { … }

    la fonction sera d'obtenir son propre u64 valeur et de sa propre Vec<u64> valeur.

    La différence entre u64 et Vec<u64> cependant que l' u64 valeur peut être facilement copié à un autre endroit tout en un Vec<u64> valeur ne peut déplacer à un autre endroit facilement. Si vous voulez donner la vec_is_prime fonction de ses propres Vec<u64> valeur, tout en gardant un pour vous-même dans la principale, vous avez le reproduire, en quelque sorte. C'est ce qui est clone() est pour. La raison pour laquelle vous devez être explicite ici, c'est parce que cette opération n'est pas bon marché. C'est une belle chose à propos de la Rouille: Il n'est pas difficile de repérer des opérations coûteuses. Donc, vous pourrait appeler la fonction comme ceci

    if vec_is_prime(num, primes.clone()) { …

    mais ce n'est pas vraiment ce que vous voulez, en fait. La fonction n'a pas besoin de son propre Vec<64> valeur. Il a juste besoin de l'emprunter pour une courte durée. L'emprunt est beaucoup plus efficace et applicable dans ce cas:

    fn vec_is_prime(num: u64, vec: &Vec<u64>) -> bool { …

    Invoquant il exige maintenant que les “emprunts opérateur”:

    if vec_is_prime(num, &primes) { …

    Beaucoup mieux. Mais nous pouvons encore l'améliorer. Si une fonction veut emprunter un Vec<T> juste pour le but de la lecture, il est préférable de prendre un &[T] à la place:

    fn vec_is_prime(num: u64, vec: &[u64]) -> bool { …

    C'est juste plus général. Maintenant, vous pouvez prêter une certaine partie de la Cve, à la fonction ou tout autre chose (pas nécessairement un Vec, tant que ce quelque chose stocke ses valeurs consécutivement en mémoire, comme un statique de la table de recherche). Ce qui est aussi bien c'est qu'en raison encore de la contrainte des règles que vous n'avez pas besoin de modifier quoi que ce soit au site d'appel. Vous pouvez toujours appeler cette fonction avec &primes comme argument.

    Pour String et &str la situation est la même. String est pour stocker des valeurs de chaîne dans le sens qu'une variable de ce type possède cette valeur. &str est pour emprunter.

    • Un petit détail: Lors de l'itération, il semble que, comme @Vaelden écrit, la variable d'itération, i, doit être écrit &i.
    • C'est une possibilité, oui. Une autre serait de déréférencer i où vous l'utilisez.
    • Une itération sur un emprunt tranche vous donne emprunte des éléments. Faire autrement serait d'exiger le type de l'élément à être Copy ou Clone. Si vous utilisez &i dans la boucle for, i sera une copie d'un vecteur de l'élément.
    InformationsquelleAutor sellibitze
  3. 2

    Vous déplacer valeur de primes à la fonction vectorIsPrime (BTW Rouille utilisation snake_case par convention). Vous avez d'autres options, mais le mieux est d'emprunter de vecteur au lieu de la déplacer:

    fn vector_is_prime(num: u64, p: &Vec<u64>) -> bool { … }

    Et puis en passant référence:

    vector_is_prime(num, &primes)
    InformationsquelleAutor Hauleth