{"id":920,"date":"2024-08-09T20:19:27","date_gmt":"2024-08-09T20:19:27","guid":{"rendered":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/?page_id=920"},"modified":"2025-01-26T18:21:30","modified_gmt":"2025-01-26T18:21:30","slug":"c-classes","status":"publish","type":"page","link":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/topics\/c-details\/classes\/c-classes\/","title":{"rendered":"What Are Classes?"},"content":{"rendered":"\n

<\/span>What Are Classes?<\/span><\/h2>\n\n\n\n

Here are the basics of C++ Classes. In particular:<\/p>\n\n\n\n

    \n
  • Declarations and Definitions<\/li>\n\n\n\n
  • Member Functions <\/li>\n\n\n\n
  • Constructors and Destructors<\/li>\n<\/ul>\n\n\n\n

    <\/span>Class Declarations<\/span><\/h3>\n\n\n\n

    Here\u2019s a simple class declaration<\/em> for a complex number:<\/p>\n\n\n\n

    \n
    \n
    <\/path><\/path><\/svg><\/span>
    \/\/ complex.h<\/span><\/span>\nclass<\/span> <\/span>Complex<\/span> <\/span><\/span>\n{ <\/span><\/span>\npublic:<\/span>    <\/span><\/span>\n  \/\/ sets values    <\/span><\/span>\n  <\/span>void<\/span> <\/span>set<\/span>(<\/span>const<\/span> <\/span>double<\/span> <\/span>r<\/span>, <\/span><\/span>\n           <\/span>const<\/span> <\/span>double<\/span> <\/span>i<\/span>);<\/span><\/span>\n<\/span>\n  \/\/ prints values<\/span><\/span>\n  <\/span>void<\/span> <\/span>print<\/span>();<\/span><\/span>\n<\/span>\nprivate:<\/span>    <\/span><\/span>\n    <\/span>double<\/span> real, imag; <\/span><\/span>\n};<\/span>\t\t\/\/ end of class declaration (semicolon required)<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
    \n
    It consists of:<\/p>\n\n\n\n
      \n
    • A class name<\/em>, Complex<\/strong><\/li>\n\n\n\n
    • Several class members<\/em>:<\/li>\n\n\n\n
    • data members<\/em> real<\/strong> and imag<\/strong>, and <\/li>\n\n\n\n
    • member functions<\/em> set<\/strong> and print<\/strong><\/li>\n\n\n\n
    • Access specifiers<\/em> private<\/strong> and public<\/strong><\/li>\n<\/ul>\n\n\n\n
      NOTE:<\/strong> A class declaration<\/em> is typically placed in a header file<\/em>.<\/p>\n<\/div>\n<\/div>\n\n\n\n
      And here\u2019s its corresponding class definition<\/em>:<\/p>\n\n\n\n
      \n
      \n
      <\/path><\/path><\/svg><\/span>
      \/\/ complex.cpp<\/span><\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span>"complex.h"<\/span>\t<\/span>\/\/ Note!<\/span><\/span>\n<\/span>\nvoid<\/span> <\/span>Complex<\/span>::<\/span>set<\/span>(<\/span>const<\/span> <\/span>double<\/span> <\/span>r<\/span>, <\/span><\/span>\n                  <\/span>const<\/span> <\/span>double<\/span> <\/span>i<\/span>)    <\/span><\/span>\n{ <\/span><\/span>\n  real = r; <\/span><\/span>\n  imag = i; <\/span><\/span>\n}    <\/span><\/span>\n<\/span>\nvoid<\/span> <\/span>Complex<\/span>::<\/span>print<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>'('<\/span> << real<\/span><\/span>\n            << <\/span>','<\/span> << imag << <\/span>')'<\/span><\/span>\n            << <\/span>std<\/span>::endl;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
      \n
        \n
      • It must <\/em>#include<\/em><\/strong> the class header file<\/em>.<\/li>\n\n\n\n
      • It contains the implementation<\/em> of the class member functions<\/em>.<\/li>\n<\/ul>\n\n\n\n
        NOTE:<\/strong>  A class definition is typically placed in one or more <\/em>.cpp<\/em><\/strong> files<\/em>.<\/p>\n<\/div>\n<\/div>\n\n\n\n
        Here\u2019s how the class might be used:<\/p>\n\n\n\n
        \n
        \n
        <\/path><\/path><\/svg><\/span>
        \/\/ testComplex.cpp<\/span><\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span>"complex.h"<\/span>\t<\/span>\/\/ Note!<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>() <\/span><\/span>\n{ <\/span><\/span>\n  Complex a;<\/span><\/span>\n<\/span>\n  <\/span>a<\/span>.<\/span>set<\/span>(<\/span>27.5<\/span>, <\/span>13.4<\/span>); <\/span><\/span>\n  <\/span>a<\/span>.<\/span>print<\/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
          \n
        • NOTE:<\/strong>\n
            \n
          • It must #include<\/strong> the class header file.<\/li>\n\n\n\n
          • In this case, the Complex a;<\/strong> produces a local, auto instance<\/em> of class Complex<\/strong>.<\/li>\n\n\n\n
          • In this case, it calls both of the member functions of class Complex<\/strong>, set<\/strong> and print<\/strong>, applied to a<\/strong>.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n\n\n\n
            It outputs:<\/p>\n\n\n\n
            (27.5,13.4)<\/code><\/pre>\n<\/div>\n<\/div>\n\n\n\n
            <\/span>class versus struct<\/span><\/h3>\n\n\n\n
            A class<\/strong> is similar to a C struct<\/strong>:<\/p>\n\n\n\n
              \n
            • It has a similar syntax.<\/li>\n\n\n\n
            • It can contain data members.<\/li>\n\n\n\n
            • It is an extension of the same concept.<\/li>\n<\/ul>\n\n\n\n
              A class<\/strong> differs from a C struct<\/strong>:<\/p>\n\n\n\n
                \n
              • It uses the keyword class.<\/li>\n\n\n\n
              • It can contain member functions as well as data members.<\/li>\n\n\n\n
              • It can contain access specifiers (public<\/strong> and private<\/strong>).<\/li>\n\n\n\n
              • Its usage<\/em> does not require the keyword struct<\/strong> (or class<\/strong>).<\/li>\n<\/ul>\n\n\n\n
                In C++, a class<\/strong> and a struct<\/strong> are both extensions of a C struct<\/strong>;  they differ only in one respect (see later).<\/p>\n\n\n\n
                <\/span>inline Member Functions<\/span><\/h3>\n\n\n\n
                When you create many member functions which contain very little code, and call them often (a common occurrence in object-oriented programming), run-time efficiency often becomes an issue.<\/p>\n\n\n\n
                In C, the only solution was to use a macro<\/em>, which has some potentially serious side-effects.<\/p>\n\n\n\n
                In C++, you have a much better alternative:<\/p>\n\n\n\n
                  \n
                • You can use inline<\/strong> member functions.<\/li>\n<\/ul>\n\n\n\n
                  There are two ways to specify an inline<\/strong> member function:<\/p>\n\n\n\n
                    \n
                  • Place the function body inside the class declaration,\n
                      \n
                    • This combines (part of) the class definition with the class declaration, which means you are exposing implementation details of the class to your clients. (It violates encapsulation)<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n\n\n\n
                      or:<\/p>\n\n\n\n
                        \n
                      • Define the function explicitly inline<\/strong> in the class header file.\n
                          \n
                        • This still has some encapsulation issues.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n\n\n\n
                          <\/span>Placing the function body inside the class declaration:<\/span><\/h4>\n\n\n\n
                          \n
                          \n
                          <\/path><\/path><\/svg><\/span>
                          \/\/ complex.h<\/span><\/span>\nclass<\/span> <\/span>Complex<\/span> <\/span><\/span>\n{ <\/span><\/span>\nprivate:<\/span>    <\/span><\/span>\n  <\/span>double<\/span> real, imag; <\/span><\/span>\npublic:<\/span>    <\/span><\/span>\n  \/\/ sets values<\/span><\/span>\n  <\/span>void<\/span> <\/span>set<\/span>(<\/span>const<\/span> <\/span>double<\/span> <\/span>r<\/span>, <\/span><\/span>\n           <\/span>const<\/span> <\/span>double<\/span> <\/span>i<\/span>)<\/span><\/span>\n  { <\/span><\/span>\n    real = r; <\/span><\/span>\n    imag = i; <\/span><\/span>\n\t}<\/span><\/span>\n  <\/span>void<\/span> <\/span>print<\/span>();<\/span>\t\/\/ prints values<\/span><\/span>\n};<\/span> \/\/ end of class declaration (semicolon required)<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                          \n
                          This implicitly<\/em> makes the member function inline<\/strong>.<\/p>\n<\/div>\n<\/div>\n\n\n\n
                          <\/span>Defining the function explicitly<\/em> inline<\/strong> in the class header file:<\/span><\/h4>\n\n\n\n
                          \n
                          \n
                          <\/path><\/path><\/svg><\/span>
                          \/\/ complex.h<\/span><\/span>\nclass<\/span> <\/span>Complex<\/span> <\/span><\/span>\n{ <\/span><\/span>\nprivate:<\/span>    <\/span><\/span>\n  <\/span>double<\/span> real, imag; <\/span><\/span>\npublic:<\/span>    <\/span><\/span>\n  <\/span>void<\/span> <\/span>set<\/span>(<\/span>const<\/span> <\/span>double<\/span> <\/span>r<\/span>, <\/span><\/span>\n           <\/span>const<\/span> <\/span>double<\/span> <\/span>i<\/span>);<\/span> \/\/ sets values<\/span><\/span>\n  <\/span>void<\/span> <\/span>print<\/span>();<\/span>\t\/\/ prints values<\/span><\/span>\n};<\/span> \/\/ end of class declaration (semicolon required)<\/span><\/span>\n<\/span>\ninline<\/span> <\/span>void<\/span> <\/span>Complex<\/span>::<\/span>set<\/span>(<\/span>const<\/span> <\/span>double<\/span> <\/span>r<\/span>, <\/span><\/span>\n                         <\/span>const<\/span> <\/span>double<\/span> <\/span>i<\/span>)<\/span><\/span>\n{ <\/span><\/span>\n\treal = r; <\/span><\/span>\n\timag = i; <\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                          \n
                          Question:<\/strong> Why does it have to be in the header file?<\/em><\/p>\n<\/div>\n<\/div>\n\n\n\n
                          <\/span>To inline or Not To inline?<\/span><\/h3>\n\n\n\n
                          Beware!<\/strong> Making a function inline<\/strong> exposes that part of the class implementation to its clients, which can lead to problems.<\/em>   <\/p>\n\n\n\n
                          When should one make a member function inline<\/strong>?<\/p>\n\n\n\n
                          when:<\/p>\n\n\n\n
                            \n
                          • The member function is truly trivial<\/em>, and is likely to remain so<\/em>.<\/li>\n<\/ul>\n\n\n\n
                            and<\/em> when:<\/p>\n\n\n\n
                              \n
                            • Making the member function inline<\/strong> is not detrimental in other ways<\/em>.<\/li>\n<\/ul>\n\n\n\n
                              For example, we could have done the following:<\/p>\n\n\n\n
                              \n
                              \n
                              <\/path><\/path><\/svg><\/span>
                              \/\/ complex.h<\/span><\/span>\n#include<\/span> <\/span><iostream><\/span>\t<\/span>\/\/ Large!!<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Complex<\/span> <\/span><\/span>\n{ <\/span><\/span>\nprivate:<\/span>    <\/span><\/span>\n  <\/span>double<\/span> real, imag; <\/span><\/span>\npublic:<\/span>    <\/span><\/span>\n  <\/span>void<\/span> <\/span>set<\/span>(<\/span>const<\/span> <\/span>double<\/span> <\/span>r<\/span>, <\/span><\/span>\n           <\/span>const<\/span> <\/span>double<\/span> <\/span>i<\/span>)<\/span><\/span>\n  { real = r; imag = i; }.<\/span> \/\/ sets values<\/span><\/span>\n  <\/span>void<\/span> <\/span>print<\/span>()<\/span>\t\t         \/\/ prints values<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>std<\/span>::cout << \u2018(\u2018 << real <\/span><\/span>\n              << \u2018.\u2019 << imag << \u2018)\u2019<\/span><\/span>\n              << <\/span>std<\/span>::endl;<\/span><\/span>\n  }<\/span><\/span>\n};<\/span> \/\/ end of class declaration (semicolon required)<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                              \n
                              But then, all clients would be forced to include <iostream>, which slows down compilation considerably!  Besides, in this case, the savings won\u2019t be great.<\/p>\n<\/div>\n<\/div>\n\n\n\n
                              <\/span>Class Scope<\/span><\/h2>\n\n\n\n
                                \n
                              • C has the following scopes:\n
                                  \n
                                • local<\/em> (or block<\/em>) scope<\/li>\n\n\n\n
                                • function<\/em> scope (labels only)<\/li>\n\n\n\n
                                • global<\/em> (or file<\/em>) scope<\/li>\n<\/ul>\n<\/li>\n\n\n\n
                                • To these, C++ adds:\n
                                    \n
                                  • class<\/em> scope\n
                                      \n
                                    • The name of a class member is local to its class<\/li>\n\n\n\n
                                    • Access to class members is controlled<\/li>\n<\/ul>\n<\/li>\n\n\n\n
                                    • namespace<\/em> scope<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n\n\n\n
                                      <\/span>Class Scope and Access Specifiers<\/span><\/h3>\n\n\n\n
                                        \n
                                      • The member functions<\/em> of a class have unrestricted access to all the class members of that class.<\/li>\n\n\n\n
                                      • Functions that are not member functions of that class<\/em> have access only to the public members of that class<\/em>. <\/li>\n\n\n\n
                                      • private<\/strong> disallows access to a class member from outside the class<\/em>.<\/li>\n\n\n\n
                                      • Any number<\/em> of access specifiers is allowed, and no particular order<\/em> is required.\n
                                          \n
                                        • However, note that this may affect the order in which the members are allocated in memory. <\/li>\n<\/ul>\n<\/li>\n\n\n\n
                                        • The default access<\/em>\n
                                            \n
                                          • in a class<\/em> is private<\/strong>   <\/li>\n\n\n\n
                                          • in a struct<\/em> is public<\/strong><\/li>\n<\/ul>\n<\/li>\n<\/ul>\n\n\n\n
                                                 This is the only difference between a class<\/strong> and a struct<\/strong> in C++.<\/p>\n\n\n\n
                                            <\/span>Class versus Struct<\/span><\/h3>\n\n\n\n
                                            A C-style struct<\/strong> is, in C++, a class<\/strong> with all public<\/strong> members.<\/p>\n\n\n\n
                                            For example, you could do:<\/p>\n\n\n\n
                                            \n
                                            \n
                                            <\/path><\/path><\/svg><\/span>
                                            #include<\/span> <\/span><iostream.h><\/span><\/span>\nstruct<\/span> <\/span>Complex<\/span> <\/span><\/span>\n{    <\/span><\/span>\n\t<\/span>double<\/span> real, imag;    <\/span><\/span>\n\t<\/span>void<\/span> <\/span>set<\/span>(<\/span>const<\/span> <\/span>double<\/span> <\/span>r<\/span>, <\/span><\/span>\n           <\/span>const<\/span> <\/span>double<\/span> <\/span>i<\/span>); <\/span><\/span>\n\t<\/span>void<\/span> <\/span>print<\/span>();<\/span><\/span>\n};<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                                            \n
                                            but don\u2019t!   <\/em><\/strong><\/p>\n\n\n\n
                                              \n
                                            • Use a class<\/strong> when there are member functions<\/em>, and <\/li>\n\n\n\n
                                            • Use a struct<\/strong> when there are only data members<\/em>.  <\/li>\n<\/ul>\n<\/div>\n<\/div>\n\n\n\n
                                              <\/span>Class Constructors<\/span><\/h2>\n\n\n\n
                                              A class can be told how to create instances of itself.<\/p>\n\n\n\n
                                              \n
                                              \n
                                              <\/path><\/path><\/svg><\/span>
                                              \/\/ complex.h<\/span><\/span>\nclass<\/span> <\/span>Complex<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>Complex<\/span>(<\/span>const<\/span> <\/span>double<\/span> <\/span>r<\/span>,<\/span><\/span>\n          <\/span>const<\/span> <\/span>double<\/span> <\/span>i<\/span>)<\/span><\/span>\n  { real = r; imag = i; }<\/span><\/span>\n<\/span>\n  <\/span>void<\/span> <\/span>print<\/span>();<\/span><\/span>\n<\/span>\nprivate:<\/span><\/span>\n  <\/span>double<\/span> real, imag;<\/span><\/span>\n};<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                                              \n
                                                \n
                                              • A constructor is a special member function that is called whenever an instance of its class is created:<\/em><\/strong><\/li>\n<\/ul>\n<\/div>\n<\/div>\n\n\n\n
                                                \n
                                                \n
                                                <\/path><\/path><\/svg><\/span>
                                                \/\/ complex.h<\/span><\/span>\nclass<\/span> <\/span>Complex<\/span><\/span>\n{<\/span><\/span>\nprivate:<\/span><\/span>\n  <\/span>double<\/span> real, imag;<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>Complex<\/span>()<\/span><\/span>\n  { real = <\/span>0.0<\/span>; imag = <\/span>0.0<\/span>; }<\/span><\/span>\n<\/span>\n  <\/span>Complex<\/span>(<\/span>const<\/span> <\/span>double<\/span> <\/span>r<\/span>)<\/span><\/span>\n  { real = r; imag = <\/span>0.0<\/span>; }<\/span><\/span>\n<\/span>\n  <\/span>Complex<\/span>(<\/span>const<\/span> <\/span>double<\/span> <\/span>r<\/span>, <\/span><\/span>\n          <\/span>const<\/span> <\/span>double<\/span> <\/span>i<\/span>)<\/span><\/span>\n  { real = r; imag = i; }<\/span><\/span>\n<\/span>\n  <\/span>void<\/span> <\/span>print<\/span>();<\/span><\/span>\n};<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                                                \n
                                                  \n
                                                • A constructor<\/em> always has the same name as its class<\/em>.<\/li>\n\n\n\n
                                                • It may not<\/em> have a return type<\/em>, nor may it return a value<\/em>.<\/li>\n\n\n\n
                                                • Constructors<\/em> can be (and usually are) overloaded (see example code)<\/li>\n<\/ul>\n<\/div>\n<\/div>\n\n\n\n
                                                  <\/span>Constructor Usage<\/span><\/h3>\n\n\n\n
                                                  A constructor is guaranteed to be called for the creation of an instance of its class<\/em> (even a static instance!)<\/p>\n\n\n\n
                                                  Note that we have replaced the set<\/strong> method with a constructor.<\/p>\n\n\n\n
                                                    \n
                                                  • More appropriate in C++, because of the above guarantee.<\/li>\n\n\n\n
                                                  • Of course, we could have both, if we wish.<\/li>\n<\/ul>\n\n\n\n
                                                    <\/span>Explicit Constructor Usage<\/span><\/h3>\n\n\n\n
                                                    Here are some examples of explicit constructor usage:<\/p>\n\n\n\n
                                                    \n
                                                    \n
                                                    <\/path><\/path><\/svg><\/span>
                                                    \/\/ testComplex.cpp<\/span><\/span>\n#include<\/span> <\/span>"complex.h"<\/span><\/span>\n<\/span>\nstatic<\/span> <\/span>Complex<\/span> <\/span>g<\/span>(<\/span>54.6<\/span>);<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  Complex x;<\/span><\/span>\n  Complex <\/span>y<\/span>(<\/span>34.5<\/span>);<\/span><\/span>\n  Complex <\/span>z<\/span>(<\/span>27.5<\/span>, <\/span>13.4<\/span>);<\/span><\/span>\n<\/span>\n  <\/span>g<\/span>.<\/span>print<\/span>();<\/span><\/span>\n  <\/span>x<\/span>.<\/span>print<\/span>();<\/span><\/span>\n  <\/span>y<\/span>.<\/span>print<\/span>();<\/span><\/span>\n  <\/span>z<\/span>.<\/span>print<\/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
                                                    <\/div>\n<\/div>\n\n\n\n
                                                    <\/span>Constructors and Default Arguments<\/span><\/h3>\n\n\n\n
                                                    You can reduce the proliferation of constructors by using default arguments:<\/p>\n\n\n\n
                                                    \n
                                                    \n
                                                    <\/path><\/path><\/svg><\/span>
                                                    \/\/ complex.h<\/span><\/span>\nclass<\/span> <\/span>Complex<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>Complex<\/span>(<\/span>const<\/span> <\/span>double<\/span> <\/span>r<\/span> = <\/span>0.0<\/span>, <\/span><\/span>\n         <\/span>const<\/span> <\/span>double<\/span> <\/span>i<\/span> = <\/span>0.0<\/span>)<\/span><\/span>\n  { real = r; imag = i; }<\/span><\/span>\n<\/span>\n  <\/span>void<\/span> <\/span>print<\/span>();<\/span><\/span>\n<\/span>\nprivate:<\/span><\/span>\n  <\/span>double<\/span> real, imag;<\/span><\/span>\n};<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                                                    <\/div>\n<\/div>\n\n\n\n
                                                    <\/span>Default Constructors<\/span><\/h3>\n\n\n\n
                                                    A default constructor<\/em> is one that can be called without an argument.<\/p>\n\n\n\n
                                                      \n
                                                    • Note<\/strong>: A default constructor may or may not have zero arguments.  It depends on whether its declaration contains default arguments.<\/li>\n\n\n\n
                                                    • For this reason, using the term no-arg constructor<\/em> is incorrect<\/em>.<\/li>\n<\/ul>\n\n\n\n
                                                      Here\u2019s how a default constructor can be used:<\/p>\n\n\n\n
                                                      \n
                                                      \n
                                                      <\/path><\/path><\/svg><\/span>
                                                      \/\/ testComplex.cpp<\/span><\/span>\n#include<\/span> <\/span>"complex.h"<\/span><\/span>\n<\/span>\nstatic<\/span> Complex g;<\/span> \t\/\/ Calls default constructor<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  Complex x;<\/span> \t\t\/\/ Calls default constructor<\/span><\/span>\n  Complex <\/span>a<\/span>[<\/span>10<\/span>];<\/span>\t\/\/ Calls default constructor 10 times<\/span><\/span>\n<\/span>\n\/\/ ...<\/span><\/span>\n<\/span>\nreturn<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                                                      <\/div>\n<\/div>\n\n\n\n
                                                      <\/span>Generated Default Constructors<\/span><\/h3>\n\n\n\n
                                                      If you declare no constructors<\/em> for a class:<\/p>\n\n\n\n
                                                        \n
                                                      • The C++ compiler will automatically generate<\/em> a default constructor<\/em> for that class.<\/li>\n<\/ul>\n\n\n\n
                                                        If you declare any<\/em> constructors for a class:<\/p>\n\n\n\n
                                                          \n
                                                        • The C++ compiler will not<\/em> generate a default constructor<\/em> for that class.<\/li>\n\n\n\n
                                                        • In that case, if you want a default constructor for that class, you must declare (and write) it explicitly<\/em>.<\/li>\n\n\n\n
                                                        • You will encounter classes which will require you to write default constructors explicitly.<\/li>\n<\/ul>\n\n\n\n
                                                          For example:<\/p>\n\n\n\n
                                                          \n
                                                          \n
                                                          <\/path><\/path><\/svg><\/span>
                                                          \/\/ complex.h<\/span><\/span>\nclass<\/span> <\/span>Complex<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>Complex<\/span>(<\/span>const<\/span> <\/span>double<\/span> <\/span>r<\/span>, <\/span><\/span>\n          <\/span>const<\/span> <\/span>double<\/span> <\/span>i<\/span>)<\/span><\/span>\n  { real = r; imag = i; }<\/span><\/span>\n<\/span>\n  <\/span>void<\/span> <\/span>print<\/span>();<\/span><\/span>\n<\/span>\nprivate:<\/span><\/span>\n  <\/span>double<\/span> real, imag;<\/span><\/span>\n};<\/span><\/span>\n<\/span>\n\/\/ testComplex.cpp<\/span><\/span>\n#include<\/span> <\/span>"complex.h"<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  Complex x;<\/span>  \/\/ error C2512: <\/span><\/span>\n              \/\/ 'Complex' : no appropriate default constructor available<\/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
                                                          <\/div>\n<\/div>\n\n\n\n
                                                          <\/span>Constructor Usage<\/span><\/h3>\n\n\n\n
                                                          You can explicitly initialize elements of an array of class instances using constructors:<\/p>\n\n\n\n
                                                          \n
                                                          \n
                                                          <\/path><\/path><\/svg><\/span>
                                                          \/\/ testComplex.cpp<\/span><\/span>\n#include<\/span> <\/span>"complex.h"<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  Complex <\/span>x<\/span>[<\/span>5<\/span>] =<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>Complex<\/span>(), <\/span><\/span>\n    <\/span>Complex<\/span>(<\/span>2.5<\/span>),<\/span><\/span>\n    <\/span>Complex<\/span>(<\/span>2.3<\/span>, <\/span>4.5<\/span>)<\/span><\/span>\n  };<\/span><\/span>\n<\/span>\n  \/\/ ...<\/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
                                                          <\/div>\n<\/div>\n\n\n\n
                                                          If the initializer list does not contain an entry for every element, then the default constructor<\/em> is used for those that are missing.<\/p>\n\n\n\n
                                                          If there is no default constructor, then every element must be explicitly initialized<\/em>.<\/p>\n\n\n\n
                                                          <\/span>Type Conversions<\/span><\/h3>\n\n\n\n
                                                          Consider:<\/p>\n\n\n\n
                                                          Complex x(5.4);<\/code><\/pre>\n\n\n\n
                                                          This amounts to type conversion<\/em> from double<\/strong> to Complex<\/strong>.<\/p>\n\n\n\n
                                                          In general, it would be very convenient if we could accomplish implicit type conversions among instances of different classes.<\/p>\n\n\n\n
                                                          One common way to accomplish type conversion is to use a constructor with a single argument<\/em> (or one where all arguments but the first are defaulted):<\/p>\n\n\n\n
                                                          \n
                                                          \n
                                                          <\/path><\/path><\/svg><\/span>
                                                          \/\/ testComplex.cpp<\/span><\/span>\n#include<\/span> <\/span>"complex.h"<\/span><\/span>\n<\/span>\nextern<\/span> <\/span>void<\/span> <\/span>bungle<\/span>(<\/span>Complex<\/span> <\/span>c<\/span>);<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  Complex <\/span>x<\/span>(<\/span>1.0<\/span>);<\/span>\t\t\t\/\/ explicit conversion<\/span><\/span>\n<\/span>\n  <\/span>bungle<\/span>( <\/span>Complex<\/span>(<\/span>37.5<\/span>) );<\/span>\t\/\/ explicit conversion<\/span><\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                                                          <\/div>\n<\/div>\n\n\n\n
                                                          <\/span>Implicit Type Conversions<\/span><\/h3>\n\n\n\n
                                                          Implicit type conversions<\/em> occur in situations where you may or may not<\/em> want it!<\/p>\n\n\n\n
                                                          \n
                                                          \n
                                                          <\/path><\/path><\/svg><\/span>
                                                          \/\/ testComplex.cpp<\/span><\/span>\n#include<\/span> <\/span>"complex.h"<\/span><\/span>\n<\/span>\nextern<\/span> <\/span>void<\/span> <\/span>blather<\/span>(<\/span>Complex<\/span> <\/span>c<\/span>);<\/span> \/\/ accepts a Complex<\/span><\/span>\n<\/span>\nComplex<\/span> <\/span>doit<\/span>()<\/span> \t\/\/ returns a Complex<\/span><\/span>\n{<\/span><\/span>\n  <\/span>blather<\/span>(<\/span>2.3<\/span>);<\/span>\t\/\/ implicit conversion <\/span><\/span>\n  \/\/ Equivalent to blather(Complex(2.3));<\/span><\/span>\n<\/span>\n  \/\/ ...<\/span><\/span>\n<\/span>\n  <\/span>return<\/span> <\/span>3.5<\/span>;<\/span>\t\/\/ implicit conversion<\/span><\/span>\n  \/\/ Equivalent to return Complex(3.5);<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                                                          \n
                                                            \n
                                                          • Be extremely wary of using conversion constructors when you don\u2019t want this to happen!  <\/em><\/strong><\/li>\n\n\n\n
                                                          • This is easy to forget, so don’t say you haven’t been warned!<\/strong><\/li>\n<\/ul>\n<\/div>\n<\/div>\n\n\n\n
                                                            <\/span>Copy Constructors<\/span><\/h3>\n\n\n\n
                                                            Consider:<\/p>\n\n\n\n
                                                            Complex x = 1.0; \/\/ initialization, not assignment!<\/code><\/pre>\n\n\n\n
                                                            Because of implicit conversions, this can be equivalent to:<\/p>\n\n\n\n
                                                            Complex x = Complex(1.0);<\/code><\/pre>\n\n\n\n
                                                            but then it is often (but not always!) optimized to:<\/p>\n\n\n\n
                                                            Complex x(1.0);<\/code><\/pre>\n\n\n\n
                                                            A copy constructor<\/em> is one that constructs an instance of a class from another instance of that class<\/em>:<\/p>\n\n\n\n
                                                            Complex(const Complex &src); (preferred) <\/code><\/pre>\n\n\n\n
                                                            or:<\/p>\n\n\n\n
                                                            Complex(Complex &src);\n<\/code><\/pre>\n\n\n\n
                                                            Note the reference <\/em>(&<\/strong>), which is required<\/em>  <\/p>\n\n\n\n
                                                            The following:<\/p>\n\n\n\n
                                                            Complex(const Complex src);<\/code><\/pre>\n\n\n\n
                                                            is <\/em>not<\/em><\/strong> a copy constructor!<\/em><\/p>\n\n\n\n
                                                            <\/span>Generated Copy Constructors<\/span><\/h3>\n\n\n\n
                                                            If you do not declare<\/em> a copy constructor for a class:<\/p>\n\n\n\n
                                                              \n
                                                            • The C++ compiler will generate<\/em> a copy constructor for that class.\n
                                                                \n
                                                              • This is sometimes called a default copy constructor<\/em>, although the term can be confused with the simple default constructor.<\/li>\n<\/ul>\n<\/li>\n\n\n\n
                                                              • For a simple class, the generated copy constructor will do memberwise initialization<\/em> — i.e., a \u2018shallow copy\u2019<\/em>.\n
                                                                  \n
                                                                • This may, or may not, be what you want for the class.<\/em><\/li>\n<\/ul>\n<\/li>\n\n\n\n
                                                                • Remember, if you declare no constructors for the class, the compiler will also generate a default constructor for the class.<\/li>\n<\/ul>\n\n\n\n
                                                                  If you do declare<\/em> a copy constructor for a class:<\/p>\n\n\n\n
                                                                    \n
                                                                  • The C++ compiler will not generate<\/em> one for that class.<\/li>\n\n\n\n
                                                                  • Neither will it generate a default constructor for the class.
                                                                    (Because you declared at least one constructor for the class.)<\/li>\n<\/ul>\n\n\n\n
                                                                    <\/span>Explicit Copy Constructors<\/span><\/h3>\n\n\n\n
                                                                    For example, here\u2019s an explicit copy constructor:<\/p>\n\n\n\n
                                                                    \n
                                                                    \n
                                                                    <\/path><\/path><\/svg><\/span>
                                                                    \/\/ complex.h<\/span><\/span>\nclass<\/span> <\/span>Complex<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>Complex<\/span>(<\/span>const<\/span> <\/span>double<\/span> <\/span>r<\/span> = <\/span>0.0<\/span>,<\/span><\/span>\n          <\/span>const<\/span> <\/span>double<\/span> <\/span>i<\/span> = <\/span>0.0<\/span>)<\/span><\/span>\n  { real = r; imag = i; }<\/span><\/span>\n<\/span>\n  <\/span>Complex<\/span>(<\/span>const<\/span> <\/span>Complex<\/span> <\/span>&<\/span>src<\/span>)<\/span><\/span>\n  { real = <\/span>src<\/span>.<\/span>real<\/span>; imag = <\/span>src<\/span>.<\/span>imag<\/span>; }<\/span><\/span>\n<\/span>\n  <\/span>void<\/span> <\/span>print<\/span>();<\/span><\/span>\n<\/span>\nprivate:<\/span><\/span>\n  <\/span>double<\/span> real, imag;<\/span><\/span>\n};<\/span><\/span>\n<\/span>\n\/\/ testComplex.cpp<\/span><\/span>\n#include<\/span> <\/span>"complex.h"<\/span><\/span>\nint<\/span> <\/span>main<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  Complex <\/span>x<\/span>(<\/span>1.0<\/span>, <\/span>4.5<\/span>);<\/span><\/span>\n  Complex <\/span>y<\/span>(x);<\/span>\t\/\/ Copy constructor<\/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
                                                                    <\/div>\n<\/div>\n\n\n\n
                                                                    <\/span>Explicit or Generated Copy Constructors?<\/span><\/h3>\n\n\n\n
                                                                    In some cases, the generated copy constructor is sufficient.<\/p>\n\n\n\n
                                                                    In other cases it is insufficient:<\/p>\n\n\n\n
                                                                      \n
                                                                    • When a class contains a pointer to a non-shared object.<\/li>\n\n\n\n
                                                                    • Other situations where it does not make sense to replicate only the contents of the class and not any external context.<\/li>\n<\/ul>\n\n\n\n
                                                                      In some other cases, copying a class is meaningless.<\/p>\n\n\n\n
                                                                        \n
                                                                      • For example, does it make sense to copy a linked list?  What does it mean?<\/li>\n\n\n\n
                                                                      • In this case, you need to ensure that no copy constructor exists.  (How?  Later…)<\/li>\n<\/ul>\n\n\n\n
                                                                        <\/span>Class Destructors<\/span><\/h2>\n\n\n\n
                                                                        A class can be told how to destroy an instance of itself.<\/p>\n\n\n\n
                                                                        A destructor<\/em> is a special member function that is called whenever an instance of its class is destroyed:<\/p>\n\n\n\n
                                                                        \n
                                                                        \n
                                                                        <\/path><\/path><\/svg><\/span>
                                                                        \/\/ complex.h<\/span><\/span>\nclass<\/span> <\/span>Complex<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>Complex<\/span>(<\/span>const<\/span> <\/span>double<\/span> <\/span>r<\/span> = <\/span>0.0<\/span>,<\/span><\/span>\n          <\/span>const<\/span> <\/span>double<\/span> <\/span>i<\/span> = <\/span>0.0<\/span>)<\/span><\/span>\n  { real = r; imag = i; }<\/span><\/span>\n<\/span>\n  <\/span>~Complex<\/span>() {}<\/span> \/\/ Destructor<\/span><\/span>\n<\/span>\n  <\/span>void<\/span> <\/span>print<\/span>();<\/span><\/span>\n<\/span>\nprivate:<\/span><\/span>\n  <\/span>double<\/span> real, imag;<\/span><\/span>\n};<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                                                                        <\/div>\n<\/div>\n\n\n\n
                                                                        A destructor<\/em> always has the same name as its class, preceded by a tilde (~) character<\/em>.<\/p>\n\n\n\n
                                                                        It may not<\/em> have a return type<\/em>, nor may it return a value<\/em>.<\/p>\n\n\n\n
                                                                        A destructor always takes no arguments<\/em>, so:<\/p>\n\n\n\n
                                                                          \n
                                                                        • It cannot be overloaded.<\/li>\n\n\n\n
                                                                        • A class may only have a single destructor.<\/li>\n<\/ul>\n\n\n\n
                                                                          Destructors are invoked implicitly;  it is rarely necessary to make an explicit call to a destructor (bad form!). <\/p>\n\n\n\n
                                                                          A destructor is guaranteed to be called for the destruction of an instance of its class<\/em> (even a static instance!), except for free store instances (more later…).<\/p>\n\n\n\n
                                                                          <\/span>Implicit Destructor Usage<\/span><\/h3>\n\n\n\n
                                                                          Example:<\/p>\n\n\n\n
                                                                          \n
                                                                          \n
                                                                          <\/path><\/path><\/svg><\/span>
                                                                          \/\/ testComplex.cpp<\/span><\/span>\n#include<\/span> <\/span>"complex.h"<\/span><\/span>\n<\/span>\nstatic<\/span> <\/span>Complex<\/span> <\/span>g<\/span>(<\/span>54.6<\/span>);<\/span><\/span>\n<\/span>\nstatic<\/span> <\/span>void<\/span> <\/span>doit<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  Complex x;<\/span>  \/\/ call constructor for x...<\/span><\/span>\n  \/\/ ...<\/span><\/span>\n}.<\/span>            \/\/ call destructor for x...<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>()<\/span>\t\t\/\/ call constructor for g...<\/span><\/span>\n{<\/span><\/span>\n  <\/span>doit<\/span>();<\/span><\/span>\n  \/\/ ...<\/span><\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span>             \/\/ call destructor for g...<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                                                                          <\/div>\n<\/div>\n\n\n\n
                                                                          <\/span>Generated Destructors<\/span><\/h3>\n\n\n\n
                                                                          If you declare no destructor<\/em> for a class:<\/p>\n\n\n\n
                                                                            \n
                                                                          • The C++ compiler will automatically generate<\/em> a destructor for that class.<\/li>\n\n\n\n
                                                                          • For a simple class, the generated destructor will do essentially nothing.<\/li>\n\n\n\n
                                                                          • For derived classes, and classes with class member objects, the generated destructor does more! (Later…)<\/li>\n<\/ul>\n\n\n\n
                                                                            You can, of course, write your own — and you must for some classes<\/em>.<\/p>\n\n\n\n
                                                                            <\/span>What Does a Destructor Do?<\/span><\/h3>\n\n\n\n
                                                                            In the case of class Complex<\/strong>, there is nothing to do.<\/p>\n\n\n\n
                                                                            In other situations, a destructor can:<\/p>\n\n\n\n
                                                                              \n
                                                                            • Deallocate space<\/em> allocated by the instance.<\/li>\n\n\n\n
                                                                            • Close a file<\/em> associated with the instance.<\/li>\n\n\n\n
                                                                            • Remove a window<\/em> from the screen that the instance caused to be created.<\/li>\n\n\n\n
                                                                            • Defrangle a booblefratz<\/em>, that had been previously frangled by the instance.<\/li>\n<\/ul>\n\n\n\n
                                                                              A destructor<\/em> is the complement of a constructor;  it typically cleans up after the instance.<\/p>\n\n\n\n
                                                                              <\/span>When a Destructor is NOT Called<\/span><\/h3>\n\n\n\n
                                                                              Note that no destructor is called<\/em> in the following case:<\/p>\n\n\n\n
                                                                              \n
                                                                              \n
                                                                              <\/path><\/path><\/svg><\/span>
                                                                              \/\/ testComplex.cpp<\/span><\/span>\n#include<\/span> <\/span>"complex.h"<\/span><\/span>\n<\/span>\nstatic<\/span> <\/span>void<\/span> <\/span>doit<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  Complex *ptr = <\/span>new<\/span> <\/span>Complex<\/span>(<\/span>1.0<\/span>);\t<\/span><\/span>\n   \/\/ constructor called for what ptr will point to.<\/span><\/span>\n   <\/span><\/span>\n  \/\/ ...<\/span><\/span>\n}<\/span>\t\t\t\t\t\t\t\t\/\/ no destructor called!<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                                                                              \n
                                                                              If you don\u2019t clean it up with an explicit delete<\/strong>, it doesn\u2019t get cleaned up!<\/p>\n<\/div>\n<\/div>\n\n\n\n
                                                                              <\/span>Destructor Usage<\/span><\/h3>\n\n\n\n
                                                                              Here\u2019s an example of where you need an explicit destructor:<\/p>\n\n\n\n
                                                                              \n
                                                                              \n
                                                                              <\/path><\/path><\/svg><\/span>
                                                                              \/\/ complex.h<\/span><\/span>\n#include<\/span> <\/span><string.h><\/span><\/span>\n<\/span>\nclass<\/span> <\/span>MyString<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>MyString<\/span>(<\/span>const<\/span> <\/span>char<\/span> <\/span>source<\/span>[])<\/span><\/span>\n  {<\/span><\/span>\n    p = <\/span>new<\/span> <\/span>char<\/span>[<\/span>strlen<\/span>(source) + <\/span>1<\/span>];<\/span><\/span>\n    <\/span>strcpy<\/span>(p, source);<\/span><\/span>\n  }<\/span><\/span>\n<\/span>\n  <\/span>~MyString<\/span>() <\/span><\/span>\n  { <\/span><\/span>\n    <\/span>delete<\/span> <\/span>[]<\/span> p; <\/span><\/span>\n  }<\/span><\/span>\n  \/\/ ... <\/span><\/span>\n<\/span>\nprivate:<\/span><\/span>\n  <\/span>char<\/span> *p; <\/span><\/span>\n};<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                                                                              \n
                                                                              The constructor allocated an array which must be deallocated (else you will have a memory leak!).<\/p>\n<\/div>\n<\/div>\n\n\n\n
                                                                              Here\u2019s a more complex example — a FileStats<\/strong> class:<\/p>\n\n\n\n
                                                                              \n
                                                                              \n
                                                                              <\/path><\/path><\/svg><\/span>
                                                                              \/\/ FileStats.h<\/span><\/span>\n#include<\/span> <\/span><stdio.h><\/span>\t\t<\/span>\/\/ For FILE<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>FileStats<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>FileStats<\/span>(<\/span>char<\/span> <\/span>*<\/span>fileName<\/span>);<\/span><\/span>\n  <\/span>~FileStats<\/span>();<\/span><\/span>\n  <\/span>void<\/span> <\/span>collectStats<\/span>();<\/span><\/span>\n<\/span>\nprivate:<\/span><\/span>\n  \/\/ Methods<\/span><\/span>\n  <\/span>int<\/span> <\/span>readChar<\/span>();<\/span><\/span>\n<\/span>\n  \/\/ Data<\/span><\/span>\n  <\/span>char<\/span> *name;<\/span>\t\t\t\/\/ File name<\/span><\/span>\n  FILE *ifp;<\/span>\t\t\t\/\/ File pointer<\/span><\/span>\n<\/span>\n    \/\/ Counts of characters, words, lines<\/span><\/span>\n  <\/span>typedef<\/span> <\/span>unsigned<\/span> <\/span>int<\/span> count;<\/span><\/span>\n  count \tchars;<\/span><\/span>\n  count \twords;<\/span><\/span>\n  count \tlines;<\/span><\/span>\n};<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                                                                              <\/div>\n<\/div>\n\n\n\n
                                                                              \n
                                                                              \n
                                                                              <\/path><\/path><\/svg><\/span>
                                                                              \/\/ FileStats.cpp<\/span><\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span>"FileStats.h"<\/span><\/span>\n<\/span>\n\/\/ Constructor<\/span><\/span>\nFileStats<\/span>::<\/span>FileStats<\/span>(<\/span>char<\/span> *fileName)<\/span><\/span>\n{<\/span><\/span>\n  ifp = <\/span>fopen<\/span>(fileName, <\/span>"r"<\/span>);<\/span> \/\/ Open for reading<\/span><\/span>\n  <\/span>if<\/span> (ifp != <\/span>NULL<\/span>)<\/span><\/span>\n  {<\/span><\/span>\n    chars = words = lines = <\/span>0<\/span>;<\/span><\/span>\n    name = <\/span>new<\/span> <\/span>char<\/span>[<\/span>strlen<\/span>(fileName) + <\/span>1<\/span>];<\/span><\/span>\n    <\/span>strcpy<\/span>(name, fileName);<\/span><\/span>\n  }<\/span><\/span>\n  <\/span>else<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>exit<\/span>(<\/span>1<\/span>);<\/span>\t\/\/ Exit abruptly<\/span><\/span>\n  }<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n\/\/ Private utility member function<\/span><\/span>\nint<\/span> <\/span>FileStats<\/span>::<\/span>readChar<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  <\/span>int<\/span> ch;<\/span><\/span>\n  ch = <\/span>fgetc<\/span>(ifp);<\/span><\/span>\n  <\/span>if<\/span> (ch != EOF)<\/span><\/span>\n    chars++;<\/span> \/\/ count chars<\/span><\/span>\n  <\/span>if<\/span> (ch == <\/span>'<\/span>\\n<\/span>'<\/span>)<\/span><\/span>\n    lines++;<\/span> \/\/ count lines<\/span><\/span>\n  <\/span>return<\/span> ch;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n\/\/ Collect File Statistics member function<\/span><\/span>\nvoid<\/span> <\/span>FileStats<\/span>::<\/span>collectStats<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  <\/span>bool<\/span> in_word = <\/span>false<\/span>;<\/span><\/span>\n  <\/span>int<\/span> ch;<\/span><\/span>\n  <\/span>while<\/span> (EOF != (ch = <\/span>readChar<\/span>()))<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>if<\/span> (!in_word)<\/span><\/span>\n    {<\/span>   \t \/\/ not already in word<\/span><\/span>\n      <\/span>if<\/span> (<\/span>isalnum<\/span>(ch))<\/span><\/span>\n      {<\/span>  \t\/\/ start of new word<\/span><\/span>\n        words++;<\/span> \/\/ count words<\/span><\/span>\n        in_word = <\/span>true<\/span>;<\/span><\/span>\n      }<\/span><\/span>\n  }<\/span><\/span>\n  <\/span>else<\/span><\/span>\n  {<\/span>   \t\/\/ already in a word<\/span><\/span>\n    <\/span>if<\/span> (!<\/span>isalnum<\/span>(ch))<\/span><\/span>\n    in_word = <\/span>false<\/span>; <\/span><\/span>\n        \/\/ end of word<\/span><\/span>\n    }<\/span><\/span>\n  }<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n\/\/ Destructor<\/span><\/span>\n\/\/ Cleans up and prints statistics<\/span><\/span>\n\/\/<\/span><\/span>\nFileStats<\/span>::~<\/span>FileStats<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  \/\/ We opened the file, so be sure to close it<\/span><\/span>\n  <\/span>if<\/span> (ifp != <\/span>NULL<\/span>)<\/span><\/span>\n    <\/span>fclose<\/span>(ifp);<\/span><\/span>\n<\/span>\n  \/\/ Output file statistics<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"File '"<\/span> << name<\/span><\/span>\n            << <\/span>"' statistics:"<\/span> << <\/span>std<\/span>::endl<\/span><\/span>\n            << <\/span>" chars : "<\/span> << chars << <\/span>std<\/span>::endl<\/span><\/span>\n            << <\/span>" words : "<\/span> << words << <\/span>std<\/span>::endl<\/span><\/span>\n            << <\/span>" lines : "<\/span> << lines << <\/span>std<\/span>::endl;<\/span><\/span>\n<\/span>\n  \/\/ Free up allocated space<\/span><\/span>\n  <\/span>delete<\/span> <\/span>[]<\/span> name;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                                                                              \n
                                                                              Note that the actual reporting is done in the destructor!
                                                                              This is not necessarily good practice — it depends on the situation.
                                                                              We’re doing it here to show that a destructor can potentially do a fair amount of work — destructors are not necessarily trivial.<\/p>\n<\/div>\n<\/div>\n\n\n\n
                                                                              And now to use this magical class…<\/p>\n\n\n\n
                                                                              \n
                                                                              \n
                                                                              <\/path><\/path><\/svg><\/span>
                                                                              \/\/ testFileStats.cpp<\/span><\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span>"FileStats.h"<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span>argv<\/span>[])<\/span><\/span>\n{<\/span><\/span>\n  <\/span>int<\/span> retVal = <\/span>1<\/span>;<\/span><\/span>\n  <\/span>if<\/span> (argc > <\/span>1<\/span>)<\/span><\/span>\n  {<\/span><\/span>\n    FileStats <\/span>fs<\/span>(<\/span>argv<\/span>[<\/span>1<\/span>]);<\/span><\/span>\n    <\/span>fs<\/span>.<\/span>collectStats<\/span>();<\/span><\/span>\n    retVal = <\/span>0<\/span>;<\/span><\/span>\n  }<\/span><\/span>\n  <\/span>else<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>std<\/span>::cerr << <\/span>"No filename specified"<\/span> <\/span><\/span>\n              << <\/span>std<\/span>::endl;<\/span><\/span>\n }<\/span><\/span>\n  <\/span>return<\/span> retVal;<\/span><\/span>\n}<\/span>\t\t\t\t\t\/\/ FileStats destructor gets called here...<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                                                                              <\/div>\n<\/div>\n\n\n\n
                                                                              Try using this FileStats<\/strong> class (cut and paste it), and have it print out the statistics from some of your files!<\/p>\n\n\n\n
                                                                              It will give you some practice with creating the various files that you typically use to implement a class and make it available to its clients.<\/p>\n\n\n\n
                                                                              <\/span>Summary<\/span><\/h2>\n\n\n\n
                                                                              We’ve talked about quite a few things relating to classes:<\/p>\n\n\n\n