RustとC ++は多くの点で似ていますが、さらに異なります。最も重要な違いのいくつかのリストは次のとおりです。

1）C ++はオブジェクト指向言語と見なされますが、錆は機能的なプログラミングの影響を伴う手続き言語に似ています。そのため、Rustには、継承など、C ++に見られる重要なオブジェクト指向の特徴がありません。Rustプログラムは、「特性」の概念とRustのより強力なマクロシステムの概念を使用して同様の利点を達成し、通常、継承のような種類のボイラープレート機能を排除するために使用されます。
2）Rustは、C ++よりもはるかに強力なマクロシステムを備えています。C ++マクロが単純なテキストの置き換えである場合、Rust Macrosはコンパイル時に実行され、抽象的構文ツリーを直接変更してコードを自動的に書き込む完全な錆プログラムです。錆びたマクロには、チューリング全体の完全な錆言語が利用可能であるため、錆のマクロとしての継承などの機能を失った機能を再実装することさえ可能です。
3）RustとC ++の両方が厳密なタイプシステムを持っていますが、C ++のタイプシステムは多かれ少なかれ、int、bool、charなどのマシンタイプの1から1つの翻訳です。「それはより複雑な関係をモデル化することができます。Rust型システムは、C ++よりもHaskellなどの機能的なプログラミング言語に似ています。Rustのいわゆる「表現型タイプ」を使用してドメイン情報をモデル化し、タイプシステムで悪い状態を表現できないようにすることでエラーを回避できます。コンパイル時間エラーになります。Rustには、C ++のような基本的なマシンタイプ（I32、F64、Boolなど）や代数タイプも含まれていることに注意する必要があります。代数タイプは強力であり、多くの利点を提供しますが、より複雑または混乱を招くと見なされ、書くのに時間がかかる可能性があります。このため、C ++のはるかにシンプルなタイプシステムを好む人もいます。
4）Rustには、C ++で表示されるような例外またはヌルタイプの概念がありません。代わりに、タイプシステムの明示的な値としてエラーをモデル化することを好みます。故障時にクラッシュするのではなく、故障する可能性のある錆関数は、結果<値、エラー>の値を返します。これは有効な値、またはエラーです。同様に、値を返す可能性がある場合と表示されない可能性がある場合は、nullになる可能性のある値ではなく、オプション<some（value）、none>を返します。これは、使用する前にオプションタイプから値を引き出すことを強制するという意味で、ヌルとは異なります。したがって、そうでないというケースを処理します。その結果、Rustのメモリ安全機能と組み合わせることで、パニックを呼び出すためにプログラムを手動でクラッシュさせたり、いわゆる「安全でない」コードを書いたりしない限りクラッシュするRustプログラムを作成することはほぼ不可能です。クラッシュするC関数を呼び出すと、Rustプログラムは引き続きクラッシュする可能性があります。
5）CとC ++は、生のポインターの操作に大きな重点を置いていますが、錆はメモリの安全性のためにあなたから離れたポインターの詳細を主に隠し、手動のポインター操作はほとんどありません。錆のポインターは「参照」と呼ばれ、実行時に「借り入れ」によって厳密に警察されています。一般に、これは、メモリが漏れ、自由なエラーの後の使用、ぶら下がっているポインター、およびセグフォルトなどのものが、まるでゴミ収集言語を使用しているかのように、錆の事実上の問題ではないことを意味します。また、同時のプログラミングがエラーが発生しやすくなり、人種条件が妨げられます。ただし、欠点は、多くの新しい錆ユーザーが、失敗する可能性のあるコードを書くことを妨げるため、「借入チェッカーと戦う」ことに気づくことです。また、錆の木、グラフ、リンクリストなどのポインターベースのデータストラクチャを作成するのがより困難になります。また、ボローチェッカーを手動でオフにし、Pointer算術などのこれらすべてを実行できる「安全でない」コードをRustで書くことも可能ですが、その場合、借りるチェッカーのメモリ安全上の利点を失います。
While Rust and C++ are similar in many ways, they differ in even more. Here is a list of some of the most important differences:

1) While C++ is considered an object oriented language, Rust is more similar to a procedural language, with functional programming influences. As such, Rust lacks essential object oriented features found in C++, such as inheritance. Rust programs achieve similar benefits using the concept of "traits" and Rust's more powerful macro system to avoid the kind of boilerplate features like inheritance are usually used to eliminate.
2) Rust features a much more powerful macro system than C++. Where C++ macros are a simple text replacement, Rust macros are full Rust programs that run at compile time and directly modify the Abstract Syntax Tree to write code automatically. As Rust macros have the entire turing complete Rust language available to them, it's even possible to re-implement missing features like inheritance as a macro in Rust.
3) While Rust and C++ both have strict type systems, the type system in C++ is more or less a one to one translation of machine types such int, bool, char etc., while Rust's type system is something called an "Algebraic Type System" that can model more complex relationships. The Rust type system is more similar to functional programming languages such as Haskell than it is to C++. Rust's so called "expressive types" can be used to model domain information, and avoid errors by making bad states unrepresentable in the type system, it becomes a compile time error. It should be noted that Rust also includes the basic machine types like C++ does (i32, f64, bool, etc), as well as the algebraic types. Algebraic types are powerful and offer many benefits, but may be considered more complicated or confusing and potentially take longer to write. Some people prefer C++'s much simpler type system for this reason.
4) Rust lacks the concept of an exception or a null type like you might see in C++, instead preferring to model errors as explicit values in the type system. A rather than crash on failure, a Rust function that might fail returns a value of Result<value, error>, which is either a valid value, or an error. Similarly, a function that might or might not return a value returns an Option<Some(value), None>, rather than a value that could be null. This is different from a null in the sense that it forces you to pull the value out of the option type before using it, therefore handling the case that it's None. As a result, in combination with Rust's memory safety features, it's nearly impossible to write a Rust program that crashes unless you either call the panic!() function to manually crash the program, or write so called "unsafe" code, eg, your Rust program can still crash if you were to call a C function that crashes.
5) While C and C++ put a large emphasis on manipulating raw pointers, Rust largely hides the details of pointers away from you for memory safety and features almost no manual pointer manipulation. Rust pointers are called "references", and they're strictly policed by the "borrow checker" at runtime. In general, this means that things like memory leaks, use after free errors, dangling pointers, and segfaults are virtually non-issues in Rust, as if you were using a garbage collected language. It also makes concurrent programming significantly less error prone, preventing race conditions. However, the downside is that many new Rust users find themselves "fighting the borrow checker" as it prevents them from writing code that might fail. It also makes more difficult to write pointer based datastructures such as trees, graphs, and linked lists in Rust. It is also possible to manually turn off the borrow checker and write "unsafe" code in Rust that allows you to do all these things, such as pointer arithmetic, but you lose the memory safety benefits of the borrow checker when you do so.