Being aware of overengineering is crucial when working with a feature-rich language like C++. Overengineering occurs when developers introduce overly complex or unnecessary solutions to a problem.<\/p>\n\n\n\n
C++ developers could be attempted to use as possible the new features introduced by the new standards. which makes the code finally more complicated than it must be.<\/p>
Here’s an example to show how C++ metaprogramming can be used to create a type-erased container with arithmetic operations that are evaluated at compile time. While this example show the power and flexibility of C++ metaprogramming techniques. it might seem complicated due to the use of templates, concepts and constexpr functions:<\/p>\n\n\n\n\n\n\n\n
#include <iostream>\n#include <type_traits>\n\ntemplate<typename T>\nconcept Arithmetic = std::is_arithmetic_v<T>;\n\ntemplate<Arithmetic T>\nstruct AnyType {\n constexpr AnyType(const T& value) : value_(value) {}\n\n template<Arithmetic U>\n constexpr auto add(const AnyType<U>& other) const {\n return AnyType{ value_ + other.value_ };\n }\n\n template<Arithmetic U>\n constexpr auto subtract(const AnyType<U>& other) const {\n return AnyType{ value_ - other.value_ };\n }\n\n template<Arithmetic U>\n constexpr auto multiply(const AnyType<U>& other) const {\n return AnyType{ value_ * other.value_ };\n }\n\n template<Arithmetic U>\n constexpr auto divide(const AnyType<U>& other) const {\n static_assert(other.value_ != 0, "Division by zero");\n return AnyType{ value_ \/ other.value_ };\n }\n\n template<Arithmetic U>\n friend std::ostream& operator<<(std::ostream& os, const AnyType<U>& any) {\n return os << any.value_;\n }\n\nprivate:\n T value_;\n};\n\nint main() {\n constexpr AnyType<int> x{ 5 };\n constexpr AnyType<float> y{ 2.5f };\n\n constexpr auto addition = x.add(y);\n constexpr auto subtraction = x.subtract(y);\n constexpr auto multiplication = x.multiply(y);\n constexpr auto division = x.divide(y);\n\n std::cout << "Addition: " << addition << std::endl;\n std::cout << "Subtraction: " << subtraction << std::endl;\n std::cout << "Multiplication: " << multiplication << std::endl;\n std::cout << "Division: " << division << std::endl;\n\n return 0;\n}\n<\/pre><\/div>\n\n\n\nIn this example:<\/p>\n\n\n\n
Arithmetic<\/code> to constrain the template parameters to arithmetic types.<\/li>\n\n\n\n- The
AnyType<\/code> class template is defined to hold any arithmetic type.<\/li>\n\n\n\n- We provide member functions (
add<\/code>, subtract<\/code>, multiply<\/code>, divide<\/code>) that perform arithmetic operations between AnyType<\/code> objects of potentially different types.<\/li>\n\n\n\n- We use
constexpr<\/code> to ensure that these operations are evaluated at compile time.<\/li>\n\n\n\n- We overload the
operator<<<\/code> to allow streaming AnyType<\/code> objects to std::ostream<\/code>.<\/li>\n<\/ul>\n\n\n\nYes sometimes for specific needs we can develop a code like that, But in general do we need this sophisticated class to do basic arithmetic operations, it’s like construct a tank to kill a fly \ud83d\ude42<\/p>\n\n\n\n
To resume try to not be tempted by the sophiscated new features and try to use them only if you need to. And always try to Follow KISS and YAGNI Principles<\/strong>:<\/p>\n\n\n\nKeep It Simple, Stupid (KISS) and You Ain’t Gonna Need It (YAGNI) are principles that advocate for simplicity and avoiding unnecessary features until they are needed.<\/p>\n","protected":false},"excerpt":{"rendered":"
Being aware of overengineering is crucial when working with a feature-rich language like C++. Overengineering occurs when developers introduce overly complex or unnecessary solutions to a problem. C++ developers could be attempted to use as possible the new features introduced by the new standards. which makes the code finally more complicated than it must be. … Continue reading “C++ is now a feature-rich language, Be aware of OverEngineering”<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[67,137],"class_list":["post-1592","post","type-post","status-publish","format-standard","hentry","category-uncategorized","tag-c-2","tag-programming"],"_links":{"self":[{"href":"https:\/\/cppdepend.com\/blog\/wp-json\/wp\/v2\/posts\/1592","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/cppdepend.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/cppdepend.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/cppdepend.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/cppdepend.com\/blog\/wp-json\/wp\/v2\/comments?post=1592"}],"version-history":[{"count":6,"href":"https:\/\/cppdepend.com\/blog\/wp-json\/wp\/v2\/posts\/1592\/revisions"}],"predecessor-version":[{"id":1776,"href":"https:\/\/cppdepend.com\/blog\/wp-json\/wp\/v2\/posts\/1592\/revisions\/1776"}],"wp:attachment":[{"href":"https:\/\/cppdepend.com\/blog\/wp-json\/wp\/v2\/media?parent=1592"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/cppdepend.com\/blog\/wp-json\/wp\/v2\/categories?post=1592"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/cppdepend.com\/blog\/wp-json\/wp\/v2\/tags?post=1592"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}