{"id":2744,"date":"2022-04-03T15:25:40","date_gmt":"2022-04-03T09:55:40","guid":{"rendered":"https:\/\/www.rangakrish.com\/?p=2744"},"modified":"2022-04-03T15:25:40","modified_gmt":"2022-04-03T09:55:40","slug":"rust-trait-vs-c-abstract-class","status":"publish","type":"post","link":"https:\/\/www.rangakrish.com\/index.php\/2022\/04\/03\/rust-trait-vs-c-abstract-class\/","title":{"rendered":"Rust Trait vs. C++ Abstract Class"},"content":{"rendered":"

Traits<\/strong><\/em> in Rust<\/strong><\/em> are an amazing feature and contribute significantly to the expressive power of the language. For someone coming to Rust<\/strong><\/em> with a C++<\/strong><\/em> background (like me), Traits<\/strong><\/em> appear to be quite similar to Abstract Classes<\/strong><\/em> in C++. Although they are similar, Traits<\/strong><\/em> have certain characteristics that set them apart. In this article, I will try to compare the two and highlight the key differences.<\/p>\n

In order to keep the discussion simple and to the point, I will ignore “Generics” <\/strong><\/em>\u00a0in Rust (C++ Templates)<\/strong><\/em>.<\/p>\n

The first similarity is that both Traits<\/strong><\/em> and Abstract Classes<\/strong><\/em> cannot be instantiated directly. In that sense, we can say that both of them “prescribe”<\/strong><\/em> behavior, to be implemented by a conforming abstraction.<\/p>\n

Let us start with a simple example in Rust<\/strong><\/em>, where we define a “struct”<\/strong><\/em> and two “traits”<\/strong><\/em>.<\/p>\n

\"Rust<\/a>
Rust Example<\/strong><\/figcaption><\/figure>\n

Please note that “MyStruct”<\/strong><\/em> does not implement any of the two traits yet (we will do this a little later). Another interesting point to note is that it is possible to define methods (not just declare them) in Traits<\/strong><\/em>. When we run this code, here is what we get:<\/p>\n

\"Rust<\/a>
Rust Output<\/strong><\/figcaption><\/figure>\n

How can we implement similar functionality in C++<\/strong><\/em> using Abstract Classes<\/strong><\/em>? Pretty straightforward actually. Here is the code:<\/p>\n

\"C++<\/a>
C++ Example<\/strong><\/figcaption><\/figure>\n

Here also you can see that “MyStruct”<\/strong><\/em> does not (yet) use the two abstract classes “BaseTrait”<\/strong><\/em> and “DerivedTrait”<\/strong><\/em>. And, as in the case of “Traits”<\/strong><\/em>, it is possible to define methods in Abstract Classes<\/strong><\/em>. We get the following output when we run the program:<\/p>\n

\"C++<\/a>
C++ Output<\/strong><\/figcaption><\/figure>\n

It is easy to see that the outputs of the Rust<\/strong><\/em> and C++<\/strong><\/em> programs match so far.<\/p>\n

Let us move on to the next step. How do we take advantage of Traits<\/strong><\/em> in Rust<\/strong><\/em>? We know that Traits<\/strong> “prescribe”<\/strong><\/em> behavior, which some abstraction might implement. So, here is our example with “MyStruct”<\/strong><\/em> implementing both the Traits<\/strong><\/em>:<\/p>\n

\"Rust<\/a>
Rust – Updated Example<\/strong><\/figcaption><\/figure>\n

What you must take note of is that we did not change the original definition of “MyStruct”<\/strong><\/em><\/span>, but added the extra behaviors independently.\u00a0 <\/span>This is pretty cool!<\/p>\n

Here is the output from the modified program:<\/p>\n

\"Rust<\/a>
Rust – Output After Change<\/strong><\/figcaption><\/figure>\n

What about the C++<\/strong><\/em> example? The typical scenario (let us not get into Design Patterns<\/strong><\/em> here) is to derive “MyStruct”<\/strong><\/em> from “DerivedTrait”<\/strong><\/em> and implement the pure virtual methods “foo()”<\/strong> <\/em>and “bar()”<\/strong><\/em>. The modified version looks like this:<\/p>\n

\"C++<\/a>
C++ – Updated Program<\/strong><\/figcaption><\/figure>\n

The output from the program, in this case, will be:<\/p>\n

\"C++<\/a>
C++ – Output from Updated Program<\/strong><\/figcaption><\/figure>\n

The outputs from Rust<\/strong><\/em> and C++<\/strong><\/em> match this time too, confirming that the behaviors are the same.<\/p>\n

What is the main take-away from these two implementations? Which appeals to you more?<\/p>\n

My view is that declaring behaviors through Traits<\/strong><\/em> is more natural and flexible compared to doing the same through Abstract Classes<\/strong><\/em>. How so? As you can see from our example, “MyStruct”<\/strong> <\/em>can choose to take on additional behaviors without changing its original definition<\/span><\/em>. In the case of C++<\/strong><\/em>, we had to change the definition of “MyStruct”<\/strong><\/em> to derive from “DerivedTrait”<\/strong><\/em> to take on its behaviors. What if “MyStruct”<\/strong><\/em> has to also implement additional behaviors? Of course, since C++<\/strong><\/em> supports multiple inheritance, this might not be a problem, but you can see that the implementation can get a bit convoluted. Other approaches exist, for example, using a “Behavioral Design Pattern”<\/strong><\/em>, but that is beyond the scope of this article.<\/p>\n

In summary, I feel that Traits<\/strong><\/em> in Rust<\/strong><\/em> combine the benefits of C++ Abstract Classes<\/strong><\/em>, Java Interfaces<\/strong><\/em> and Lisp Mixins<\/strong><\/em>.<\/p>\n

You can download the C++<\/strong><\/em> and Rust<\/strong><\/em> source files from here<\/strong><\/em><\/a>. I used Visual Studio 2022<\/strong><\/em> for the C++<\/strong><\/em> example and Intellij CLion 2021.3<\/strong><\/em> for the Rust<\/strong><\/em> example.<\/p>\n

Have a nice weekend and a great week ahead!<\/p>\n","protected":false},"excerpt":{"rendered":"

Traits in Rust are an amazing feature and contribute significantly to the expressive power of the language. For someone coming to Rust with a C++ background (like me), Traits appear to be quite similar to Abstract Classes in C++. Although they are similar, Traits have certain characteristics that set them apart. In this article, I […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"advanced_seo_description":"","jetpack_seo_html_title":"","jetpack_seo_noindex":false,"_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":true,"jetpack_social_options":{"image_generator_settings":{"template":"highway","default_image_id":0,"font":"","enabled":false},"version":2},"jetpack_post_was_ever_published":false},"categories":[49,17,314],"tags":[315,67,317,316],"class_list":["post-2744","post","type-post","status-publish","format-standard","hentry","category-c","category-programming","category-rust","tag-abstract-class","tag-c","tag-rust","tag-trait"],"jetpack_publicize_connections":[],"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"jetpack_shortlink":"https:\/\/wp.me\/p9OLnF-Ig","jetpack-related-posts":[{"id":1973,"url":"https:\/\/www.rangakrish.com\/index.php\/2020\/04\/26\/stdis_base_of\/","url_meta":{"origin":2744,"position":0},"title":"std::is_base_of","author":"admin","date":"April 26, 2020","format":false,"excerpt":"In our on-going series on C++ Type Traits, today's topic is about the trait std::is_base_of<>. For the official description, see this. std::is_base_of::value takes two arguments, both classes (or structs), and returns true if A is a base class of B and false otherwise. Trivially, std::::value is true. Let\u2026","rel":"","context":"In "C++"","block_context":{"text":"C++","link":"https:\/\/www.rangakrish.com\/index.php\/category\/c\/"},"img":{"alt_text":"Output","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2020\/04\/Output.jpg?resize=350%2C200&ssl=1","width":350,"height":200},"classes":[]},{"id":2789,"url":"https:\/\/www.rangakrish.com\/index.php\/2022\/05\/04\/using-dll-functions-in-rust\/","url_meta":{"origin":2744,"position":1},"title":"Using DLL Functions in Rust","author":"admin","date":"May 4, 2022","format":false,"excerpt":"When you program in Rust, especially in a non-trivial project, there is a good chance that you will need to call \"external\" functions (usually, C\/C++) that are available in a DLL (we are talking about the Windows platform here). It could be because you wish to re-use some code that\u2026","rel":"","context":"In "C++"","block_context":{"text":"C++","link":"https:\/\/www.rangakrish.com\/index.php\/category\/c\/"},"img":{"alt_text":"New DLL Project","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2022\/05\/DLL-Project-300x211.jpg?resize=350%2C200&ssl=1","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2022\/05\/DLL-Project-300x211.jpg?resize=350%2C200&ssl=1 1x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2022\/05\/DLL-Project-300x211.jpg?resize=525%2C300&ssl=1 1.5x"},"classes":[]},{"id":2024,"url":"https:\/\/www.rangakrish.com\/index.php\/2020\/06\/21\/stdis_standard_layout\/","url_meta":{"origin":2744,"position":2},"title":"std::is_standard_layout","author":"admin","date":"June 21, 2020","format":false,"excerpt":"In our last post, we learnt about the type trait std::is_trivial. Today, let us go through another type trait that is quite similar. The expression\u00a0is_standard_layout::value returns true if the layout of objects of type T is compiler independent, and hence is of standard format. Else, it returns false. This is\u2026","rel":"","context":"In "C++"","block_context":{"text":"C++","link":"https:\/\/www.rangakrish.com\/index.php\/category\/c\/"},"img":{"alt_text":"The Difference","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2020\/06\/Example4.jpg?resize=350%2C200&ssl=1","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2020\/06\/Example4.jpg?resize=350%2C200&ssl=1 1x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2020\/06\/Example4.jpg?resize=525%2C300&ssl=1 1.5x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2020\/06\/Example4.jpg?resize=700%2C400&ssl=1 2x"},"classes":[]},{"id":293,"url":"https:\/\/www.rangakrish.com\/index.php\/2016\/08\/07\/is-deriving-from-a-concrete-class-bad\/","url_meta":{"origin":2744,"position":3},"title":"Is Deriving from a Concrete Class Bad?","author":"admin","date":"August 7, 2016","format":false,"excerpt":"In my first post on Julia, I noted that the language does not allow deriving from a concrete (i.e., non-abstract) class. It definitely came as a surprise because in most OO languages (C++, Java, Scala, C#, etc.) such a restriction does not exist. It is true that when you design\u2026","rel":"","context":"In "Julia"","block_context":{"text":"Julia","link":"https:\/\/www.rangakrish.com\/index.php\/category\/julia\/"},"img":{"alt_text":"","src":"","width":0,"height":0},"classes":[]},{"id":1928,"url":"https:\/\/www.rangakrish.com\/index.php\/2020\/03\/15\/stdis_destructible\/","url_meta":{"origin":2744,"position":4},"title":"std::is_destructible","author":"admin","date":"March 15, 2020","format":false,"excerpt":"In the last article, I explained the deleted destructor in some detail. Today, I would like to talk about a related construct, a type trait called std::is_destructible. Type traits, defined in the header , are a big help when it comes to implementing template metaprogramming. \u00a0See this\u00a0article for a nice\u2026","rel":"","context":"In "C++"","block_context":{"text":"C++","link":"https:\/\/www.rangakrish.com\/index.php\/category\/c\/"},"img":{"alt_text":"Private\/Protected Destructor","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2020\/03\/Example7.jpg?resize=350%2C200&ssl=1","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2020\/03\/Example7.jpg?resize=350%2C200&ssl=1 1x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2020\/03\/Example7.jpg?resize=525%2C300&ssl=1 1.5x"},"classes":[]},{"id":4012,"url":"https:\/\/www.rangakrish.com\/index.php\/2026\/01\/01\/common-lisp-metaobject-protocol-classes-are-just-objects\/","url_meta":{"origin":2744,"position":5},"title":"Common Lisp Metaobject Protocol: Classes are Just Objects!","author":"admin","date":"January 1, 2026","format":false,"excerpt":"In today\u2019s popular languages such as C++, Java, Golang, Rust, Python, etc., classes are fixed constructs defined by the language. They have a definite syntax that can\u2019t be changed while programming. We are all used to this of course. But what makes Common Lisp stand out is that in that\u2026","rel":"","context":"In "LISP"","block_context":{"text":"LISP","link":"https:\/\/www.rangakrish.com\/index.php\/category\/lisp\/"},"img":{"alt_text":"A Simple Class","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2026\/01\/code1-300x42.jpg?resize=350%2C200&ssl=1","width":350,"height":200},"classes":[]}],"_links":{"self":[{"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/posts\/2744","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/comments?post=2744"}],"version-history":[{"count":0,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/posts\/2744\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/media?parent=2744"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/categories?post=2744"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/tags?post=2744"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}