Re: Rust vs Go

Sauf que du fait qu’il soit implémenté par le compilateur, le owned pointer de Rust est bien plus riche (tout en étant plus sûr) que le unique_ptr de C++.

Plus riche : en Rust je peux passer un owned pointer en argument d’une fonction (par exemple pour passer l’ownership à un objet qui le mettra dans ses attributs). En C++ c’est une erreur de compilation (unique_ptr(const unique_ptr&) = delete;).

Plus sûr : en C++ je peux faire une référence sur un owned pointer (int& j = *i) sans que le compilateur trouve quoi que ce soit à redire (donc tu peux même pas dire : unique_pointer et shared_ptr safe, il faut regarder méthode par méthode... une erreur est vite arrivée). En Rust aussi je peux faire une référence sur un owner pointer, mais le compilateur (vu que c’est implémenté dans le compilo et non dans la stdlib, c’est possible et c’est fait) vérifie que la référence ne vit pas plus longtemps que l’objet référencé et balance une erreur si c’est le cas.

Pire : ceci est syntaxiquement valide en C++, mais trivialement faux :

#include <memory>
#include <iostream>
void do_something(std::unique_ptr<int> i) {
}
int main() {
 std::unique_ptr<int> i(new int(1));
 do_something(std::move(i));
 std::cout << *i << std::endl;
 return 0;
}

Après, je n’ai pas fait de C++ « moderne », la seule connaissance que j’en ai ce sont les discussions sur ce fil :). Mais l’important reste qu’en utilisant uniquement des constructions soit-disant safe du langage (ou alors est-ce que std::move est considéré comme unsafe ? si oui ça limite quand même vachement l’intérêt de la chose), j’arrive à faire des constructions unsafe, ce que Rust m’empêche de faire.