C++ classes
Type of data structure
- 34 min read
- 6 chapters
Related on Lably
Through Record (computer science), Data structure and Method (computer programming)
Instances of a class data type are known as objects and can contain member variables, constants, member functions, and overloaded operators defined by the programmer.
Differences between a struct and a class in C++
In C++, a class defined with the class keyword has private members and base classes by default. A structure is a class defined with the struct keyword. Its members and base classes are public by default. In practice, structs are typically reserved for data without functions. When deriving a struct from a class/struct, default access-specifier for a base class/struct is public. And when deriving a class, default access specifier is private.
Sign in to keep reading
5 more chapters are free with a Lably account.
Aggregate classes
An aggregate class is a class with no user-declared constructors, no private or protected non-static data members, no base classes, and no virtual functions. Such a class can be initialized with a brace-enclosed comma-separated list of initializer-clauses. The following code has the same semantics in both C and C++. Since C++20, aggregate types may also be initialized with C99-style designated initializers, but unlike in C, these fields cannot be reordered in declaration.
<span id="mwPA"></span><span class="k" id="mwPQ">using</span><span class="w" id="mwPg"> </span><span class="n" id="mwPw">std</span><span class="o" id="mwQA">::</span><span class="n" id="mwQQ">string</span><span class="p" id="mwQg">;</span> <span class="k" id="mwQw">struct</span><span class="w" id="mwRA"> </span><span class="nc" id="mwRQ">Address</span><span class="w" id="mwRg"> </span><span class="p" id="mwRw">{</span> <span class="w" id="mwSA"> </span><span class="n" id="mwSQ">string</span><span class="w" id="mwSg"> </span><span class="n" id="mwSw">city</span><span class="p" id="mwTA">;</span> <span class="w" id="mwTQ"> </span><span class="kt" id="mwTg">int</span><span class="w" id="mwTw"> </span><span class="n" id="mwUA">zip</span><span class="p" id="mwUQ">;</span> <span class="p" id="mwUg">};</span> <span class="k" id="mwUw">struct</span><span class="w" id="mwVA"> </span><span class="nc" id="mwVQ">Person</span><span class="w" id="mwVg"> </span><span class="p" id="mwVw">{</span> <span class="w" id="mwWA"> </span><span class="n" id="mwWQ">string</span><span class="w" id="mwWg"> </span><span class="n" id="mwWw">name</span><span class="p" id="mwXA">;</span> <span class="w" id="mwXQ"> </span><span class="kt" id="mwXg">int</span><span class="w" id="mwXw"> </span><span class="n" id="mwYA">age</span><span class="p" id="mwYQ">;</span> <span class="w" id="mwYg"> </span><span class="n" id="mwYw">Address</span><span class="w" id="mwZA"> </span><span class="n" id="mwZQ">addr</span><span class="p" id="mwZg">;</span> <span class="p" id="mwZw">};</span> <span class="c1" id="mwaA">// Ordinary initializer list</span> <span class="n" id="mwaQ">Address</span><span class="w" id="mwag"> </span><span class="n" id="mwaw">addr1</span><span class="w" id="mwbA"> </span><span class="o" id="mwbQ">=</span><span class="w" id="mwbg"> </span><span class="p" id="mwbw">{</span><span class="s" id="mwcA">"Los Angeles"</span><span class="p" id="mwcQ">,</span><span class="w" id="mwcg"> </span><span class="mi" id="mwcw">12345</span><span class="p" id="mwdA">};</span> <span class="n" id="mwdQ">Address</span><span class="w" id="mwdg"> </span><span class="n" id="mwdw">addr2</span><span class="p" id="mweA">{</span><span class="s" id="mweQ">"Seattle"</span><span class="p" id="mweg">,</span><span class="w" id="mwew"> </span><span class="mi" id="mwfA">10001</span><span class="p" id="mwfQ">};</span> <span class="c1" id="mwfg">// Designated initializer</span> <span class="n" id="mwfw">Address</span><span class="w" id="mwgA"> </span><span class="n" id="mwgQ">addr3</span><span class="w" id="mwgg"> </span><span class="o" id="mwgw">=</span><span class="w" id="mwhA"> </span><span class="p" id="mwhQ">{</span> <span class="w" id="mwhg"> </span><span class="p" id="mwhw">.</span><span class="n" id="mwiA">city</span><span class="w" id="mwiQ"> </span><span class="o" id="mwig">=</span><span class="w" id="mwiw"> </span><span class="s" id="mwjA">"Toronto"</span><span class="p" id="mwjQ">,</span> <span class="w" id="mwjg"> </span><span class="p" id="mwjw">.</span><span class="n" id="mwkA">zip</span><span class="w" id="mwkQ"> </span><span class="o" id="mwkg">=</span><span class="w" id="mwkw"> </span><span class="mi" id="mwlA">13853</span> <span class="p" id="mwlQ">};</span> <span class="c1" id="mwlg">// Designated initializers also work with another aggregate as member:</span> <span class="n" id="mwlw">Person</span><span class="w" id="mwmA"> </span><span class="n" id="mwmQ">john</span><span class="p" id="mwmg">{</span> <span class="w" id="mwmw"> </span><span class="p" id="mwnA">.</span><span class="n" id="mwnQ">name</span><span class="w" id="mwng"> </span><span class="o" id="mwnw">=</span><span class="w" id="mwoA"> </span><span class="s" id="mwoQ">"John"</span><span class="p" id="mwog">,</span> <span class="w" id="mwow"> </span><span class="p" id="mwpA">.</span><span class="n" id="mwpQ">age</span><span class="w" id="mwpg"> </span><span class="o" id="mwpw">=</span><span class="w" id="mwqA"> </span><span class="mi" id="mwqQ">20</span><span class="p" id="mwqg">,</span> <span class="w" id="mwqw"> </span><span class="p" id="mwrA">.</span><span class="n" id="mwrQ">address</span><span class="w" id="mwrg"> </span><span class="o" id="mwrw">=</span><span class="w" id="mwsA"> </span><span class="p" id="mwsQ">{</span> <span class="w" id="mwsg"> </span><span class="p" id="mwsw">.</span><span class="n" id="mwtA">city</span><span class="w" id="mwtQ"> </span><span class="o" id="mwtg">=</span><span class="w" id="mwtw"> </span><span class="s" id="mwuA">"New York"</span><span class="p" id="mwuQ">,</span> <span class="w" id="mwug"> </span><span class="p" id="mwuw">.</span><span class="n" id="mwvA">zip</span><span class="w" id="mwvQ"> </span><span class="o" id="mwvg">=</span><span class="w" id="mwvw"> </span><span class="mi" id="mwwA">54321</span> <span class="w" id="mwwQ"> </span><span class="p" id="mwwg">}</span> <span class="p" id="mwww">};</span>Just as in C, a semicolon must follow the definition of a struct/class. Between the definition of the struct/class and the semicolon, instances of it may be declared.
<span id="mwyw"></span><span class="c1" id="mwzA">// Declares two Points, named a and b</span> <span class="c1" id="mwzQ">// a = {1, 2} and b = {3, 4}</span> <span class="k" id="mwzg">struct</span><span class="w" id="mwzw"> </span><span class="nc" id="mw0A">Point</span><span class="w" id="mw0Q"> </span><span class="p" id="mw0g">{</span> <span class="w" id="mw0w"> </span><span class="kt" id="mw1A">int</span><span class="w" id="mw1Q"> </span><span class="n" id="mw1g">x</span><span class="p" id="mw1w">;</span> <span class="w" id="mw2A"> </span><span class="kt" id="mw2Q">int</span><span class="w" id="mw2g"> </span><span class="n" id="mw2w">y</span><span class="p" id="mw3A">;</span> <span class="p" id="mw3Q">}</span><span class="w" id="mw3g"> </span><span class="n" id="mw3w">a</span><span class="p" id="mw4A">{</span><span class="mi" id="mw4Q">1</span><span class="p" id="mw4g">,</span><span class="w" id="mw4w"> </span><span class="mi" id="mw5A">2</span><span class="p" id="mw5Q">},</span><span class="w" id="mw5g"> </span><span class="n" id="mw5w">b</span><span class="p" id="mw6A">{</span><span class="mi" id="mw6Q">3</span><span class="p" id="mw6g">,</span><span class="w" id="mw6w"> </span><span class="mi" id="mw7A">4</span><span class="p" id="mw7Q">};</span>POD-structs
A POD-struct (Plain Old Data Structure) is a non-union aggregate class that has no non-static data members of type non-POD-struct, non-POD-union (or array of such types) or reference, and has no user-defined assignment operator and no user-defined destructor. A POD-struct could be said to be the C++ equivalent of a C struct. In most cases, a POD-struct will have the same memory layout as a corresponding struct declared in C. For this reason, POD-structs are sometimes colloquially referred to as "C-style structs".
Properties shared between structs in C and POD-structs in C++
- Data members are allocated so that later members have higher addresses within an object, except where separated by an access-specifier.
- Two POD-struct types are layout-compatible if they have the same number of nonstatic data members, and corresponding nonstatic data members (in order) have layout-compatible types.
- A POD-struct may contain unnamed padding.
- A pointer to a POD-struct object, suitably converted using a reinterpret cast, points to its initial member and vice versa, implying that there is no padding at the beginning of a POD-struct.
- A POD-struct may be used with the offsetof macro.
Declaration and usage
C++ classes have their own members. These members include variables (including other structures and classes), functions (specific identifiers or overloaded operators) known as member functions, constructors and destructors. Members are declared to be either publicly or privately accessible using the public: and private: access specifiers respectively. Any member encountered after a specifier will have the associated access until another specifier is encountered. There is also inheritance between classes which can make use of the protected: specifier.
The this keyword
To facilitate classes' ability to reference themselves, C++ implements the this keyword for all member functions. The this keyword acts as a pointer to the current object. Its type is that of a pointer to the current object.
The this keyword is especially important for member functions with the class itself as the return value:
<span id="mwATI"></span><span class="k" id="mwATM">class</span><span class="w" id="mwATQ"> </span><span class="nc" id="mwATU">Point</span><span class="w" id="mwATY"> </span><span class="p" id="mwATc">{</span> <span class="k" id="mwATg">private</span><span class="o" id="mwATk">:</span> <span class="w" id="mwATo"> </span><span class="kt" id="mwATs">double</span><span class="w" id="mwATw"> </span><span class="n" id="mwAT0">x</span><span class="p" id="mwAT4">;</span> <span class="w" id="mwAT8"> </span><span class="kt" id="mwAUA">double</span><span class="w" id="mwAUE"> </span><span class="n" id="mwAUI">y</span><span class="p" id="mwAUM">;</span> <span class="k" id="mwAUQ">public</span><span class="o" id="mwAUU">:</span> <span class="w" id="mwAUY"> </span><span class="c1" id="mwAUc">// ...</span> <span class="w" id="mwAUg"> </span><span class="n" id="mwAUk">Point</span><span class="o" id="mwAUo">&</span><span class="w" id="mwAUs"> </span><span class="k" id="mwAUw">operator</span><span class="o" id="mwAU0">+=</span><span class="p" id="mwAU4">(</span><span class="k" id="mwAU8">const</span><span class="w" id="mwAVA"> </span><span class="n" id="mwAVE">Point</span><span class="o" id="mwAVI">&</span><span class="w" id="mwAVM"> </span><span class="n" id="mwAVQ">rhs</span><span class="p" id="mwAVU">)</span><span class="w" id="mwAVY"> </span><span class="k" id="mwAVc">noexcept</span><span class="w" id="mwAVg"> </span><span class="p" id="mwAVk">{</span> <span class="w" id="mwAVo"> </span><span class="k" id="mwAVs">this</span><span class="o" id="mwAVw">-></span><span class="n" id="mwAV0">x</span><span class="w" id="mwAV4"> </span><span class="o" id="mwAV8">+=</span><span class="w" id="mwAWA"> </span><span class="n" id="mwAWE">rhs</span><span class="p" id="mwAWI">.</span><span class="n" id="mwAWM">x</span><span class="p" id="mwAWQ">;</span> <span class="w" id="mwAWU"> </span><span class="k" id="mwAWY">this</span><span class="o" id="mwAWc">-></span><span class="n" id="mwAWg">y</span><span class="w" id="mwAWk"> </span><span class="o" id="mwAWo">+=</span><span class="w" id="mwAWs"> </span><span class="n" id="mwAWw">rhs</span><span class="p" id="mwAW0">.</span><span class="n" id="mwAW4">y</span><span class="p" id="mwAW8">;</span> <span class="w" id="mwAXA"> </span><span class="k" id="mwAXE">return</span><span class="w" id="mwAXI"> </span><span class="o" id="mwAXM">*</span><span class="k" id="mwAXQ">this</span><span class="p" id="mwAXU">;</span> <span class="w" id="mwAXY"> </span><span class="p" id="mwAXc">}</span> <span class="p" id="mwAXg">};</span>As stated above, this is a pointer, so the use of the asterisk (*) is necessary to convert it into a reference to be returned. The type of this for a class X is X* const; if the member function is const-qualified, the type is const X* const.
Global and local class
A class defined outside all functions is a global class because its objects can be created from anywhere in the program. If it is defined within a function body then it's a local class because objects of such a class are local to the function scope.
Basic declaration and member variables
Non-union classes are declared with the class or struct keyword. Declaration of members are placed within this declaration.
The above definitions are functionally equivalent. Either code will define objects of type Person as having two public data members, name and age. The semicolons after the closing braces are mandatory.
After one of these declarations (but not both), Person can be used as follows to create newly defined variables of the Person datatype:
<span id="mwAds"></span><span class="k" id="mwAdw">import</span><span class="w" id="mwAd0"> </span><span class="n" id="mwAd4">std</span><span class="p" id="mwAd8">;</span> <span class="k" id="mwAeA">using</span><span class="w" id="mwAeE"> </span><span class="n" id="mwAeI">std</span><span class="o" id="mwAeM">::</span><span class="n" id="mwAeQ">string</span><span class="p" id="mwAeU">;</span> <span class="k" id="mwAeY">struct</span><span class="w" id="mwAec"> </span><span class="nc" id="mwAeg">Person</span><span class="w" id="mwAek"> </span><span class="p" id="mwAeo">{</span> <span class="w" id="mwAes"> </span><span class="n" id="mwAew">string</span><span class="w" id="mwAe0"> </span><span class="n" id="mwAe4">name</span><span class="p" id="mwAe8">;</span> <span class="w" id="mwAfA"> </span><span class="kt" id="mwAfE">int</span><span class="w" id="mwAfI"> </span><span class="n" id="mwAfM">age</span><span class="p" id="mwAfQ">;</span> <span class="p" id="mwAfU">};</span> <span class="kt" id="mwAfY">int</span><span class="w" id="mwAfc"> </span><span class="nf" id="mwAfg">main</span><span class="p" id="mwAfk">()</span><span class="w" id="mwAfo"> </span><span class="p" id="mwAfs">{</span> <span class="w" id="mwAfw"> </span><span class="n" id="mwAf0">Person</span><span class="w" id="mwAf4"> </span><span class="n" id="mwAf8">a</span><span class="p" id="mwAgA">;</span> <span class="w" id="mwAgE"> </span><span class="n" id="mwAgI">Person</span><span class="w" id="mwAgM"> </span><span class="n" id="mwAgQ">b</span><span class="p" id="mwAgU">;</span> <span class="w" id="mwAgY"> </span><span class="n" id="mwAgc">a</span><span class="p" id="mwAgg">.</span><span class="n" id="mwAgk">name</span><span class="w" id="mwAgo"> </span><span class="o" id="mwAgs">=</span><span class="w" id="mwAgw"> </span><span class="s" id="mwAg0">"Calvin"</span><span class="p" id="mwAg4">;</span> <span class="w" id="mwAg8"> </span><span class="n" id="mwAhA">b</span><span class="p" id="mwAhE">.</span><span class="n" id="mwAhI">name</span><span class="w" id="mwAhM"> </span><span class="o" id="mwAhQ">=</span><span class="w" id="mwAhU"> </span><span class="s" id="mwAhY">"Hobbes"</span><span class="p" id="mwAhc">;</span> <span class="w" id="mwAhg"> </span><span class="n" id="mwAhk">a</span><span class="p" id="mwAho">.</span><span class="n" id="mwAhs">age</span><span class="w" id="mwAhw"> </span><span class="o" id="mwAh0">=</span><span class="w" id="mwAh4"> </span><span class="mi" id="mwAh8">30</span><span class="p" id="mwAiA">;</span> <span class="w" id="mwAiE"> </span><span class="n" id="mwAiI">b</span><span class="p" id="mwAiM">.</span><span class="n" id="mwAiQ">age</span><span class="w" id="mwAiU"> </span><span class="o" id="mwAiY">=</span><span class="w" id="mwAic"> </span><span class="mi" id="mwAig">20</span><span class="p" id="mwAik">;</span> <span class="w" id="mwAio"> </span><span class="n" id="mwAis">std</span><span class="o" id="mwAiw">::</span><span class="n" id="mwAi0">println</span><span class="p" id="mwAi4">(</span><span class="s" id="mwAi8">"{}: {}"</span><span class="p" id="mwAjA">,</span><span class="w" id="mwAjE"> </span><span class="n" id="mwAjI">a</span><span class="p" id="mwAjM">.</span><span class="n" id="mwAjQ">name</span><span class="p" id="mwAjU">,</span><span class="w" id="mwAjY"> </span><span class="n" id="mwAjc">a</span><span class="p" id="mwAjg">.</span><span class="n" id="mwAjk">age</span><span class="p" id="mwAjo">);</span> <span class="w" id="mwAjs"> </span><span class="n" id="mwAjw">std</span><span class="o" id="mwAj0">::</span><span class="n" id="mwAj4">println</span><span class="p" id="mwAj8">(</span><span class="s" id="mwAkA">"{}: {}"</span><span class="p" id="mwAkE">,</span><span class="w" id="mwAkI"> </span><span class="n" id="mwAkM">b</span><span class="p" id="mwAkQ">.</span><span class="n" id="mwAkU">name</span><span class="p" id="mwAkY">,</span><span class="w" id="mwAkc"> </span><span class="n" id="mwAkg">b</span><span class="p" id="mwAkk">.</span><span class="n" id="mwAko">age</span><span class="p" id="mwAks">);</span> <span class="p" id="mwAkw">}</span>Executing the above code will output
Calvin: 30 Hobbes: 20
Member functions
An important feature of the C++ class are member functions. Each datatype can have its own built-in functions (referred to as member functions) that have access to all (public and private) members of the datatype. In the body of these non-static member functions, the keyword this can be used to refer to the object for which the function is called. This is commonly implemented by passing the address of the object as an implicit first argument to the function. Take the above Person type as an example again:
<span id="mwAls"></span><span class="k" id="mwAlw">import</span><span class="w" id="mwAl0"> </span><span class="n" id="mwAl4">std</span><span class="p" id="mwAl8">;</span> <span class="k" id="mwAmA">using</span><span class="w" id="mwAmE"> </span><span class="n" id="mwAmI">std</span><span class="o" id="mwAmM">::</span><span class="n" id="mwAmQ">string</span><span class="p" id="mwAmU">;</span> <span class="k" id="mwAmY">class</span><span class="w" id="mwAmc"> </span><span class="nc" id="mwAmg">Person</span><span class="w" id="mwAmk"> </span><span class="p" id="mwAmo">{</span> <span class="k" id="mwAms">private</span><span class="o" id="mwAmw">:</span> <span class="w" id="mwAm0"> </span><span class="n" id="mwAm4">string</span><span class="w" id="mwAm8"> </span><span class="n" id="mwAnA">name</span><span class="p" id="mwAnE">;</span> <span class="w" id="mwAnI"> </span><span class="kt" id="mwAnM">int</span><span class="w" id="mwAnQ"> </span><span class="n" id="mwAnU">age</span><span class="w" id="mwAnY"> </span><span class="o" id="mwAnc">=</span><span class="w" id="mwAng"> </span><span class="mi" id="mwAnk">5</span><span class="p" id="mwAno">;</span> <span class="k" id="mwAns">public</span><span class="o" id="mwAnw">:</span> <span class="w" id="mwAn0"> </span><span class="c1" id="mwAn4">// "name" and "age" are the member variables. The "this" keyword is an</span> <span class="w" id="mwAn8"> </span><span class="c1" id="mwAoA">// expression whose value is the address of the object for which the member</span> <span class="w" id="mwAoE"> </span><span class="c1" id="mwAoI">// was invoked. Its type is "const Person*", because the function is declared</span> <span class="w" id="mwAoM"> </span><span class="c1" id="mwAoQ">// const.</span> <span class="w" id="mwAoU"> </span><span class="kt" id="mwAoY">void</span><span class="w" id="mwAoc"> </span><span class="n" id="mwAog">printData</span><span class="p" id="mwAok">()</span><span class="w" id="mwAoo"> </span><span class="k" id="mwAos">const</span><span class="w" id="mwAow"> </span><span class="p" id="mwAo0">{</span> <span class="w" id="mwAo4"> </span><span class="n" id="mwAo8">std</span><span class="o" id="mwApA">::</span><span class="n" id="mwApE">println</span><span class="p" id="mwApI">(</span><span class="s" id="mwApM">"{}: {}"</span><span class="p" id="mwApQ">,</span><span class="w" id="mwApU"> </span><span class="n" id="mwApY">name</span><span class="p" id="mwApc">,</span><span class="w" id="mwApg"> </span><span class="n" id="mwApk">age</span><span class="p" id="mwApo">);</span> <span class="w" id="mwAps"> </span><span class="p" id="mwApw">}</span> <span class="p" id="mwAp0">};</span>In the above example the printData method is declared in the body of the class and defined by qualifying it with the name of the class followed by ::. Both name and age are private (default for class) and printData is declared as public which is necessary if it is to be used from outside the class.
With the member function printData, printing can be simplified into:
<span id="mwAqg"></span><span class="n" id="mwAqk">a</span><span class="p" id="mwAqo">.</span><span class="n" id="mwAqs">printData</span><span class="p" id="mwAqw">();</span> <span class="n" id="mwAq0">b</span><span class="p" id="mwAq4">.</span><span class="n" id="mwAq8">printData</span><span class="p" id="mwArA">();</span>
where a and b above are called senders, and each of them will refer to their own member variables when the printData() function is executed.
Prior to the introduction of modules (i.e. using headers), one would usually separate the class or structure declaration (called its interface) and the definition (called its implementation) into separate units. The interface, needed by the user, would be kept in a header file and the implementation would be kept separately in either source or compiled form.
Inheritance
The layout of non-POD classes in memory is not specified by the C++ standard. For example, many popular C++ compilers implement single inheritance by concatenation of the parent class fields with the child class fields, but this is not required by the standard. This choice of layout makes referring to a derived class via a pointer to the parent class type a trivial operation.
For example, consider
<span id="mwAsE"></span><span class="k" id="mwAsI">struct</span><span class="w" id="mwAsM"> </span><span class="nc" id="mwAsQ">Scalar</span><span class="w" id="mwAsU"> </span><span class="p" id="mwAsY">{</span> <span class="w" id="mwAsc"> </span><span class="kt" id="mwAsg">int</span><span class="w" id="mwAsk"> </span><span class="n" id="mwAso">x</span><span class="p" id="mwAss">;</span> <span class="p" id="mwAsw">};</span><span id="mwAs8"></span><span class="k" id="mwAtA">struct</span><span class="w" id="mwAtE"> </span><span class="nc" id="mwAtI">Vec2</span><span class="w" id="mwAtM"> </span><span class="o" id="mwAtQ">:</span><span class="w" id="mwAtU"> </span><span class="k" id="mwAtY">public</span><span class="w" id="mwAtc"> </span><span class="n" id="mwAtg">Scalar</span><span class="w" id="mwAtk"> </span><span class="p" id="mwAto">{</span> <span class="w" id="mwAts"> </span><span class="kt" id="mwAtw">int</span><span class="w" id="mwAt0"> </span><span class="n" id="mwAt4">y</span><span class="p" id="mwAt8">;</span> <span class="p" id="mwAuA">};</span>An instance of Scalar with a Scalar* p pointing to it might look like this in memory:
┏━━━━━━━━━┓ ┃Scalar::x┃ ┗━━━━━━━━━┛ ↑ p
An instance of Vec2 with a Scalar* p pointing to it might look like this:
┏━━━━━━━━━┳━━━━━━━┓ ┃Scalar::x┃Vec2::y┃ ┗━━━━━━━━━┻━━━━━━━┛ ↑ p
Therefore, any code that manipulates the fields of a Scalar object can manipulate the Scalar fields inside the Vec2 object without having to consider anything about the definition of Vec2's fields. A properly written C++ program shouldn't make any assumptions about the layout of inherited fields, in any case. Using the static_cast or dynamic_cast type conversion operators will ensure that pointers are properly converted from one type to another.
Multiple inheritance is not as simple. If a class Z extends classes X and Y, then the fields of both parents need to be stored in some order, but (at most) only one of the parent classes can be located at the front of the derived class. Whenever the compiler needs to convert a pointer from the Z type to either X or Y, the compiler will provide an automatic conversion from the address of the derived class to the address of the base class fields (typically, this is a simple offset calculation).
The final keyword limits the ways in which a class can be subclassed. Subclasses of a class are prevented from overriding methods marked as final by the parent class. Final classes cannot be inherited. This allows devirtualization, the removal of the use of vtables for method lookup, thus allowing the inlining of method calls on final classes.
<span id="mwAxo"></span><span class="c1" id="mwAxs">// final in a class declaration declares that a class cannot be extended</span> <span class="k" id="mwAxw">class</span><span class="w" id="mwAx0"> </span><span class="nc" id="mwAx4">Z</span><span class="w" id="mwAx8"> </span><span class="k" id="mwAyA">final</span><span class="w" id="mwAyE"> </span><span class="o" id="mwAyI">:</span><span class="w" id="mwAyM"> </span><span class="k" id="mwAyQ">public</span><span class="w" id="mwAyU"> </span><span class="n" id="mwAyY">X</span><span class="p" id="mwAyc">,</span><span class="w" id="mwAyg"> </span><span class="k" id="mwAyk">public</span><span class="w" id="mwAyo"> </span><span class="n" id="mwAys">Y</span><span class="w" id="mwAyw"> </span><span class="p" id="mwAy0">{</span> <span class="k" id="mwAy4">public</span><span class="o" id="mwAy8">:</span> <span class="w" id="mwAzA"> </span><span class="c1" id="mwAzE">// final in a method signature declares that a method cannot be overridden further</span> <span class="w" id="mwAzI"> </span><span class="kt" id="mwAzM">void</span><span class="w" id="mwAzQ"> </span><span class="n" id="mwAzU">someOperation</span><span class="p" id="mwAzY">()</span><span class="w" id="mwAzc"> </span><span class="k" id="mwAzg">override</span><span class="w" id="mwAzk"> </span><span class="k" id="mwAzo">final</span><span class="w" id="mwAzs"> </span><span class="p" id="mwAzw">{</span> <span class="w" id="mwAz0"> </span><span class="c1" id="mwAz4">// do something here</span> <span class="w" id="mwAz8"> </span><span class="p" id="mwA0A">}</span> <span class="p" id="mwA0E">};</span>final is not a reserved word in C++, and is instead defined as a contextual keyword, in order to not conflict with uses of the identifier 'final' in existing codebases.
Anonymous class
A class may be anonymous, that is, without an identifier or name.
Anonymous structs had first existed in C11:
<span id="mwA1k"></span><span class="k" id="mwA1o">struct</span><span class="w" id="mwA1s"> </span><span class="p" id="mwA1w">{</span> <span class="w" id="mwA10"> </span><span class="kt" id="mwA14">int</span><span class="w" id="mwA18"> </span><span class="n" id="mwA2A">x</span><span class="p" id="mwA2E">;</span> <span class="w" id="mwA2I"> </span><span class="kt" id="mwA2M">int</span><span class="w" id="mwA2Q"> </span><span class="n" id="mwA2U">y</span><span class="p" id="mwA2Y">;</span> <span class="p" id="mwA2c">}</span><span class="w" id="mwA2g"> </span><span class="n" id="mwA2k">coords</span><span class="p" id="mwA2o">;</span> <span class="n" id="mwA2s">coords</span><span class="p" id="mwA2w">.</span><span class="n" id="mwA20">x</span><span class="w" id="mwA24"> </span><span class="o" id="mwA28">=</span><span class="w" id="mwA3A"> </span><span class="mi" id="mwA3E">5</span><span class="p" id="mwA3I">;</span>In C++, anonymous classes may be defined in a similar manner. However, these classes may not have constructors, as they have no name. Their types, which are compiler-generated, may be retrieved using decltype.
<span id="mwA3k"></span><span class="k" id="mwA3o">class</span><span class="w" id="mwA3s"> </span><span class="p" id="mwA3w">{</span> <span class="k" id="mwA30">private</span><span class="o" id="mwA34">:</span> <span class="w" id="mwA38"> </span><span class="kt" id="mwA4A">int</span><span class="w" id="mwA4E"> </span><span class="n" id="mwA4I">value</span><span class="p" id="mwA4M">;</span> <span class="k" id="mwA4Q">public</span><span class="o" id="mwA4U">:</span> <span class="w" id="mwA4Y"> </span><span class="kt" id="mwA4c">int</span><span class="w" id="mwA4g"> </span><span class="n" id="mwA4k">getValue</span><span class="p" id="mwA4o">()</span><span class="w" id="mwA4s"> </span><span class="p" id="mwA4w">{</span> <span class="w" id="mwA40"> </span><span class="k" id="mwA44">return</span><span class="w" id="mwA48"> </span><span class="n" id="mwA5A">value</span><span class="p" id="mwA5E">;</span> <span class="w" id="mwA5I"> </span><span class="p" id="mwA5M">}</span> <span class="w" id="mwA5Q"> </span><span class="kt" id="mwA5U">void</span><span class="w" id="mwA5Y"> </span><span class="n" id="mwA5c">setValue</span><span class="p" id="mwA5g">(</span><span class="kt" id="mwA5k">int</span><span class="w" id="mwA5o"> </span><span class="n" id="mwA5s">x</span><span class="p" id="mwA5w">)</span><span class="w" id="mwA50"> </span><span class="p" id="mwA54">{</span> <span class="w" id="mwA58"> </span><span class="n" id="mwA6A">value</span><span class="w" id="mwA6E"> </span><span class="o" id="mwA6I">=</span><span class="w" id="mwA6M"> </span><span class="n" id="mwA6Q">x</span><span class="p" id="mwA6U">;</span> <span class="w" id="mwA6Y"> </span><span class="p" id="mwA6c">}</span> <span class="w" id="mwA6g"> </span><span class="kt" id="mwA6k">void</span><span class="w" id="mwA6o"> </span><span class="n" id="mwA6s">display</span><span class="p" id="mwA6w">()</span><span class="w" id="mwA60"> </span><span class="p" id="mwA64">{</span> <span class="w" id="mwA68"> </span><span class="n" id="mwA7A">std</span><span class="o" id="mwA7E">::</span><span class="n" id="mwA7I">println</span><span class="p" id="mwA7M">(</span><span class="s" id="mwA7Q">"Value: {}"</span><span class="p" id="mwA7U">,</span><span class="w" id="mwA7Y"> </span><span class="n" id="mwA7c">value</span><span class="p" id="mwA7g">);</span> <span class="w" id="mwA7k"> </span><span class="p" id="mwA7o">}</span> <span class="p" id="mwA7s">}</span><span class="w" id="mwA7w"> </span><span class="n" id="mwA70">obj</span><span class="p" id="mwA74">;</span> <span class="n" id="mwA78">obj</span><span class="p" id="mwA8A">.</span><span class="n" id="mwA8E">setValue</span><span class="p" id="mwA8I">(</span><span class="mi" id="mwA8M">15</span><span class="p" id="mwA8Q">);</span> <span class="kt" id="mwA8U">int</span><span class="w" id="mwA8Y"> </span><span class="n" id="mwA8c">x</span><span class="w" id="mwA8g"> </span><span class="o" id="mwA8k">=</span><span class="w" id="mwA8o"> </span><span class="n" id="mwA8s">obj</span><span class="p" id="mwA8w">.</span><span class="n" id="mwA80">getValue</span><span class="p" id="mwA84">();</span> <span class="n" id="mwA88">obj</span><span class="p" id="mwA9A">.</span><span class="n" id="mwA9E">display</span><span class="p" id="mwA9I">();</span><span class="w" id="mwA9M"> </span><span class="c1" id="mwA9Q">// Value: 15</span>Java-style anonymous subclasses may be similarly emulated:
<span id="mwA9k"></span><span class="k" id="mwA9o">using</span><span class="w" id="mwA9s"> </span><span class="n" id="mwA9w">std</span><span class="o" id="mwA90">::</span><span class="n" id="mwA94">chrono</span><span class="o" id="mwA98">::</span><span class="n" id="mwA-A">system_clock</span><span class="p" id="mwA-E">;</span> <span class="c1" id="mwA-I">// An interface-like class</span> <span class="k" id="mwA-M">class</span><span class="w" id="mwA-Q"> </span><span class="nc" id="mwA-U">Speaking</span><span class="w" id="mwA-Y"> </span><span class="p" id="mwA-c">{</span> <span class="k" id="mwA-g">public</span><span class="o" id="mwA-k">:</span> <span class="w" id="mwA-o"> </span><span class="k" id="mwA-s">virtual</span><span class="w" id="mwA-w"> </span><span class="kt" id="mwA-0">void</span><span class="w" id="mwA-4"> </span><span class="n" id="mwA-8">speak</span><span class="p" id="mwA_A">()</span><span class="w" id="mwA_E"> </span><span class="o" id="mwA_I">=</span><span class="w" id="mwA_M"> </span><span class="mi" id="mwA_Q">0</span><span class="p" id="mwA_U">;</span> <span class="p" id="mwA_Y">};</span> <span class="c1" id="mwA_c">// Implementing the Speaking "interface"</span> <span class="nl" id="mwA_g">class</span><span class="w" id="mwA_k"> </span><span class="p" id="mwA_o">:</span><span class="w" id="mwA_s"> </span><span class="k" id="mwA_w">public</span><span class="w" id="mwA_0"> </span><span class="n" id="mwA_4">Speaking</span><span class="w" id="mwA_8"> </span><span class="p" id="mwBAA">{</span> <span class="k" id="mwBAE">public</span><span class="o" id="mwBAI">:</span> <span class="w" id="mwBAM"> </span><span class="kt" id="mwBAQ">void</span><span class="w" id="mwBAU"> </span><span class="n" id="mwBAY">speak</span><span class="p" id="mwBAc">()</span><span class="w" id="mwBAg"> </span><span class="k" id="mwBAk">override</span><span class="w" id="mwBAo"> </span><span class="p" id="mwBAs">{</span> <span class="w" id="mwBAw"> </span><span class="n" id="mwBA0">std</span><span class="o" id="mwBA4">::</span><span class="n" id="mwBA8">println</span><span class="p" id="mwBBA">(</span><span class="s" id="mwBBE">"The current time is {}"</span><span class="p" id="mwBBI">,</span><span class="w" id="mwBBM"> </span><span class="n" id="mwBBQ">system_clock</span><span class="o" id="mwBBU">::</span><span class="n" id="mwBBY">now</span><span class="p" id="mwBBc">());</span> <span class="w" id="mwBBg"> </span><span class="p" id="mwBBk">}</span> <span class="p" id="mwBBo">}</span><span class="w" id="mwBBs"> </span><span class="n" id="mwBBw">timeTeller</span><span class="p" id="mwBB0">;</span>Lambdas in C++ are similar to an anonymous class; they are in fact function objects, which have a compiler-generated name and implement an operator().
Overloaded operators
In C++, operators, such as + - * /, can be overloaded to suit the needs of programmers. These operators are called overloadable operators.
By convention, overloaded operators should behave nearly the same as they do in built-in datatypes (int, float, etc.), but this is not required. One can declare a structure called Integer in which the variable really stores an integer, but by calling Integer * Integer the sum, instead of the product, of the integers might be returned:
<span id="mwBDU"></span><span class="k" id="mwBDY">struct</span><span class="w" id="mwBDc"> </span><span class="nc" id="mwBDg">Integer</span><span class="w" id="mwBDk"> </span><span class="p" id="mwBDo">{</span> <span class="w" id="mwBDs"> </span><span class="kt" id="mwBDw">int</span><span class="w" id="mwBD0"> </span><span class="n" id="mwBD4">i</span><span class="w" id="mwBD8"> </span><span class="o" id="mwBEA">=</span><span class="w" id="mwBEE"> </span><span class="mi" id="mwBEI">0</span><span class="p" id="mwBEM">;</span> <span class="w" id="mwBEQ"> </span><span class="n" id="mwBEU">Integer</span><span class="p" id="mwBEY">()</span><span class="w" id="mwBEc"> </span><span class="o" id="mwBEg">=</span><span class="w" id="mwBEk"> </span><span class="k" id="mwBEo">default</span><span class="p" id="mwBEs">;</span> <span class="w" id="mwBEw"> </span><span class="n" id="mwBE0">Integer</span><span class="p" id="mwBE4">(</span><span class="kt" id="mwBE8">int</span><span class="w" id="mwBFA"> </span><span class="n" id="mwBFE">i</span><span class="p" id="mwBFI">)</span><span class="o" id="mwBFM">:</span><span class="w" id="mwBFQ"> </span> <span class="w" id="mwBFU"> </span><span class="n" id="mwBFY">i</span><span class="p" id="mwBFc">{</span><span class="n" id="mwBFg">i</span><span class="p" id="mwBFk">}</span><span class="w" id="mwBFo"> </span><span class="p" id="mwBFs">{}</span> <span class="w" id="mwBFw"> </span><span class="n" id="mwBF0">Integer</span><span class="w" id="mwBF4"> </span><span class="k" id="mwBF8">operator</span><span class="o" id="mwBGA">*</span><span class="p" id="mwBGE">(</span><span class="k" id="mwBGI">const</span><span class="w" id="mwBGM"> </span><span class="n" id="mwBGQ">Integer</span><span class="o" id="mwBGU">&</span><span class="w" id="mwBGY"> </span><span class="n" id="mwBGc">rhs</span><span class="p" id="mwBGg">)</span><span class="w" id="mwBGk"> </span><span class="k" id="mwBGo">const</span><span class="w" id="mwBGs"> </span><span class="p" id="mwBGw">{</span> <span class="w" id="mwBG0"> </span><span class="k" id="mwBG4">return</span><span class="w" id="mwBG8"> </span><span class="n" id="mwBHA">Integer</span><span class="p" id="mwBHE">(</span><span class="n" id="mwBHI">i</span><span class="w" id="mwBHM"> </span><span class="o" id="mwBHQ">+</span><span class="w" id="mwBHU"> </span><span class="n" id="mwBHY">rhs</span><span class="p" id="mwBHc">.</span><span class="n" id="mwBHg">i</span><span class="p" id="mwBHk">);</span> <span class="w" id="mwBHo"> </span><span class="p" id="mwBHs">}</span> <span class="p" id="mwBHw">};</span>The code above made use of a constructor to "construct" the return value. For clearer presentation (although this could decrease efficiency of the program if the compiler cannot optimize the statement into the equivalent one above), the above code can be rewritten as:
<span id="mwBIA"></span><span class="k" id="mwBIE">struct</span><span class="w" id="mwBII"> </span><span class="nc" id="mwBIM">Integer</span><span class="w" id="mwBIQ"> </span><span class="p" id="mwBIU">{</span> <span class="w" id="mwBIY"> </span><span class="c1" id="mwBIc">// ...</span> <span class="w" id="mwBIg"> </span><span class="n" id="mwBIk">Integer</span><span class="w" id="mwBIo"> </span><span class="k" id="mwBIs">operator</span><span class="o" id="mwBIw">*</span><span class="p" id="mwBI0">(</span><span class="k" id="mwBI4">const</span><span class="w" id="mwBI8"> </span><span class="n" id="mwBJA">Integer</span><span class="o" id="mwBJE">&</span><span class="w" id="mwBJI"> </span><span class="n" id="mwBJM">rhs</span><span class="p" id="mwBJQ">)</span><span class="w" id="mwBJU"> </span><span class="k" id="mwBJY">const</span><span class="w" id="mwBJc"> </span><span class="p" id="mwBJg">{</span> <span class="w" id="mwBJk"> </span><span class="n" id="mwBJo">Integer</span><span class="w" id="mwBJs"> </span><span class="n" id="mwBJw">m</span><span class="p" id="mwBJ0">;</span> <span class="w" id="mwBJ4"> </span><span class="n" id="mwBJ8">m</span><span class="p" id="mwBKA">.</span><span class="n" id="mwBKE">i</span><span class="w" id="mwBKI"> </span><span class="o" id="mwBKM">=</span><span class="w" id="mwBKQ"> </span><span class="n" id="mwBKU">i</span><span class="w" id="mwBKY"> </span><span class="o" id="mwBKc">+</span><span class="w" id="mwBKg"> </span><span class="n" id="mwBKk">rhs</span><span class="p" id="mwBKo">.</span><span class="n" id="mwBKs">i</span><span class="p" id="mwBKw">;</span> <span class="w" id="mwBK0"> </span><span class="k" id="mwBK4">return</span><span class="w" id="mwBK8"> </span><span class="n" id="mwBLA">m</span><span class="p" id="mwBLE">;</span> <span class="w" id="mwBLI"> </span><span class="p" id="mwBLM">}</span> <span class="p" id="mwBLQ">};</span>Programmers can also put a prototype of the operator in the struct declaration and define the function of the operator in the global scope:
<span id="mwBLk"></span><span class="k" id="mwBLo">struct</span><span class="w" id="mwBLs"> </span><span class="nc" id="mwBLw">Integer</span><span class="w" id="mwBL0"> </span><span class="p" id="mwBL4">{</span> <span class="w" id="mwBL8"> </span><span class="kt" id="mwBMA">int</span><span class="w" id="mwBME"> </span><span class="n" id="mwBMI">i</span><span class="w" id="mwBMM"> </span><span class="o" id="mwBMQ">=</span><span class="w" id="mwBMU"> </span><span class="mi" id="mwBMY">0</span><span class="p" id="mwBMc">;</span> <span class="w" id="mwBMg"> </span><span class="n" id="mwBMk">Integer</span><span class="p" id="mwBMo">()</span><span class="w" id="mwBMs"> </span><span class="o" id="mwBMw">=</span><span class="w" id="mwBM0"> </span><span class="k" id="mwBM4">default</span><span class="p" id="mwBM8">;</span> <span class="w" id="mwBNA"> </span><span class="n" id="mwBNE">Integer</span><span class="p" id="mwBNI">(</span><span class="kt" id="mwBNM">int</span><span class="w" id="mwBNQ"> </span><span class="n" id="mwBNU">i</span><span class="p" id="mwBNY">)</span><span class="o" id="mwBNc">:</span><span class="w" id="mwBNg"> </span> <span class="w" id="mwBNk"> </span><span class="n" id="mwBNo">i</span><span class="p" id="mwBNs">{</span><span class="n" id="mwBNw">i</span><span class="p" id="mwBN0">}</span><span class="w" id="mwBN4"> </span><span class="p" id="mwBN8">{}</span> <span class="w" id="mwBOA"> </span><span class="n" id="mwBOE">Integer</span><span class="w" id="mwBOI"> </span><span class="k" id="mwBOM">operator</span><span class="o" id="mwBOQ">*</span><span class="p" id="mwBOU">(</span><span class="k" id="mwBOY">const</span><span class="w" id="mwBOc"> </span><span class="n" id="mwBOg">Integer</span><span class="o" id="mwBOk">&</span><span class="w" id="mwBOo"> </span><span class="n" id="mwBOs">rhs</span><span class="p" id="mwBOw">)</span><span class="w" id="mwBO0"> </span><span class="k" id="mwBO4">const</span><span class="p" id="mwBO8">;</span> <span class="p" id="mwBPA">};</span> <span class="w" id="mwBPE"> </span> <span class="n" id="mwBPI">Integer</span><span class="w" id="mwBPM"> </span><span class="n" id="mwBPQ">Integer</span><span class="o" id="mwBPU">::</span><span class="k" id="mwBPY">operator</span><span class="o" id="mwBPc">*</span><span class="p" id="mwBPg">(</span><span class="k" id="mwBPk">const</span><span class="w" id="mwBPo"> </span><span class="n" id="mwBPs">Integer</span><span class="o" id="mwBPw">&</span><span class="w" id="mwBP0"> </span><span class="n" id="mwBP4">rhs</span><span class="p" id="mwBP8">)</span><span class="w" id="mwBQA"> </span><span class="k" id="mwBQE">const</span><span class="w" id="mwBQI"> </span><span class="p" id="mwBQM">{</span> <span class="w" id="mwBQQ"> </span><span class="k" id="mwBQU">return</span><span class="w" id="mwBQY"> </span><span class="n" id="mwBQc">Integer</span><span class="p" id="mwBQg">(</span><span class="n" id="mwBQk">i</span><span class="w" id="mwBQo"> </span><span class="o" id="mwBQs">*</span><span class="w" id="mwBQw"> </span><span class="n" id="mwBQ0">rhs</span><span class="p" id="mwBQ4">.</span><span class="n" id="mwBQ8">i</span><span class="p" id="mwBRA">);</span> <span class="p" id="mwBRE">}</span>i above represents the sender's own member variable, while rhs.i represents the member variable from the argument variable rhs.
The const keyword appears twice in the above code. The first occurrence, the argument const integer& rhs, indicated that the argument variable will not be changed by the function. The second incidence at the end of the declaration promises the compiler that the sender would not be changed by the function run.
In const integer& rhs, the ampersand (&) means "pass by reference". When the function is called, a reference to the variable will be passed to the function, rather than the value of the variable.
Note that associativity and precedence of operators cannot be changed.
Binary overloadable operators
Binary operators (operators with two arguments) are overloaded by declaring a function with an "identifier" operator (something) which calls one single argument. The variable on the left of the operator is the sender while that on the right is the argument.
<span id="mwBSc"></span><span class="n" id="mwBSg">Integer</span><span class="w" id="mwBSk"> </span><span class="n" id="mwBSo">i</span><span class="w" id="mwBSs"> </span><span class="o" id="mwBSw">=</span><span class="w" id="mwBS0"> </span><span class="mi" id="mwBS4">1</span><span class="p" id="mwBS8">;</span> <span class="c1" id="mwBTA">// we can initialize a structure variable this way as</span> <span class="c1" id="mwBTE">// if calling a constructor with only the first</span> <span class="c1" id="mwBTI">// argument specified.</span> <span class="n" id="mwBTM">Integer</span><span class="w" id="mwBTQ"> </span><span class="n" id="mwBTU">j</span><span class="w" id="mwBTY"> </span><span class="o" id="mwBTc">=</span><span class="w" id="mwBTg"> </span><span class="mi" id="mwBTk">3</span><span class="p" id="mwBTo">;</span> <span class="c1" id="mwBTs">// variable names are independent of the names of the</span> <span class="c1" id="mwBTw">// member variables of the structure.</span> <span class="n" id="mwBT0">Integer</span><span class="w" id="mwBT4"> </span><span class="n" id="mwBT8">k</span><span class="w" id="mwBUA"> </span><span class="o" id="mwBUE">=</span><span class="w" id="mwBUI"> </span><span class="n" id="mwBUM">i</span><span class="w" id="mwBUQ"> </span><span class="o" id="mwBUU">*</span><span class="w" id="mwBUY"> </span><span class="n" id="mwBUc">j</span><span class="p" id="mwBUg">;</span> <span class="n" id="mwBUk">std</span><span class="o" id="mwBUo">::</span><span class="n" id="mwBUs">println</span><span class="p" id="mwBUw">(</span><span class="s" id="mwBU0">"{}"</span><span class="p" id="mwBU4">,</span><span class="w" id="mwBU8"> </span><span class="n" id="mwBVA">k</span><span class="p" id="mwBVE">.</span><span class="n" id="mwBVI">i</span><span class="p" id="mwBVM">);</span>'3' would be printed.
The following is a list of binary overloadable operators:
The '=' (assignment) operator between two variables of the same structure type is overloaded by default to copy the entire content of the variables from one to another. It can be overwritten with something else, if necessary.
Operators must be overloaded one by one, in other words, no overloading is associated with one another. For example, < is not necessarily the opposite of >.
Unary overloadable operators
While some operators, as specified above, takes two terms, sender on the left and the argument on the right, some operators have only one argument - the sender, and they are said to be "unary". Examples are the negative sign (when nothing is put on the left of it) and the "logical NOT" (exclamation mark, !).
Sender of unary operators may be on the left or on the right of the operator. The following is a list of unary overloadable operators:
The syntax of an overloading of a unary operator, where the sender is on the right, is as follows:
T operatorX()
When the sender is on the left, the declaration is:
T operatorX(int)
X above stands for the operator to be overloaded. Replace T with the datatype of the return value (int, bool, structures etc.)
The int parameter essentially means nothing but a convention to show that the sender is on the left of the operator.
const arguments can be added to the end of the declaration if applicable.
Overloading brackets
The square bracket [] and the round bracket () can be overloaded in C++ classes. The square bracket must contain exactly one argument, initialiser list (since C++11) or arbitrary parameter pack (since C++23), while the round bracket can contain any specific number of arguments, or no arguments.
The following declaration overloads the square bracket.
T operator[] (x1, x2, ...))
The content inside the bracket is specified in the argument part.
Round bracket is overloaded a similar way.
T operator() (x1, x2, ...)
Contents of the bracket in the operator call are specified in the second bracket.
In addition to the operators specified above, the arrow operator (->), the starred arrow (->*), the new keyword and the delete keyword can also be overloaded. These memory-or-pointer-related operators must process memory-allocating functions after overloading. Like the assignment (=) operator, they are also overloaded by default if no specific declaration is made.
Constructors
Sometimes programmers may want their variables to take a default or specific value upon declaration. This can be done by declaring constructors.
<span id="mwBdc"></span><span class="k" id="mwBdg">using</span><span class="w" id="mwBdk"> </span><span class="n" id="mwBdo">std</span><span class="o" id="mwBds">::</span><span class="n" id="mwBdw">string</span><span class="p" id="mwBd0">;</span> <span class="k" id="mwBd4">class</span><span class="w" id="mwBd8"> </span><span class="nc" id="mwBeA">Person</span><span class="w" id="mwBeE"> </span><span class="p" id="mwBeI">{</span> <span class="k" id="mwBeM">private</span><span class="o" id="mwBeQ">:</span> <span class="w" id="mwBeU"> </span><span class="n" id="mwBeY">string</span><span class="w" id="mwBec"> </span><span class="n" id="mwBeg">name</span><span class="p" id="mwBek">;</span> <span class="w" id="mwBeo"> </span><span class="kt" id="mwBes">int</span><span class="w" id="mwBew"> </span><span class="n" id="mwBe0">age</span><span class="p" id="mwBe4">;</span> <span class="k" id="mwBe8">public</span><span class="o" id="mwBfA">:</span> <span class="w" id="mwBfE"> </span><span class="n" id="mwBfI">Person</span><span class="p" id="mwBfM">(</span><span class="n" id="mwBfQ">string</span><span class="w" id="mwBfU"> </span><span class="n" id="mwBfY">name</span><span class="p" id="mwBfc">,</span><span class="w" id="mwBfg"> </span><span class="kt" id="mwBfk">int</span><span class="w" id="mwBfo"> </span><span class="n" id="mwBfs">age</span><span class="p" id="mwBfw">)</span><span class="w" id="mwBf0"> </span><span class="p" id="mwBf4">{</span> <span class="w" id="mwBf8"> </span><span class="k" id="mwBgA">this</span><span class="o" id="mwBgE">-></span><span class="n" id="mwBgI">name</span><span class="w" id="mwBgM"> </span><span class="o" id="mwBgQ">=</span><span class="w" id="mwBgU"> </span><span class="n" id="mwBgY">name</span><span class="p" id="mwBgc">;</span> <span class="w" id="mwBgg"> </span><span class="k" id="mwBgk">this</span><span class="o" id="mwBgo">-></span><span class="n" id="mwBgs">age</span><span class="w" id="mwBgw"> </span><span class="o" id="mwBg0">=</span><span class="w" id="mwBg4"> </span><span class="n" id="mwBg8">age</span><span class="p" id="mwBhA">;</span> <span class="w" id="mwBhE"> </span><span class="p" id="mwBhI">}</span> <span class="p" id="mwBhM">};</span>Member variables can be initialized in an initializer list, with utilization of a colon, as in the example below. This differs from the above in that it initializes (using the constructor), rather than using the assignment operator. This is more efficient for class types, since it just needs to be constructed directly; whereas with assignment, they must be first initialized using the default constructor, and then assigned a different value. Thus, member initialization is typically preferred over constructor body assignment whenever possible. Also some types (like references and const types) cannot be assigned to and therefore must be initialized in the initializer list.
<span id="mwBhw"></span><span class="k" id="mwBh0">using</span><span class="w" id="mwBh4"> </span><span class="n" id="mwBh8">std</span><span class="o" id="mwBiA">::</span><span class="n" id="mwBiE">string</span><span class="p" id="mwBiI">;</span> <span class="k" id="mwBiM">class</span><span class="w" id="mwBiQ"> </span><span class="nc" id="mwBiU">Person</span><span class="w" id="mwBiY"> </span><span class="p" id="mwBic">{</span> <span class="k" id="mwBig">private</span><span class="o" id="mwBik">:</span> <span class="w" id="mwBio"> </span><span class="n" id="mwBis">string</span><span class="w" id="mwBiw"> </span><span class="n" id="mwBi0">name</span><span class="p" id="mwBi4">;</span> <span class="w" id="mwBi8"> </span><span class="kt" id="mwBjA">int</span><span class="w" id="mwBjE"> </span><span class="n" id="mwBjI">age</span><span class="p" id="mwBjM">;</span> <span class="k" id="mwBjQ">public</span><span class="o" id="mwBjU">:</span> <span class="w" id="mwBjY"> </span><span class="n" id="mwBjc">Person</span><span class="p" id="mwBjg">(</span><span class="n" id="mwBjk">string</span><span class="w" id="mwBjo"> </span><span class="n" id="mwBjs">name</span><span class="p" id="mwBjw">,</span><span class="w" id="mwBj0"> </span><span class="kt" id="mwBj4">int</span><span class="w" id="mwBj8"> </span><span class="n" id="mwBkA">age</span><span class="p" id="mwBkE">)</span><span class="o" id="mwBkI">:</span> <span class="w" id="mwBkM"> </span><span class="n" id="mwBkQ">name</span><span class="p" id="mwBkU">{</span><span class="n" id="mwBkY">name</span><span class="p" id="mwBkc">},</span><span class="w" id="mwBkg"> </span><span class="n" id="mwBkk">age</span><span class="p" id="mwBko">{</span><span class="n" id="mwBks">age</span><span class="p" id="mwBkw">}</span><span class="w" id="mwBk0"> </span><span class="p" id="mwBk4">{}</span> <span class="p" id="mwBk8">};</span>Note that the curly braces cannot be omitted, even if empty.
Default values can be given to the last arguments to help initializing default values.
<span id="mwBlQ"></span><span class="k" id="mwBlU">using</span><span class="w" id="mwBlY"> </span><span class="n" id="mwBlc">std</span><span class="o" id="mwBlg">::</span><span class="n" id="mwBlk">string</span><span class="p" id="mwBlo">;</span> <span class="k" id="mwBls">class</span><span class="w" id="mwBlw"> </span><span class="nc" id="mwBl0">Person</span><span class="w" id="mwBl4"> </span><span class="p" id="mwBl8">{</span> <span class="w" id="mwBmA"> </span><span class="c1" id="mwBmE">// ...</span> <span class="w" id="mwBmI"> </span><span class="n" id="mwBmM">Person</span><span class="p" id="mwBmQ">(</span><span class="n" id="mwBmU">string</span><span class="w" id="mwBmY"> </span><span class="n" id="mwBmc">name</span><span class="w" id="mwBmg"> </span><span class="o" id="mwBmk">=</span><span class="w" id="mwBmo"> </span><span class="s" id="mwBms">""</span><span class="p" id="mwBmw">,</span><span class="w" id="mwBm0"> </span><span class="kt" id="mwBm4">int</span><span class="w" id="mwBm8"> </span><span class="n" id="mwBnA">age</span><span class="w" id="mwBnE"> </span><span class="o" id="mwBnI">=</span><span class="w" id="mwBnM"> </span><span class="mi" id="mwBnQ">0</span><span class="p" id="mwBnU">)</span><span class="o" id="mwBnY">:</span><span class="w" id="mwBnc"> </span> <span class="w" id="mwBng"> </span><span class="n" id="mwBnk">name</span><span class="p" id="mwBno">{</span><span class="n" id="mwBns">name</span><span class="p" id="mwBnw">},</span><span class="w" id="mwBn0"> </span><span class="n" id="mwBn4">age</span><span class="p" id="mwBn8">{</span><span class="n" id="mwBoA">age</span><span class="p" id="mwBoE">}</span><span class="w" id="mwBoI"> </span><span class="p" id="mwBoM">{}</span> <span class="p" id="mwBoQ">};</span>When no arguments are given to the constructor in the example above, it is equivalent to calling the following constructor with no arguments (a default constructor):
<span id="mwBog"></span><span class="k" id="mwBok">using</span><span class="w" id="mwBoo"> </span><span class="n" id="mwBos">std</span><span class="o" id="mwBow">::</span><span class="n" id="mwBo0">string</span><span class="p" id="mwBo4">;</span> <span class="k" id="mwBo8">class</span><span class="w" id="mwBpA"> </span><span class="nc" id="mwBpE">Person</span><span class="w" id="mwBpI"> </span><span class="p" id="mwBpM">{</span> <span class="w" id="mwBpQ"> </span><span class="c1" id="mwBpU">// ...</span> <span class="w" id="mwBpY"> </span><span class="n" id="mwBpc">Person</span><span class="p" id="mwBpg">()</span><span class="o" id="mwBpk">:</span> <span class="w" id="mwBpo"> </span><span class="n" id="mwBps">name</span><span class="p" id="mwBpw">{</span><span class="s" id="mwBp0">""</span><span class="p" id="mwBp4">},</span><span class="w" id="mwBp8"> </span><span class="n" id="mwBqA">age</span><span class="p" id="mwBqE">{</span><span class="mi" id="mwBqI">0</span><span class="p" id="mwBqM">}</span><span class="w" id="mwBqQ"> </span><span class="p" id="mwBqU">{}</span> <span class="p" id="mwBqY">};</span>The declaration of a constructor looks like a function with the same name as the datatype. In fact, a call to a constructor can take the form of a function call. In that case an initialized Person type variable can be thought of as the return value:
<span id="mwBqs"></span><span class="kt" id="mwBqw">int</span><span class="w" id="mwBq0"> </span><span class="nf" id="mwBq4">main</span><span class="p" id="mwBq8">()</span><span class="w" id="mwBrA"> </span><span class="p" id="mwBrE">{</span> <span class="w" id="mwBrI"> </span><span class="n" id="mwBrM">Person</span><span class="w" id="mwBrQ"> </span><span class="n" id="mwBrU">r</span><span class="w" id="mwBrY"> </span><span class="o" id="mwBrc">=</span><span class="w" id="mwBrg"> </span><span class="n" id="mwBrk">Person</span><span class="p" id="mwBro">(</span><span class="s" id="mwBrs">"Wales"</span><span class="p" id="mwBrw">,</span><span class="w" id="mwBr0"> </span><span class="mi" id="mwBr4">40</span><span class="p" id="mwBr8">);</span> <span class="w" id="mwBsA"> </span><span class="n" id="mwBsE">r</span><span class="p" id="mwBsI">.</span><span class="n" id="mwBsM">print</span><span class="p" id="mwBsQ">();</span> <span class="p" id="mwBsU">}</span>An alternate syntax that does the same thing as the above example is
<span id="mwBsk"></span><span class="kt" id="mwBso">int</span><span class="w" id="mwBss"> </span><span class="nf" id="mwBsw">main</span><span class="p" id="mwBs0">()</span><span class="w" id="mwBs4"> </span><span class="p" id="mwBs8">{</span> <span class="w" id="mwBtA"> </span><span class="n" id="mwBtE">Person</span><span class="w" id="mwBtI"> </span><span class="n" id="mwBtM">r</span><span class="p" id="mwBtQ">(</span><span class="s" id="mwBtU">"Wales"</span><span class="p" id="mwBtY">,</span><span class="w" id="mwBtc"> </span><span class="mi" id="mwBtg">40</span><span class="p" id="mwBtk">);</span> <span class="w" id="mwBto"> </span><span class="n" id="mwBts">r</span><span class="p" id="mwBtw">.</span><span class="n" id="mwBt0">printData</span><span class="p" id="mwBt4">();</span> <span class="p" id="mwBt8">}</span>Specific program actions, which may or may not relate to the variable, can be added inside the constructor body.
<span id="mwBuM"></span><span class="k" id="mwBuQ">using</span><span class="w" id="mwBuU"> </span><span class="n" id="mwBuY">std</span><span class="o" id="mwBuc">::</span><span class="n" id="mwBug">string</span><span class="p" id="mwBuk">;</span> <span class="k" id="mwBuo">class</span><span class="w" id="mwBus"> </span><span class="nc" id="mwBuw">Person</span><span class="w" id="mwBu0"> </span><span class="p" id="mwBu4">{</span> <span class="w" id="mwBu8"> </span><span class="c1" id="mwBvA">// ...</span> <span class="w" id="mwBvE"> </span><span class="n" id="mwBvI">Person</span><span class="p" id="mwBvM">(</span><span class="n" id="mwBvQ">string</span><span class="w" id="mwBvU"> </span><span class="n" id="mwBvY">name</span><span class="p" id="mwBvc">,</span><span class="w" id="mwBvg"> </span><span class="kt" id="mwBvk">int</span><span class="w" id="mwBvo"> </span><span class="n" id="mwBvs">age</span><span class="p" id="mwBvw">)</span><span class="o" id="mwBv0">:</span> <span class="w" id="mwBv4"> </span><span class="n" id="mwBv8">name</span><span class="p" id="mwBwA">{</span><span class="n" id="mwBwE">name</span><span class="p" id="mwBwI">},</span><span class="w" id="mwBwM"> </span><span class="n" id="mwBwQ">age</span><span class="p" id="mwBwU">{</span><span class="n" id="mwBwY">age</span><span class="p" id="mwBwc">}</span><span class="w" id="mwBwg"> </span><span class="p" id="mwBwk">{</span> <span class="w" id="mwBwo"> </span><span class="n" id="mwBws">std</span><span class="o" id="mwBww">::</span><span class="n" id="mwBw0">println</span><span class="p" id="mwBw4">(</span><span class="s" id="mwBw8">"Hello! My name is {} and I am {} years old."</span><span class="p" id="mwBxA">,</span><span class="w" id="mwBxE"> </span><span class="n" id="mwBxI">name</span><span class="p" id="mwBxM">,</span><span class="w" id="mwBxQ"> </span><span class="n" id="mwBxU">age</span><span class="p" id="mwBxY">);</span> <span class="w" id="mwBxc"> </span><span class="p" id="mwBxg">};</span> <span class="p" id="mwBxk">}</span>With the above constructor, a "Hello!" will be printed when the default Person constructor is invoked.
Default constructor
Default constructors are called when constructors are not defined for the classes.
<span id="mwByA"></span><span class="k" id="mwByE">struct</span><span class="w" id="mwByI"> </span><span class="nc" id="mwByM">Scalar</span><span class="w" id="mwByQ"> </span><span class="p" id="mwByU">{</span> <span class="w" id="mwByY"> </span><span class="kt" id="mwByc">int</span><span class="w" id="mwByg"> </span><span class="n" id="mwByk">i</span><span class="p" id="mwByo">;</span> <span class="p" id="mwBys">};</span> <span class="c1" id="mwByw">// Object created using parentheses.</span> <span class="n" id="mwBy0">Scalar</span><span class="o" id="mwBy4">*</span><span class="w" id="mwBy8"> </span><span class="n" id="mwBzA">a</span><span class="w" id="mwBzE"> </span><span class="o" id="mwBzI">=</span><span class="w" id="mwBzM"> </span><span class="k" id="mwBzQ">new</span><span class="w" id="mwBzU"> </span><span class="n" id="mwBzY">Scalar</span><span class="p" id="mwBzc">();</span><span class="w" id="mwBzg"> </span><span class="c1" id="mwBzk">// Calls default constructor, and b will be initialized with '0'.</span> <span class="c1" id="mwBzo">// Object created using no parentheses.</span> <span class="n" id="mwBzs">Scalar</span><span class="o" id="mwBzw">*</span><span class="w" id="mwBz0"> </span><span class="n" id="mwBz4">b</span><span class="w" id="mwBz8"> </span><span class="o" id="mwB0A">=</span><span class="w" id="mwB0E"> </span><span class="k" id="mwB0I">new</span><span class="w" id="mwB0M"> </span><span class="n" id="mwB0Q">Scalar</span><span class="p" id="mwB0U">;</span><span class="w" id="mwB0Y"> </span><span class="c1" id="mwB0c">// Allocate memory, then call default constructor, and b will have value '0'.</span> <span class="c1" id="mwB0g">// Object creation without new.</span> <span class="n" id="mwB0k">Scalar</span><span class="w" id="mwB0o"> </span><span class="n" id="mwB0s">c</span><span class="p" id="mwB0w">;</span><span class="w" id="mwB00"> </span><span class="c1" id="mwB04">// Reserve space for a on the stack, and b will have an unknown garbage value.</span> <span class="c1" id="mwB08">// Allocated objects must be de-allocated</span> <span class="k" id="mwB1A">delete</span><span class="w" id="mwB1E"> </span><span class="n" id="mwB1I">a</span><span class="p" id="mwB1M">;</span> <span class="k" id="mwB1Q">delete</span><span class="w" id="mwB1U"> </span><span class="n" id="mwB1Y">b</span><span class="p" id="mwB1c">;</span>However, if a user-defined constructor was defined for the class, both of the above declarations will call this user-defined constructor, whose defined code will be executed, but no default values will be assigned to the variable b.
The default constructor provided by the compiler can be kept by using = default;, while it may also be explicitly disabled using = delete;. This is also true of any other compiler-generated special member functions.
Destructors
A destructor is the inverse of a constructor. It is called when an instance of a class is destroyed, e.g. when an object of a class created in a block (set of curly braces "{}") is deleted after the closing brace, then the destructor is called automatically. It will be called upon emptying of the memory location storing the variables. Destructors can be used to release resources, such as heap-allocated memory and opened files when an instance of that class is destroyed.
The syntax for declaring a destructor is similar to that of a constructor. There is no return value and the name of the function is the same as the name of the class with a tilde (~) in front.
<span id="mwB2w"></span><span class="k" id="mwB20">class</span><span class="w" id="mwB24"> </span><span class="nc" id="mwB28">Person</span><span class="w" id="mwB3A"> </span><span class="p" id="mwB3E">{</span> <span class="w" id="mwB3I"> </span><span class="c1" id="mwB3M">// ...</span> <span class="w" id="mwB3Q"> </span><span class="o" id="mwB3U">~</span><span class="n" id="mwB3Y">Person</span><span class="p" id="mwB3c">()</span><span class="w" id="mwB3g"> </span><span class="p" id="mwB3k">{</span> <span class="w" id="mwB3o"> </span><span class="n" id="mwB3s">std</span><span class="o" id="mwB3w">::</span><span class="n" id="mwB30">println</span><span class="p" id="mwB34">(</span><span class="s" id="mwB38">"I'm deleting {} with age {}"</span><span class="p" id="mwB4A">,</span><span class="w" id="mwB4E"> </span><span class="n" id="mwB4I">name</span><span class="p" id="mwB4M">,</span><span class="w" id="mwB4Q"> </span><span class="n" id="mwB4U">age</span><span class="p" id="mwB4Y">);</span> <span class="w" id="mwB4c"> </span><span class="p" id="mwB4g">}</span> <span class="p" id="mwB4k">}</span>Similarities between constructors and destructors
- Both have same name as the class in which they are declared.
- If not declared by user both are available in a class by default but they now can only allocate and deallocate memory from the objects of a class when an object is declared or deleted.
- For a derived class: During the runtime of the base class constructor, the derived class constructor has not yet been called; during the runtime of the base class destructor, the derived class destructor has already been called. In both cases, the derived class member variables are in an invalid state.
Class templates
In C++, class declarations can be generated from class templates. Such class templates represent a family of classes. An actual class declaration is obtained by instantiating the template with one or more template arguments. A template instantiated with a particular set of arguments is called a template specialization.
Properties
The syntax of C++ tries to make every aspect of a class look like that of the basic datatypes. Therefore, overloaded operators allow classes to be manipulated just like integers and floating-point numbers, arrays of classes can be declared with the square-bracket syntax (X a[N] = { /* ... */ };, where X is the name of the class, a is the name of the array and N is its length), and pointers to classes can be dereferenced in the same way as pointers to built-in datatypes.
Memory consumption
The memory consumption of a structure is at least the sum of the memory sizes of constituent variables. Take the Point structure below as an example.
<span id="mwB7A"></span><span class="k" id="mwB7E">struct</span><span class="w" id="mwB7I"> </span><span class="nc" id="mwB7M">Point</span><span class="w" id="mwB7Q"> </span><span class="p" id="mwB7U">{</span> <span class="w" id="mwB7Y"> </span><span class="kt" id="mwB7c">int</span><span class="w" id="mwB7g"> </span><span class="n" id="mwB7k">x</span><span class="p" id="mwB7o">;</span> <span class="w" id="mwB7s"> </span><span class="kt" id="mwB7w">int</span><span class="w" id="mwB70"> </span><span class="n" id="mwB74">y</span><span class="p" id="mwB78">;</span> <span class="p" id="mwB8A">};</span>The structure consists of two integers. In many current C++ compilers, integers are 32-bit integers by default, so each of the member variables consume four bytes of memory. The entire structure, therefore, consumes at least (or exactly) eight bytes of memory, as follows.
+----+----+ | x | y | +----+----+
However, the compiler may add padding between the variables or at the end of the structure to ensure proper data alignment for a given computer architecture, often padding variables to be 32-bit aligned. For example, the structure
<span id="mwB8g"></span><span class="k" id="mwB8k">struct</span><span class="w" id="mwB8o"> </span><span class="nc" id="mwB8s">Data</span><span class="w" id="mwB8w"> </span><span class="p" id="mwB80">{</span><span class="w" id="mwB84"> </span> <span class="w" id="mwB88"> </span><span class="kt" id="mwB9A">char</span><span class="w" id="mwB9E"> </span><span class="n" id="mwB9I">p</span><span class="p" id="mwB9M">;</span> <span class="w" id="mwB9Q"> </span><span class="kt" id="mwB9U">char</span><span class="w" id="mwB9Y"> </span><span class="n" id="mwB9c">q</span><span class="p" id="mwB9g">;</span> <span class="w" id="mwB9k"> </span><span class="kt" id="mwB9o">char</span><span class="w" id="mwB9s"> </span><span class="n" id="mwB9w">r</span><span class="p" id="mwB90">;</span> <span class="w" id="mwB94"> </span><span class="kt" id="mwB98">short</span><span class="w" id="mwB-A"> </span><span class="n" id="mwB-E">s</span><span class="p" id="mwB-I">;</span> <span class="w" id="mwB-M"> </span><span class="kt" id="mwB-Q">int</span><span class="w" id="mwB-U"> </span><span class="n" id="mwB-Y">i</span><span class="p" id="mwB-c">;</span> <span class="w" id="mwB-g"> </span><span class="kt" id="mwB-k">double</span><span class="w" id="mwB-o"> </span><span class="n" id="mwB-s">d</span><span class="p" id="mwB-w">;</span> <span class="p" id="mwB-0">};</span>may be represented as
+-+-+-+-+--+--+----+--------+ |p|q|r|X|s |XX| i | d | +-+-+-+-+--+--+----+--------+
in memory, where X represents padded bytes based on 4 bytes alignment.
As structures may make use of pointers and arrays to declare and initialize its member variables, memory consumption of structures is not necessarily constant. Another example of non-constant memory size is template structures.
Bit fields
Bit fields are used to define the class members that can occupy less storage than an integral type. This field is applicable only for integral types (int, char, short, long, etc.) and enumeration types (e.g. std::byte, an non-algebraic enum representing raw numeric data) and excludes float or double.
<span id="mwCAA"></span><span class="k" id="mwCAE">struct</span><span class="w" id="mwCAI"> </span><span class="nc" id="mwCAM">Data</span><span class="w" id="mwCAQ"> </span><span class="p" id="mwCAU">{</span><span class="w" id="mwCAY"> </span> <span class="w" id="mwCAc"> </span><span class="kt" id="mwCAg">uint32_t</span><span class="w" id="mwCAk"> </span><span class="n" id="mwCAo">a</span><span class="o" id="mwCAs">:</span><span class="w" id="mwCAw"> </span><span class="mi" id="mwCA0">2</span><span class="p" id="mwCA4">;</span><span class="w" id="mwCA8"> </span><span class="c1" id="mwCBA">// Possible values 0..3, occupies first 2 bits of int</span> <span class="w" id="mwCBE"> </span><span class="kt" id="mwCBI">uint32_t</span><span class="w" id="mwCBM"> </span><span class="n" id="mwCBQ">b</span><span class="o" id="mwCBU">:</span><span class="w" id="mwCBY"> </span><span class="mi" id="mwCBc">3</span><span class="p" id="mwCBg">;</span><span class="w" id="mwCBk"> </span><span class="c1" id="mwCBo">// Possible values 0..7, occupies next 3 bits of int</span> <span class="w" id="mwCBs"> </span><span class="nl" id="mwCBw">uint32_t</span><span class="w" id="mwCB0"> </span><span class="p" id="mwCB4">:</span><span class="w" id="mwCB8"> </span><span class="mi" id="mwCCA">0</span><span class="p" id="mwCCE">;</span><span class="w" id="mwCCI"> </span><span class="c1" id="mwCCM">// Moves to end of next integral type</span> <span class="w" id="mwCCQ"> </span><span class="kt" id="mwCCU">uint32_t</span><span class="w" id="mwCCY"> </span><span class="n" id="mwCCc">c</span><span class="o" id="mwCCg">:</span><span class="w" id="mwCCk"> </span><span class="mi" id="mwCCo">2</span><span class="p" id="mwCCs">;</span> <span class="w" id="mwCCw"> </span><span class="nl" id="mwCC0">uint32_t</span><span class="w" id="mwCC4"> </span><span class="p" id="mwCC8">:</span><span class="w" id="mwCDA"> </span><span class="mi" id="mwCDE">4</span><span class="p" id="mwCDI">;</span><span class="w" id="mwCDM"> </span><span class="c1" id="mwCDQ">// Pads 4 bits in between c & d</span> <span class="w" id="mwCDU"> </span><span class="kt" id="mwCDY">uint32_t</span><span class="w" id="mwCDc"> </span><span class="n" id="mwCDg">d</span><span class="o" id="mwCDk">:</span><span class="w" id="mwCDo"> </span><span class="mi" id="mwCDs">1</span><span class="p" id="mwCDw">;</span> <span class="w" id="mwCD0"> </span><span class="kt" id="mwCD4">uint32_t</span><span class="w" id="mwCD8"> </span><span class="n" id="mwCEA">e</span><span class="o" id="mwCEE">:</span><span class="w" id="mwCEI"> </span><span class="mi" id="mwCEM">3</span><span class="p" id="mwCEQ">;</span> <span class="p" id="mwCEU">};</span>- Memory structure
4 byte int 4 byte int [1][2][3][4][5][6][7][8] [1] [2] [3] [4] [a][a][b][b][b][ ][ ][ ] [ ][ ][ ][ ][ ][ ][ ][ ] [ ][ ][ ][ ][ ][ ][ ][ ] [ ][ ][ ][ ][ ][ ][ ][ ] [5] [6] [7] [8] [c][c][ ][ ][ ][ ][d][e] [e][e][ ][ ][ ][ ][ ][ ] [ ][ ][ ][ ][ ][ ][ ][ ] [ ][ ][ ][ ][ ][ ][ ][ ]
Unions are also allowed to have bit-field members:
<span id="mwCEw"></span><span class="k" id="mwCE0">union</span><span class="w" id="mwCE4"> </span><span class="nc" id="mwCE8">Data</span><span class="w" id="mwCFA"> </span><span class="p" id="mwCFE">{</span><span class="w" id="mwCFI"> </span> <span class="w" id="mwCFM"> </span><span class="kt" id="mwCFQ">uint32_t</span><span class="w" id="mwCFU"> </span><span class="n" id="mwCFY">a</span><span class="o" id="mwCFc">:</span><span class="w" id="mwCFg"> </span><span class="mi" id="mwCFk">2</span><span class="p" id="mwCFo">;</span> <span class="w" id="mwCFs"> </span><span class="kt" id="mwCFw">uint32_t</span><span class="w" id="mwCF0"> </span><span class="n" id="mwCF4">b</span><span class="o" id="mwCF8">:</span><span class="w" id="mwCGA"> </span><span class="mi" id="mwCGE">3</span><span class="p" id="mwCGI">;</span> <span class="w" id="mwCGM"> </span><span class="nl" id="mwCGQ">uint32_t</span><span class="w" id="mwCGU"> </span><span class="p" id="mwCGY">:</span><span class="w" id="mwCGc"> </span><span class="mi" id="mwCGg">0</span><span class="p" id="mwCGk">;</span><span class="w" id="mwCGo"> </span><span class="c1" id="mwCGs">// Does nothing</span> <span class="w" id="mwCGw"> </span><span class="kt" id="mwCG0">uint32_t</span><span class="w" id="mwCG4"> </span><span class="n" id="mwCG8">c</span><span class="o" id="mwCHA">:</span><span class="w" id="mwCHE"> </span><span class="mi" id="mwCHI">2</span><span class="p" id="mwCHM">;</span><span class="w" id="mwCHQ"> </span> <span class="w" id="mwCHU"> </span><span class="nl" id="mwCHY">uint32_t</span><span class="w" id="mwCHc"> </span><span class="p" id="mwCHg">:</span><span class="w" id="mwCHk"> </span><span class="mi" id="mwCHo">4</span><span class="p" id="mwCHs">;</span><span class="w" id="mwCHw"> </span><span class="c1" id="mwCH0">// Does nothing in this case; if the bit-field's width were large enough, it would change the union's size to fit</span> <span class="w" id="mwCH4"> </span><span class="kt" id="mwCH8">uint32_t</span><span class="w" id="mwCIA"> </span><span class="n" id="mwCIE">d</span><span class="o" id="mwCII">:</span><span class="w" id="mwCIM"> </span><span class="mi" id="mwCIQ">1</span><span class="p" id="mwCIU">;</span> <span class="w" id="mwCIY"> </span><span class="kt" id="mwCIc">uint32_t</span><span class="w" id="mwCIg"> </span><span class="n" id="mwCIk">e</span><span class="o" id="mwCIo">:</span><span class="w" id="mwCIs"> </span><span class="mi" id="mwCIw">3</span><span class="p" id="mwCI0">;</span> <span class="p" id="mwCI4">};</span>Pass by reference
Many programmers prefer to use the ampersand (&) to declare the arguments of a function involving structures. This is because by using the dereferencing ampersand only one word (typically 4 bytes on a 32-bit machine, 8 bytes on a 64-bit machine) is required to be passed into the function, namely the memory location to the variable. Otherwise, if pass-by-value is used, the argument needs to be copied every time the function is called, which is costly with large structures.
Since pass-by-reference exposes the original structure to be modified by the function, the const keyword should be used to guarantee that the function does not modify the parameter (see const-correctness), when this is not intended.