{"id":1157,"date":"2024-08-22T18:58:54","date_gmt":"2024-08-22T18:58:54","guid":{"rendered":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/?page_id=1157"},"modified":"2025-02-10T22:45:46","modified_gmt":"2025-02-10T22:45:46","slug":"const-reference-and-static-members","status":"publish","type":"page","link":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/topics\/c-details\/classes\/const-reference-and-static-members\/","title":{"rendered":"const, Reference, and static Members"},"content":{"rendered":"\n

<\/span>const, Reference, and static Members<\/span><\/h2>\n\n\n\n

<\/span>const Members<\/span><\/h3>\n\n\n\n

C++ has:<\/p>\n\n\n\n

    \n
  • const<\/strong> data members<\/li>\n\n\n\n
  • const<\/strong> member functions<\/li>\n<\/ul>\n\n\n\n

    <\/span>const Data Members<\/span><\/h4>\n\n\n\n

    It should be clear that a const<\/strong> data member<\/em> of a class:<\/p>\n\n\n\n

      \n
    • must be initialized<\/em> (possibly via a default constructor) in the containing class constructors<\/li>\n\n\n\n
    • may not change <\/em>during the lifetime of the class instance (that’s the meaning of const<\/strong>)<\/li>\n<\/ul>\n\n\n\n

      This can be useful;  it is too seldom used!<\/p>\n\n\n\n

      <\/span>const Member Functions<\/span><\/h4>\n\n\n\n

      So, what is a const<\/strong> <\/em>member function<\/em>?<\/p>\n\n\n\n

        \n
      • It’s a member function that promises not to modify its class instance.<\/li>\n\n\n\n
      • So, all member functions which are accessor functions should be declared const.<\/li>\n\n\n\n
      • Also, member functions like Print() (etc.) should be declared const.<\/li>\n<\/ul>\n\n\n\n

        Here’s the syntax:<\/p>\n\n\n\n

        class Complex\n{\n\t\/\/ ...\n\tvoid Print() const<\/strong>;\n\tdouble GetReal() const<\/strong> { return real; }\n\tdouble GetImag() const<\/strong> { return imag; }\n\t\/\/ ...\n};\n<\/code><\/pre>\n\n\n\n
        where the const<\/strong> is placed after<\/em> the function argument list, and before<\/em> the function body.<\/p>\n\n\n\n
        <\/span>Example:<\/span><\/h5>\n\n\n\n
        Let’s use our Complex<\/strong> class from the previous Complex<\/code>\/ComplexLine<\/code> example:<\/p>\n\n\n\n
        \n
        \n
        <\/path><\/path><\/svg><\/span>
        \/\/<\/span><\/span>\n\/\/  main.cpp<\/span><\/span>\n\/\/  Member Class Objects<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/22\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span>"Complex.h"<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span> <\/span>argv<\/span>[]) <\/span><\/span>\n{<\/span><\/span>\n  ComplexLine line1;<\/span><\/span>\n  <\/span>line1<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n  <\/span><\/span>\n  ComplexLine <\/span>line2<\/span>(<\/span>Complex<\/span>(<\/span>2.0<\/span>, <\/span>1.5<\/span>),<\/span><\/span>\n                    <\/span>Complex<\/span>(<\/span>3.9<\/span>, <\/span>2.5<\/span>));<\/span><\/span>\n  <\/span>line2<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n  <\/span><\/span>\n  <\/span>const<\/span> Complex <\/span>c<\/span>(<\/span>3.4<\/span>, <\/span>5.6<\/span>);<\/span>  \t\/\/ OK<\/span><\/span>\n\t<\/span>c<\/span>.<\/span>Print<\/span>();\t<\/span><\/span>\n\t<\/span><\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
        \n
        But it gives a compile time error:<\/p>\n\n\n\n
        main.cpp:21:3 'this' argument to member function 'Print' has type 'const Complex', but function is not marked const\n\n<\/code><\/pre>\n<\/div>\n<\/div>\n\n\n\n
        Since the C++ compiler takes us seriously when we say const<\/strong>, it doesn’t know that the Print()<\/strong> member function won’t change the instance.<\/p>\n\n\n\n
        By adding const<\/strong>, we are telling the compiler that the member function will not change anything in the instance.<\/p>\n\n\n\n
        Note that the compiler will check the member function implementation to ensure that it does not change anything!<\/p>\n\n\n\n
        \n
        \n
        We fix the problem by simply adding ‘const’ to the declaration of member function Print:<\/p>\n\n\n\n
        <\/path><\/path><\/svg><\/span>
          <\/span>void<\/span> <\/span>Print<\/span>() <\/span>const<\/span>;<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
        … and also to its definition:<\/p>\n\n\n\n
        <\/path><\/path><\/svg><\/span>
        void<\/span> <\/span>Complex<\/span>::<\/span>Print<\/span>() <\/span>const<\/span><\/span>\n{<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"Complex: ["<\/span> << m_real << <\/span>", "<\/span> << m_imag << <\/span>"]"<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
        \n
        The program now compiles and runs correctly.
        <\/p>\n<\/div>\n<\/div>\n\n\n\n
        The this<\/strong> pointer for a const<\/strong> member function of class T<\/strong> is declared thusly:<\/p>\n\n\n\n
        const T * const this;\t\/\/ meaning?<\/strong><\/code><\/pre>\n\n\n\n
        which enforces the rules for code inside the const member function.<\/p>\n\n\n\n
        <\/span>Breaking the Rules<\/span><\/h4>\n\n\n\n
        There are times when you would like a member function to be:<\/p>\n\n\n\n
        ‘physically const<\/strong>‘<\/p>\n\n\n\n
          \n
        • It truly does not change its instance.<\/li>\n\n\n\n
        • Typical, straightforward usage.<\/li>\n<\/ul>\n\n\n\n
          <\/span>Logical const-ness<\/span><\/h5>\n\n\n\n
          There are other times when you would like a member function to be:<\/p>\n\n\n\n
          ‘logically const<\/strong>‘<\/p>\n\n\n\n
            \n
          • It appears to the outside world not to change its instance<\/li>\n\n\n\n
          • In fact, it does change something in the instance (an implementation detail?)<\/li>\n\n\n\n
          • To do this, one must explicitly cast the this<\/strong> pointer:<\/li>\n<\/ul>\n\n\n\n
            double Real() const\n{\n    ((Complex *)this)->real_accesses++; \/\/ Count of accesses (instrumentation)\n    return real;\n}<\/strong><\/code><\/pre>\n\n\n\n
            \n
            Clearly, this is something to do only if circumstances warrant. It should not be normal usage — especially not to get your program to compile in order to get around a problem you don’t yet understand.<\/em><\/p>\n\n\n\n
            It is typically useful for keeping track of things like method invocation counts, and similar things.<\/p>\n<\/blockquote>\n\n\n\n
            <\/span>mutable Data Members<\/span><\/h4>\n\n\n\n
            The C++ standard has now blessed this as a supported practice. They have introduced the keyword mutable, that allows a member variable of a const<\/strong> object to be modified. It\u2019s used to specify that a particular data member of a const<\/strong> object can be modified without affecting the object\u2019s const<\/strong>-ness. <\/p>\n\n\n\n
            Here’s an example:<\/p>\n\n\n\n
            \n
            \n
            <\/path><\/path><\/svg><\/span>
            \/\/<\/span><\/span>\n\/\/  Toys.hpp<\/span><\/span>\n\/\/  const, volatile, mutable<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 2\/10\/25.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#<\/span>ifndef<\/span> <\/span>Toys_hpp<\/span><\/span>\n#<\/span>define<\/span> <\/span>Toys_hpp<\/span><\/span>\n<\/span>\n#<\/span>include<\/span> <<\/span>string<\/span>><\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Toy<\/span><\/span>\n{<\/span><\/span>\npublic<\/span>:<\/span><\/span>\n  <\/span>Toy<\/span>(<\/span>std<\/span>::<\/span>string<\/span>& <\/span>name<\/span>);<\/span><\/span>\n  <\/span><\/span>\n  <\/span>std<\/span>::<\/span>string<\/span>& <\/span>getName<\/span>() <\/span>const<\/span>;<\/span><\/span>\n  <\/span><\/span>\n  <\/span>int<\/span> <\/span>getAccessCount<\/span>() const;<\/span><\/span>\n    <\/span><\/span>\nprivate<\/span>:<\/span><\/span>\n    <\/span>std<\/span>::<\/span>string<\/span>& <\/span>m_name<\/span>;<\/span><\/span>\n    <\/span>mutable<\/span> <\/span>int<\/span> <\/span>m_accessCount<\/span> = <\/span>0<\/span>;<\/span><\/span>\n};<\/span><\/span>\n<\/span>\n#<\/span>endif<\/span> <\/span>\/* Toys_hpp *\/<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
            \n
            <\/path><\/path><\/svg><\/span>
            \/\/<\/span><\/span>\n\/\/  Toys.cpp<\/span><\/span>\n\/\/  const, volatile, mutable<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 2\/10\/25.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#<\/span>include<\/span> <\/span>"Toys.hpp"<\/span><\/span>\n<\/span>\nToy::<\/span>Toy<\/span>(<\/span>std<\/span>::<\/span>string<\/span>& <\/span>name<\/span>)<\/span><\/span>\n  : <\/span>m_name<\/span>(<\/span>name<\/span>)<\/span><\/span>\n{}<\/span><\/span>\n<\/span>\nstd::<\/span>string<\/span>& Toy::<\/span>getName<\/span>() <\/span>const<\/span><\/span>\n{<\/span><\/span>\n  <\/span>m_accessCount<\/span>++;<\/span><\/span>\n  <\/span>return<\/span> <\/span>m_name<\/span>;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nint<\/span> Toy::<\/span>getAccessCount<\/span>() <\/span>const<\/span><\/span>\n{<\/span><\/span>\n  <\/span>return<\/span> <\/span>m_accessCount<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n<\/div>\n\n\n\n
            \n
            \n
            Here’s a main program to run this code:<\/p>\n\n\n\n
            <\/path><\/path><\/svg><\/span>
            \/\/<\/span><\/span>\n\/\/  main.cpp<\/span><\/span>\n\/\/  const, volatile, mutable<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 2\/10\/25.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#<\/span>include<\/span> <<\/span>iostream<\/span>><\/span><\/span>\n#<\/span>include<\/span> <<\/span>array<\/span>><\/span><\/span>\n#<\/span>include<\/span> <\/span>"Toys.hpp"<\/span><\/span>\n<\/span>\nvoid<\/span> <\/span>listToys<\/span>(<\/span>const<\/span> <\/span>Toy<\/span> &<\/span>firstToy<\/span>, <\/span>const<\/span> <\/span>Toy<\/span> &<\/span>secondToy<\/span>)<\/span><\/span>\n{<\/span><\/span>\n  std::<\/span>cout<\/span> << <\/span>"Toy [1] : "<\/span> << <\/span>firstToy<\/span>.<\/span>getName<\/span>() << std::<\/span>endl<\/span>;<\/span><\/span>\n  std::<\/span>cout<\/span> << <\/span>"Toy [2] : "<\/span> << <\/span>secondToy<\/span>.<\/span>getName<\/span>() << std::<\/span>endl<\/span>;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>const<\/span> <\/span>char<\/span> * <\/span>argv<\/span>[]) <\/span><\/span>\n{<\/span><\/span>\n  <\/span>static<\/span> std::<\/span>string<\/span> <\/span>Train<\/span>(<\/span>"Train"<\/span>);<\/span><\/span>\n  <\/span>const<\/span> <\/span>Toy<\/span> train(Train);<\/span><\/span>\n<\/span>\n  <\/span>static<\/span> std::<\/span>string<\/span> <\/span>Barbie<\/span>(<\/span>"Barbie"<\/span>);<\/span><\/span>\n  <\/span>const<\/span> <\/span>Toy<\/span> doll(Barbie);<\/span><\/span>\n  <\/span><\/span>\n  <\/span>listToys<\/span>(<\/span>train<\/span>, <\/span>doll<\/span>);<\/span><\/span>\n  <\/span><\/span>\n  std::<\/span>cout<\/span> << <\/span>"Number of accesses to: "<\/span> << <\/span>train<\/span>.<\/span>getName<\/span>() << <\/span>" = "<\/span> << <\/span>train<\/span>.<\/span>getAccessCount<\/span>() << std::<\/span>endl<\/span>;<\/span><\/span>\n  std::<\/span>cout<\/span> << <\/span>"Number of accesses to: "<\/span> << <\/span>doll<\/span>.<\/span>getName<\/span>() << <\/span>" = "<\/span> << <\/span>doll<\/span>.<\/span>getAccessCount<\/span>() << std::<\/span>endl<\/span>;<\/span><\/span>\n<\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
            \n
            Here is what the main program outputs:<\/p>\n\n\n\n
            Toy [1] : Train
            Toy [2] : Barbie
            Number of accesses to: Train = 2
            Number of accesses to: Barbie = 2
            Program ended with exit code: 0<\/p>\n\n\n\n
            Note the use of the mutable<\/strong> keyword in the Toys.hpp<\/strong> header file, and the use of const<\/strong> in the main program.<\/p>\n<\/div>\n<\/div>\n\n\n\n
            \n
            The mutable keyword is useful in several scenarios:<\/p>\n\n\n\n
              \n
            1. Caching<\/li>\n\n\n\n
            2. Lazy evaluation<\/li>\n\n\n\n
            3. Thread synchronization<\/li>\n\n\n\n
            4. Maintaining logical const<\/strong>-ness<\/li>\n<\/ol>\n<\/blockquote>\n\n\n\n
              <\/span>static Members<\/span><\/h3>\n\n\n\n
              A class may contain static<\/strong> members.<\/p>\n\n\n\n
              A static <\/strong>data member<\/em><\/strong>:<\/em><\/p>\n\n\n\n
                \n
              • Has only a single instance per class <\/em>(actually per class hierarchy)<\/li>\n\n\n\n
              • Is shared by all instances of its class<\/li>\n\n\n\n
              • Exists even if no instances of that class (yet) exist.<\/li>\n\n\n\n
              • Must be initialized<\/em> outside its class<\/li>\n<\/ul>\n\n\n\n
                A static <\/strong>member function<\/em><\/strong>:<\/em><\/p>\n\n\n\n
                  \n
                • Is not associated with any specific instance of its class (it is associated with the class, not an instance)<\/li>\n\n\n\n
                • Can be called whether or not any instances of the class (yet) exist<\/li>\n\n\n\n
                • Does not have any this<\/strong> pointer (it’s not associated with an instance)<\/li>\n<\/ul>\n\n\n\n
                  static<\/strong> members are still subject to access control (private<\/strong>\/public<\/strong>)<\/p>\n\n\n\n
                  <\/span>Example:<\/span><\/h4>\n\n\n\n
                  Here is a Person<\/code> class that collects a population of people, and reports on its current state, giving the current population, and a census of the people in that population:<\/p>\n\n\n\n
                  \n
                  NOTE<\/strong>: This class uses a simple implementation of a linked list to keep track of the people in its current population. I do not recommend this approach for your code; C++ has, in its Standard Template Library (STL) many useful implementations of structures and algorithms, including a linked list, and many more. It would be far better to use an STL linked list, or similar.<\/p>\n\n\n\n
                  The problem is that we haven’t yet learned how to use the STL, and that takes a while to master. <\/p>\n\n\n\n
                  All in due time…<\/p>\n<\/blockquote>\n\n\n\n
                  Note that this class contains three static data members (first<\/code>, last<\/code>, and count<\/code>) to keep track of the population and census, and two static member functions that allow the reporting of the population and census.<\/p>\n\n\n\n
                  Remember that a single instance of each of these static data members and static member functions exists, independent of how many instances of the Person<\/code> class exist, or even if there are none.<\/p>\n\n\n\n
                  \n
                  \n
                  <\/path><\/path><\/svg><\/span>
                  \/\/<\/span><\/span>\n\/\/  Person.hpp<\/span><\/span>\n\/\/  Static Members<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/23\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#ifndef<\/span> Person_hpp<\/span><\/span>\n#define<\/span> Person_hpp<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Person<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  \/\/ static member functions<\/span><\/span>\n  <\/span>static<\/span> <\/span>unsigned<\/span> <\/span>int<\/span> <\/span>Population<\/span>() { <\/span>return<\/span> count; }<\/span><\/span>\n  <\/span>static<\/span> <\/span>void<\/span> <\/span>Census<\/span>();<\/span><\/span>\n<\/span>\n  \/\/ Non-static member functions<\/span><\/span>\n  <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span>Name<\/span>() <\/span>const<\/span>     { <\/span>return<\/span> name; }<\/span><\/span>\n<\/span>\n  \/\/ No default constructor<\/span><\/span>\n    <\/span><\/span>\n  \/\/ Constructor with one argument<\/span><\/span>\n  <\/span>Person<\/span>(<\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span>n<\/span>);<\/span><\/span>\n    <\/span><\/span>\n  \/\/ Destructor<\/span><\/span>\n  <\/span>~Person<\/span>();<\/span><\/span>\n<\/span>\nprivate:<\/span><\/span>\n  \/\/ static data members<\/span><\/span>\n  <\/span>static<\/span> Person       *first;<\/span>    \/\/ List header<\/span><\/span>\n  <\/span>static<\/span> Person       *last;<\/span>    \/\/  ...<\/span><\/span>\n    <\/span><\/span>\n  <\/span>static<\/span> <\/span>unsigned<\/span> <\/span>int<\/span>  count;<\/span>    \/\/ Number in list<\/span><\/span>\n<\/span>\n  \/\/ Non-static data members<\/span><\/span>\n  Person              *next;<\/span>    \/\/ Item in list<\/span><\/span>\n  Person              *prev;<\/span>    \/\/  ...<\/span><\/span>\n<\/span>\n  <\/span>char<\/span>                *name;<\/span>    \/\/ Person's name<\/span><\/span>\n};<\/span><\/span>\n<\/span>\n#endif<\/span> \/* Person_hpp *\/<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                  \n
                  <\/path><\/path><\/svg><\/span>
                  \/\/<\/span><\/span>\n\/\/  Person.cpp<\/span><\/span>\n\/\/  Static Members<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/23\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><stdio.h><\/span><\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span>"Person.hpp"<\/span><\/span>\n<\/span>\n\/\/ Initialize static data members<\/span><\/span>\nPerson *<\/span>Person<\/span>::first = <\/span>0<\/span>;<\/span><\/span>\nPerson *<\/span>Person<\/span>::last  = <\/span>0<\/span>;<\/span><\/span>\nunsigned<\/span> <\/span>int<\/span> <\/span>Person<\/span>::count = <\/span>0<\/span>;<\/span><\/span>\n<\/span>\n\/\/ Constructor<\/span><\/span>\nPerson<\/span>::<\/span>Person<\/span>(<\/span>const<\/span> <\/span>char<\/span> *n)<\/span><\/span>\n  : <\/span>name<\/span>(<\/span>new<\/span> <\/span>char<\/span>[<\/span>strlen<\/span>(n) + <\/span>1<\/span>])<\/span><\/span>\n{<\/span><\/span>\n  \/\/ Insert this into the linked<\/span><\/span>\n  \/\/ list, at the end of the list.<\/span><\/span>\n  <\/span>if<\/span> (first == <\/span>0<\/span>)<\/span>   \/\/ first in list?<\/span><\/span>\n  {<\/span><\/span>\n    first = <\/span>this<\/span>;<\/span><\/span>\n    last  = <\/span>this<\/span>;<\/span><\/span>\n    prev  = <\/span>0<\/span>;<\/span><\/span>\n  }<\/span><\/span>\n  <\/span>else<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>last<\/span>-><\/span>next<\/span> = <\/span>this<\/span>;<\/span><\/span>\n    prev = last;<\/span><\/span>\n    last = <\/span>this<\/span>;<\/span><\/span>\n  }<\/span><\/span>\n  next = <\/span>0<\/span>;<\/span><\/span>\n  count++;<\/span>    \/\/ one more in list<\/span><\/span>\n  <\/span>strcpy<\/span>(name, n);<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n\/\/ Destructor<\/span><\/span>\nPerson<\/span>::~<\/span>Person<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  \/\/ Remove this from the linked list<\/span><\/span>\n  <\/span>if<\/span> (prev == <\/span>0<\/span>)<\/span>  \/\/ first in list?<\/span><\/span>\n     first = next;<\/span><\/span>\n  <\/span>else<\/span><\/span>\n     <\/span>prev<\/span>-><\/span>next<\/span> = next;<\/span><\/span>\n  <\/span>if<\/span> (next == <\/span>0<\/span>)<\/span>  \/\/ last in list?<\/span><\/span>\n     last = prev;<\/span><\/span>\n  <\/span>else<\/span><\/span>\n     <\/span>next<\/span>-><\/span>prev<\/span> = prev;<\/span><\/span>\n  --count;<\/span>      \/\/ one fewer in list<\/span><\/span>\n  <\/span>delete<\/span> <\/span>[]<\/span> name;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n\/\/ static member function<\/span><\/span>\nvoid<\/span> <\/span>Person<\/span>::<\/span>Census<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"Current census:"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n  <\/span>for<\/span> (Person *p = first; p != <\/span>0<\/span>; p = <\/span>p<\/span>-><\/span>next<\/span>)<\/span><\/span>\n  {<\/span><\/span>\n     <\/span>std<\/span>::cout << <\/span>p<\/span>-><\/span>Name<\/span>() << <\/span>std<\/span>::endl;<\/span><\/span>\n  }<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n<\/div>\n\n\n\n
                  \n
                  \n
                  Here’s a test program for trying this out:<\/p>\n\n\n\n
                  <\/path><\/path><\/svg><\/span>
                  \/\/<\/span><\/span>\n\/\/  main.cpp<\/span><\/span>\n\/\/  Static Members<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/23\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span>"Person.hpp"<\/span><\/span>\n<\/span>\n\/\/ Regular function to report on the current population<\/span><\/span>\nvoid<\/span> <\/span>report<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"Current population: "<\/span><\/span>\n        << <\/span>Person<\/span>::<\/span>Population<\/span>() << <\/span>std<\/span>::endl;<\/span><\/span>\n  <\/span>Person<\/span>::<\/span>Census<\/span>();<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nvoid<\/span> <\/span>sub<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  Person <\/span>bs<\/span>(<\/span>"Bjarne Stroustrup"<\/span>);<\/span><\/span>\n  Person <\/span>ed<\/span>(<\/span>"Edsger Dijkstra"<\/span>);<\/span><\/span>\n  <\/span>report<\/span>();<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span> <\/span>argv<\/span>[])<\/span><\/span>\n{<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"report();"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n  <\/span>report<\/span>();<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"sub();"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n  <\/span>sub<\/span>();<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"report();"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n  <\/span>report<\/span>();<\/span><\/span>\n  <\/span><\/span>\n  Person *bc = <\/span>new<\/span> <\/span>Person<\/span>(<\/span>"Brad Cox"<\/span>);<\/span><\/span>\n  Person *al = <\/span>new<\/span> <\/span>Person<\/span>(<\/span>"Ada Lovelace"<\/span>);<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"report();"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n  <\/span>report<\/span>();<\/span><\/span>\n  <\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"deleting Bjarne and Ada"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n  <\/span>delete<\/span> bc;<\/span><\/span>\n  <\/span>delete<\/span> al;<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"report();"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n  <\/span>report<\/span>();<\/span><\/span>\n  <\/span><\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                  \n
                  … and here is what it outputs:<\/p>\n\n\n\n
                  report();\nCurrent population: 0\nCurrent census:\nsub();\nCurrent population: 2\nCurrent census:\nBjarne Stroustrup\nEdsger Dijkstra\nreport();\nCurrent population: 0\nCurrent census:\nreport();\nCurrent population: 2\nCurrent census:\nBrad Cox\nAda Lovelace\ndeleting Bjarne and Ada\nreport();\nCurrent population: 0\nCurrent census:\nProgram ended with exit code: 0<\/code><\/pre>\n<\/div>\n<\/div>\n\n\n\n
                  When used properly:<\/p>\n\n\n\n
                    \n
                  • static<\/strong> data members can replace global data<\/em><\/li>\n\n\n\n
                  • static<\/strong> member functions can replace global functions<\/em><\/li>\n<\/ul>\n\n\n\n
                    All while retaining encapsulation and data abstraction.<\/p>\n\n\n\n
                    \n
                    Think about how you might be able to use static class members!<\/em><\/strong> <\/p>\n\n\n\n
                    They can be extremely useful when used properly.<\/p>\n<\/blockquote>\n","protected":false},"excerpt":{"rendered":"
                    const, Reference, and static Members const Members C++ has: const Data Members It should be clear that a const data member of a class: This can be useful;  it is too seldom used! const Member Functions So, what is a const member function? Here’s the syntax: where the const is placed after the function argument […]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":1901,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"","meta":{"footnotes":""},"class_list":["post-1157","page","type-page","status-publish","hentry"],"blocksy_meta":[],"_links":{"self":[{"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages\/1157","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/comments?post=1157"}],"version-history":[{"count":3,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages\/1157\/revisions"}],"predecessor-version":[{"id":2257,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages\/1157\/revisions\/2257"}],"up":[{"embeddable":true,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages\/1901"}],"wp:attachment":[{"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/media?parent=1157"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}