C++ Core Guidelines ### Guideline C.21 is “The Rule of Five” ## Simple String ## Simple String - Constructor struct SString { String(char const * cp) : data_(new char[string(cp) + 1]) { string(data_ s{"Pass to a function by value"}; // ... somefn(s); // ... } ## Simple String - Copy Constructor struct SString { // ... String(SString const & rhs) : data_(new char[string(rhs copied)}; String dst{"I have a value)}; // ... dst = src; // ... } ## Simple String - Copy Assignment Operator struct SString { // ... SString & operator=(SString const & rhs)

= UB Classes ⇒ Default constructor if available; else members are undefined. Aggregates $ \Rightarrow $ For each element, follows its types default init method. ## Copy Initialization T object Initialize without creating unnecessary temps. Same or Derived Class ⇒ The most appropriate constructor, excluding explicit. Different Class ⇒ Pick the user defined conversion if available. ## Aggregate types ⇒ Directly initialize the value using the arg. Classes $ \Rightarrow $ best-matching constructor (non-explicit or explicit) is selected. Arrays or aggregates $ \Rightarrow $ each member initialized

object is created. Data fields of classes should be initialized in the constructor initialization list C. The body of the constructor is available for further operations. ■ Classes can consist of member Access specifier }; class Apple 4 : /*this->*/ mData{i} C Constructor initializer list 5 { D Constructor body 6 } 8 Member functions void Set(int i) { /*this->*/ mData = declareddefaulteddefaultednot declarednot declaredcopyctornot declareddefaulteduser declareddefaultednot

(b) move • Both assigned expressions are references - Currently, both lines would call the copy constructor ## So, how can we distinguish between the cases? std::string str2 = str1; // (a) do not move move • Both assigned expressions are references - Before C++11, both lines would call the copy constructor - But they are kind of a different references: The reference at (a) would still be alive after a simple MyString class with: • Copyctor • Move ctor (“steals” the other instead of copying) • Copy Assignment operator • Move assignment operator (again, “steals”) Skeleton: https://coliru.stacked-crooked

dictionary_t(); // ... Fill in thousands of entries from database ... return dictionary; } One copy during function return void business_logic() { dictionary_t dictionary; dictionary = bui thousands of entries from database ... return dictionary; } One copy during function return void business_logic() Another copy during assignment operator { dictionary_t dictionary; dictionary David Olsen — Back to Basics: Move Semantics — CppCon 2020 ## Assignment operator Copy dictionary = build_dictionary(getCustomerDb()); Before assignment ![Image](/uploads/documents/

implemented it in CFront 1 Walter Bright's Zortech Compiler Lajoie/Stump proposed n1103 to clarify copy elision and include it in the standard 1988 1989 1997 Bloomberg Engineering ## RVO at Bloomberg different compositions with particles This should not allocate (return value optimization, as we return a copy from a locally constructed temporary in that function). work in progress 21 · Opened 24 days ago #### 11.9.6 Copy/move elision #### [class.copy.elision] When certain criteria are met, an implementation is allowed to omit the copy/move construction of a class object, even if the constructor selected

); throw error; } } Don’t throw by pointer or reference (bad semantics) throw makes a copy of the value to throw ## Throw By Rvalue void f(_/* ... */) { // ... if(* some condition message"); } // ... } Don’t throw by pointer or reference (bad semantics) throw makes a copy of the value to throw throw by rvalue ## How to Use Exceptions Build on the std::exception hierarchy ) { /* ... */ } // ... } Don’t catch by value, it ... ... creates an unnecessary copy … potentially slices the exception ![Image](/uploads/documents/9/f/1/0/9f103e555bf41b11bb9069291b2d3e22/p45_1

or one of its subobjects is initialized by a constructor other than a trivial default constructor. [Note: Initialization by a trivial copy/move constructor is non-vacuous initialization. — end note] The or one of its subobjects is initialized by a constructor other than a trivial default constructor. [Note: Initialization by a trivial copy/move constructor is non-vacuous initialization. — end note] The or one of its subobjects is initialized by a constructor other than a trivial default constructor. [Note: Initialization by a trivial copy/move constructor is non-vacuous initialization. — end note] The

having to deal with their internal format. Whenever possible data caching is performed, helped by a copy-on-write mechanism. This improves performance especially when converting big resources from a file Resource raw data isn’t always what one expected, however. While some resource types simply contain a copy of a file in their raw data, other types do some processing, so that dumping raw data doesn’t result res as well inFile.Free; end. Note that resources of type RT_MANIFEST (??) contain a straight copy of a xml file, so TGenericResource (??) class fits our needs. TGenericResource (??) is a basic implementation

strchr(str, '/')) str = p + 1; There is one caveat: if the variable is an object, its constructor is invoked every time it enters scope and is created, and its destructor is invoked every time called is defined to be the reverse of the order in which the constructors were called. Since constructor order is indeterminate, so is destructor order. For example, at program-end time a static variable initialization in the body of the constructor. • No need to worry about whether the class has been initialized or not. - Objects that are fully initialized by constructor call can be const and may also