![\"ClassIdioms\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2023\/01\/ClassIdioms.png\")
<\/p>\nA value object is a small object whose equality is based on state, but not identity. Typical value objects are money, numbers, or strings.<\/p>\n
<\/p>\n
<\/p>\n
<\/p>\n
The term Value Object goes back to the seminal book Domain-Driven Design<\/a> (DDD) by Eric Evans. But, what is a value object? Eric gave the answer in his book:<\/p>\n An object that represents a descriptive aspect of the domain with no conceptual identity is called a Value Object. Value Objects are instantiated to represent elements of the design that we care about only for what they are, not who or which they are.<\/em><\/p>\n If this is too formal for you, here is a nice example of the author:<\/p>\n When a child is drawing, he cares about the color of the marker he chooses, and he may care about the sharpness of the tip. But if there are two markers of the same color and shape, he probably won\u2019t care which one he uses. If a marker is lost and replaced by another of the same color from a new pack, he can resume his work unconcerned about the switch.<\/em><\/p>\n The key term in the formal definition and the example about the Value Object is equality.<\/p>\n In general, we have two types of equality: reference equality and value equality. For simplicity reasons, I will ignore id-based equality.<\/p>\n Let me switch to Python because Python makes it easy to compare both kinds of equality.<\/p>\n The short example in the Python shell should make the difference between reference equality and value equality clear.<\/p>\n First, I define two lists What does this mean for modern C++20? In C++20, the compiler can generate the equality operator.<\/p>\n For a user-defined type, you have to choose the appropriate equality semantics.<\/p>\n <\/p>\n <\/p>\n In C++20, the compiler can auto-generate the equality operator and use it as a fallback for the inequality operator. The auto-generated equality operator applies value equality. To be more precise, the compiler-generated equality operator performs a lexicographical comparison. Lexicographical comparison means that all base classes are compared left to right and all nonstatic members of the class in their declaration order.<\/p>\n I have to add two important points:<\/p>\n Honestly, the example works as expected but does not seem right.<\/p>\n Two dates with identical values should be regarded as equal but not two men. The equality of two men should be based on their identity and not on their name and age.<\/p>\n<\/p>\n Let me discuss the details about Value Objects.<\/p>\n After the last chapter, this should be obvious. The equality of a Value Object should be based on its state and not on its identity.<\/p>\n A Value Object should not be mutable. This makes Value Objects ideal candidates for concurrency. Changing a Value Object means creating a new one with the modified attributes. This property, that an operation on an immutable object returns a new object has two excellent properties. For conciseness, I use Python once more.<\/p>\n In Python, a string is immutable:<\/p>\n A Value Object should validate its attributes when created. For simplicity, I skipped this step in my previous What are the Pros and Cons of Value Objects:<\/p>\n The pros of Value Objects overweight their cons heavily.<\/p>\n You should use rich types instead of built-in types for dealing with primitive values. This has many implications. Let me compare the following two representations of a date:<\/p>\n <\/p>\n <\/p>\n Value Objects are immutable. Consequentially, they give the optimizer additional guarantees and can be shared between threads without synchronization.<\/p>\n Only for the sake of arguments: You may end with too many small classes representing Value Objects.<\/p>\n A Null Object encapsulates a do nothing behavior inside an object. Let me show you in my next post the advantages of Null Objects.<\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n","protected":false},"excerpt":{"rendered":" A value object is a small object whose equality is based on state, but not identity. Typical value objects are money, numbers, or strings.<\/p>\n","protected":false},"author":21,"featured_media":6503,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[379],"tags":[],"class_list":["post-6511","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-patterns"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/6511","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/users\/21"}],"replies":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/comments?post=6511"}],"version-history":[{"count":0,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/6511\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/6503"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=6511"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=6511"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=6511"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}Identity<\/h2>\n
\n
![\"EqualityPython\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2023\/02\/EqualityPythonNew.png\")
<\/p>\nlist1<\/code> and list2<\/code> with the same elements. When I compare their identity (list1 is list2<\/code>), they are different. When I compare their values, they are identical. Python uses for equality (and non-equality) comparison of the memory address of the compared objects. The id<\/code> operator (id(liste1)<\/code>) returns a decimal representation of its hexadecimal memory address. By assigning list1<\/code> to list3, <\/code>both lists refer to the same memory location. Consequentially, id(list3)<\/code> is identical to id(list1)<\/code>, and the call list1<\/code> is list3<\/code> returns True<\/code>.<\/p>\nCompiler-Generated Equality Operator<\/h2>\n
\n\/\/ equalityReferenceValue.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n\r\nclass<\/span> Date<\/span>{\r\n public:<\/span>\r\n Date(int<\/span> y, int<\/span> m, int<\/span> d):<\/span> year(y), month(m), day(d){}\r\n bool<\/span> operator<\/span>==<\/span>(const<\/span> Date&<\/span>) const<\/span> =<\/span> default<\/span>;\r\n private:<\/span>\r\n int<\/span> year;\r\n int<\/span> month;\r\n int<\/span> day;\r\n};\r\n\r\nclass<\/span> Man<\/span>{\r\n public:<\/span>\r\n Man(const<\/span> std::<\/span>string n, int<\/span> a):<\/span> name(n), age(a){}\r\n bool<\/span> operator<\/span>==<\/span>(const<\/span> Man&<\/span>) const<\/span> =<\/span> default<\/span>;\r\n private:<\/span>\r\n std::<\/span>string name;\r\n int<\/span> age;\r\n};\r\n\r\nint<\/span> main<\/span>() {\r\n\r\n std::<\/span>cout <<<\/span> std::<\/span>boolalpha <<<\/span> '\\n'<\/span>;\r\n\r\n Date date1(2022<\/span>, 10<\/span>, 31<\/span>);\r\n Date date2(2022<\/span>, 10<\/span>, 31<\/span>);\r\n\r\n std::<\/span>cout <<<\/span> \"date1 == date2: \"<\/span> <<<\/span> (date1 ==<\/span> date2) <<<\/span> '\\n'<\/span>;\r\n std::<\/span>cout <<<\/span> \"date1 != date2: \"<\/span> <<<\/span> (date1 !=<\/span> date2) <<<\/span> '\\n'<\/span>;\r\n\r\n std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n Man man1(\"Rainer Grimm\"<\/span>, 56<\/span>);\r\n Man man2(\"Rainer Grimm\"<\/span>, 56<\/span>);\r\n\r\n std::<\/span>cout <<<\/span> \"man1 == man2: \"<\/span> <<<\/span> (man1 ==<\/span> man2) <<<\/span> '\\n'<\/span>;\r\n std::<\/span>cout <<<\/span> \"man1 != man2: \"<\/span> <<<\/span> (man1 !=<\/span> man2) <<<\/span> '\\n'<\/span>;\r\n\r\n std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n}\r\n<\/pre>\n<\/div>\n\n
<=><\/code>) also applies value equality. You can read more about the three-way comparison operator in my previous posts:\n\n
![\"equalityReferenceValue\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2023\/02\/equalityReferenceValue.png\")
<\/p>\nValue Objects<\/h2>\n
Properties<\/h3>\n
Value Equality<\/h4>\n
Immutability<\/h4>\n
![\"immutable\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2023\/02\/immutable.png\")
<\/p>\n\n
. <\/code>The original s<\/code> and the new s<\/code> have different addresses.<\/code><\/li>\n(5 +5) * 10 - 20<\/code> are based on the fluent interface. Each operation returns a temporary, on which you can apply the next operation. Of course, numbers are Value Objects.<\/li>\n<\/ol>\nSelf-Validation<\/h4>\n
Date<\/code> class.<\/p>\nPros and Cons<\/h3>\n
Rich Types<\/h4>\n
\nDate date1<\/span>(2022<\/span>, 10<\/span>, 5<\/span>);\r\n\r\nstd::<\/span>string date2 =<\/span> \"2022 10 5\"; <\/span>\r\n<\/pre>\n<\/div>\n\n
Date(2022, 15, 5)<\/code>, because the constructor’s job is it to validate the input. This does not hold for the string value “2022 15 5\"<\/code>, because someone mixed up the month and the day.<\/li>\nDate<\/code> documentation, what each component stands for.<\/li>\nDate<\/code>. E.g.: subtracting two dates returns a time duration. A time duration should also be a Value Object.<\/li>\nPerformance<\/h4>\n
Proliferation of Classes<\/h4>\n
What’s Next?<\/h2>\n