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

<\/span>Class Conversions<\/span><\/h2>\n\n\n\n

Here’s the next topic on classes: Conversions<\/p>\n\n\n\n

<\/span>Conversion Constructors<\/span><\/h3>\n\n\n\n

Remember that a class constructor with a single argument<\/em> performs a type conversion?<\/p>\n\n\n\n

Here’s a simple example:<\/p>\n\n\n\n

\n
\n
<\/path><\/path><\/svg><\/span>
\/\/<\/span><\/span>\n\/\/  Kilometer.h<\/span><\/span>\n\/\/  Length Conversion<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/16\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#ifndef<\/span> Kilometer_h<\/span><\/span>\n#define<\/span> Kilometer_h<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Kilometer<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>Kilometer<\/span>(<\/span>const<\/span> <\/span>double<\/span> <\/span>lengthInKilometers<\/span>)<\/span><\/span>\n  {<\/span><\/span>\n    m_length = lengthInKilometers;<\/span><\/span>\n  }<\/span><\/span>\n  <\/span><\/span>\n  <\/span>void<\/span> <\/span>print<\/span>();<\/span><\/span>\n  <\/span><\/span>\nprivate:<\/span><\/span>\n  <\/span>double<\/span> m_length;<\/span><\/span>\n};<\/span><\/span>\n<\/span>\n<\/span>\n#endif<\/span> \/* Kilometer_h *\/<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
\n
The simple class Kilometer<\/strong><\/code> contains<\/p>\n\n\n\n
    \n
  • A single constructor — a conversion constructor that converts a double value to a Kilometer<\/strong><\/code><\/li>\n\n\n\n
  • A print method that prints the length of the Kilometer<\/strong><\/code> instance<\/li>\n\n\n\n
  • A private data member, m_length<\/code>, that holds the Kilometer<\/strong><\/code> instance length value<\/li>\n<\/ul>\n<\/div>\n<\/div>\n\n\n\n
    \n
    \n
    <\/path><\/path><\/svg><\/span>
    \/\/<\/span><\/span>\n\/\/  Kilometer.cpp<\/span><\/span>\n\/\/  Length Conversion<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/16\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span>"Kilometer.h"<\/span><\/span>\n<\/span>\nvoid<\/span> <\/span>Kilometer<\/span>::<\/span>print<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  <\/span>std<\/span>::cout << m_length << <\/span>" kilometers<\/span>\\n<\/span>"<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
    \n
    The implementation of the Kilometer<\/strong><\/code>::print<\/code> method.<\/p>\n<\/div>\n<\/div>\n\n\n\n
    \n
    \n
    <\/path><\/path><\/svg><\/span>
    \/\/<\/span><\/span>\n\/\/  main.cpp<\/span><\/span>\n\/\/  Length Conversion<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/16\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span>"Kilometer.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  Kilometer <\/span>k1<\/span>(<\/span>10.5<\/span>);<\/span><\/span>\n  <\/span>k1<\/span>.<\/span>print<\/span>();<\/span><\/span>\n  Kilometer <\/span>k2<\/span>(<\/span>35.2<\/span>);<\/span><\/span>\n  <\/span>k2<\/span>.<\/span>print<\/span>();<\/span><\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
    \n
    A simple test program that creates two instances of Kilometer<\/strong><\/code>, and prints out their lengths:<\/p>\n\n\n\n
    10.5 kilometers\n35.2 kilometers\nProgram ended with exit code: 0<\/code><\/pre>\n<\/div>\n<\/div>\n\n\n\n
    <\/span>Where Implicit Conversions are Used<\/span><\/h3>\n\n\n\n
    User-defined conversions<\/em> are used, in addition to standard conversions, for conversion of:<\/p>\n\n\n\n
      \n
    • initializers<\/li>\n\n\n\n
    • function arguments<\/li>\n\n\n\n
    • function return values<\/li>\n\n\n\n
    • expression operands<\/li>\n\n\n\n
    • expressions controlling iteration (while<\/strong>, do<\/strong>, for<\/strong>) and selection statements (if<\/strong>, switch<\/strong>)<\/li>\n\n\n\n
    • explicit type conversions.<\/li>\n<\/ul>\n\n\n\n
      <\/span>Conversion by Constructor<\/span><\/h3>\n\n\n\n
      Here’s an example:<\/p>\n\n\n\n
      \n
      \n
      <\/path><\/path><\/svg><\/span>
      \/\/<\/span><\/span>\n\/\/  weights.h<\/span><\/span>\n\/\/  Weight Conversion<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/16\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Ounce<\/span>;<\/span>  \/\/ forward declaration<\/span><\/span>\n              \/\/ WHY?<\/span><\/span>\nclass<\/span> <\/span>Gram<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>Gram<\/span>(<\/span>const<\/span> <\/span>double<\/span> <\/span>w<\/span>) { m_weight = w; }<\/span><\/span>\n  <\/span>Gram<\/span>(<\/span>Ounce<\/span> <\/span>&<\/span>oz<\/span>);<\/span><\/span>\n  <\/span>double<\/span> <\/span>getWeight<\/span>() { <\/span>return<\/span> m_weight; }<\/span><\/span>\n  <\/span>void<\/span> <\/span>print<\/span>();<\/span><\/span>\nprivate:<\/span><\/span>\n  <\/span>double<\/span> m_weight;<\/span>    \/\/ in grams<\/span><\/span>\n};<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Ounce<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>Ounce<\/span>(<\/span>const<\/span> <\/span>double<\/span> <\/span>w<\/span>) { m_weight = w; }<\/span><\/span>\n  <\/span>Ounce<\/span>(<\/span>Gram<\/span> <\/span>&<\/span>gm<\/span>);<\/span><\/span>\n  <\/span>double<\/span> <\/span>getWeight<\/span>() { <\/span>return<\/span> m_weight; }<\/span><\/span>\n  <\/span>void<\/span> <\/span>print<\/span>();<\/span><\/span>\nprivate:<\/span><\/span>\n  <\/span>double<\/span> m_weight;<\/span>    \/\/ in ounces<\/span><\/span>\n};<\/span><\/span>\n<\/span>\nconst<\/span> <\/span>double<\/span> GramsPerOunce = <\/span>28.349523<\/span>;<\/span><\/span>\n<\/span>\ninline<\/span> <\/span>Gram<\/span>::<\/span>Gram<\/span>(Ounce &oz)<\/span><\/span>\n{<\/span><\/span>\n    m_weight = <\/span>oz<\/span>.<\/span>getWeight<\/span>() * GramsPerOunce;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\ninline<\/span> <\/span>Ounce<\/span>::<\/span>Ounce<\/span>(Gram &gm)<\/span><\/span>\n{<\/span><\/span>\n    m_weight = <\/span>gm<\/span>.<\/span>getWeight<\/span>() \/ GramsPerOunce;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
      \n
      Contains two classes: Gram, with:<\/p>\n\n\n\n
        \n
      • Conversion constructor from value double<\/li>\n\n\n\n
      • Conversion constructor from Ounce<\/li>\n\n\n\n
      • public accessor method, getWeight()<\/li>\n\n\n\n
      • public method print()<\/li>\n\n\n\n
      • private data member to hold the weight value in grams<\/li>\n<\/ul>\n\n\n\n
        and Ounce, with:<\/p>\n\n\n\n
          \n
        • Conversion constructor from double value<\/li>\n\n\n\n
        • Conversion constructor from Gram<\/li>\n\n\n\n
        • public accessor method, getWeight()<\/li>\n\n\n\n
        • public method print()<\/li>\n\n\n\n
        • private data member to hold the weight value in ounces<\/li>\n<\/ul>\n\n\n\n
          Plus:<\/p>\n\n\n\n
            \n
          • A const data value GramsPerOunce, for conversion between Grams and Ounces<\/li>\n\n\n\n
          • An inline definition of the Gram(Ounce) constructor<\/li>\n\n\n\n
          • An inline definition of the Ounce(Gram) constructor<\/li>\n<\/ul>\n\n\n\n
            QUESTION: Why did I have to define these inline constructors here, rather than inside their respective class declarations?<\/p>\n\n\n\n
            QUESTION: Why did I define Gram(Ounce &oz) and Ounce(Gram &gm), rather than Gram(const Ounce &oz) and Ounce(const Gram &gm)?<\/p>\n<\/div>\n<\/div>\n\n\n\n
            \n
            \n
            <\/path><\/path><\/svg><\/span>
            \/\/<\/span><\/span>\n\/\/  weights.cpp<\/span><\/span>\n\/\/  Weight Conversion<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/16\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span>"weights.h"<\/span><\/span>\n<\/span>\nvoid<\/span> <\/span>Gram<\/span>::<\/span>print<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  <\/span>std<\/span>::cout << m_weight << <\/span>" grams"<\/span>;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nvoid<\/span> <\/span>Ounce<\/span>::<\/span>print<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  <\/span>std<\/span>::cout << m_weight << <\/span>" ounces"<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
            \n
            Contains the implementation for Gram::print() and Ounce::print().<\/p>\n\n\n\n
            QUESTION: Why did I move these to a .cpp<\/strong> file?<\/p>\n<\/div>\n<\/div>\n\n\n\n
            \n
            \n
            <\/path><\/path><\/svg><\/span>
            \/\/<\/span><\/span>\n\/\/  testWeights.cpp<\/span><\/span>\n\/\/  Weight Conversion<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/16\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span>"weights.h"<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  Ounce <\/span>one_ounce<\/span>(<\/span>1.0<\/span>);<\/span><\/span>\n  Gram  <\/span>one_gram<\/span>(<\/span>1.0<\/span>);<\/span><\/span>\n  Ounce <\/span>o<\/span>(one_gram);<\/span><\/span>\n  Gram  <\/span>g<\/span>(one_ounce);<\/span><\/span>\n<\/span>\n  <\/span>one_ounce<\/span>.<\/span>print<\/span>();<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>" = "<\/span>;<\/span><\/span>\n  <\/span>g<\/span>.<\/span>print<\/span>();<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>std<\/span>::endl;<\/span><\/span>\n<\/span>\n  <\/span>one_gram<\/span>.<\/span>print<\/span>();<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>" = "<\/span>;<\/span><\/span>\n  <\/span>o<\/span>.<\/span>print<\/span>();<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>std<\/span>::endl;<\/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’s a test program using these classes:<\/p>\n\n\n\n
            It outputs:<\/p>\n\n\n\n
            1 ounces = 28.3495 grams\n1 grams = 0.035274 ounces\nProgram ended with exit code: 0<\/code><\/pre>\n<\/div>\n<\/div>\n\n\n\n
            <\/span>Problems with Implicit Conversions<\/span><\/h3>\n\n\n\n
            But imagine you have a Stack class:<\/p>\n\n\n\n
            \n
            \n
            <\/path><\/path><\/svg><\/span>
            \/\/<\/span><\/span>\n\/\/  Stack.h<\/span><\/span>\n\/\/  Implicit Conversion Problem<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/17\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#ifndef<\/span> Stack_h<\/span><\/span>\n#define<\/span> Stack_h<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Stack<\/span><\/span>\n{<\/span><\/span>\n  \/\/ ...<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>Stack<\/span>(<\/span>int<\/span> <\/span>size<\/span>)<\/span> \/\/ stack size<\/span><\/span>\n  {<\/span><\/span>\n    p = <\/span>new<\/span> <\/span>int<\/span>[size];<\/span><\/span>\n  }<\/span><\/span>\n  <\/span>~Stack<\/span>()<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>delete<\/span> <\/span>[]<\/span> p;<\/span><\/span>\n  }<\/span><\/span>\nprivate:<\/span><\/span>\n  <\/span>int<\/span> *p;<\/span> \/\/ Pointer to stack of ints<\/span><\/span>\n};<\/span><\/span>\n<\/span>\n#endif<\/span> \/* Stack_h *\/<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
            \n
            Note that the intention of the Stack(int size) is to construct an instance of a stack, allocating that many items from the heap. <\/p>\n\n\n\n
            ~Stack() will deallocate the stack from the heap.<\/p>\n<\/div>\n<\/div>\n\n\n\n
            … and then you try to use it like this:<\/p>\n\n\n\n
            \n
            \n
            <\/path><\/path><\/svg><\/span>
            \/\/<\/span><\/span>\n\/\/  main.cpp<\/span><\/span>\n\/\/  Implicit Conversion Problem<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/17\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span>"Stack.h"<\/span><\/span>\n<\/span>\nvoid<\/span> <\/span>DoIt<\/span>(<\/span>Stack<\/span> <\/span>s<\/span>)<\/span><\/span>\n{<\/span><\/span>\n  \/\/ Do something...<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  Stack <\/span>s<\/span>(<\/span>30<\/span>);<\/span>\/\/ stack of 30 ints<\/span><\/span>\n  <\/span>DoIt<\/span>(<\/span>4<\/span>);<\/span>    \/\/ what happens here?<\/span><\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
            \n
            What will happen when DoIt() is invoked with a value of int?<\/p>\n\n\n\n
            When I annotated the Stack constructor and destructor with debugging outputs, it gave me:<\/p>\n\n\n\n
            Instance of Stack constructed with size: 30\nInstance of Stack constructed with size: 4\nInstance of Stack being destroyed\nInstance of Stack being destroyed\nProgram ended with exit code: 0<\/code><\/pre>\n\n\n\n
            Can you explain this? What is happening? Is this a good idea?<\/p>\n<\/div>\n<\/div>\n\n\n\n
            Clearly, implicit conversions can be problematic. Such implicit silent happenings behind the scenes are not necessarily a good idea.<\/p>\n\n\n\n
            <\/span>How to Avoid Implicit Conversions<\/span><\/h4>\n\n\n\n
            Here are some possibilities:<\/p>\n\n\n\n
              \n
            • Don\u2019t declare a constructor with a single argument.\n
                \n
              • Not always practical!<\/li>\n<\/ul>\n<\/li>\n\n\n\n
              • Use the explicit<\/strong> keyword on the constructor declaration to prevent implicit usage. (At the time of writing this was a relatively new feature of C++)<\/li>\n\n\n\n
              • Substitute a special class as a \u2018stand-in\u2019 for the desired single argument.\n
                  \n
                • It\u2019s a little long-winded.<\/li>\n\n\n\n
                • But, it can be good data abstraction!<\/li>\n<\/ul>\n<\/li>\n\n\n\n
                • Use a static<\/strong> member function to explicitly \u2018make\u2019 an instance of the class\n
                    \n
                  • we\u2019ll discuss this later…<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n\n\n\n
                    <\/span>The explicit Keyword<\/span><\/h4>\n\n\n\n
                    \n
                    \n
                    <\/path><\/path><\/svg><\/span>
                    \/\/<\/span><\/span>\n\/\/  Stack.h<\/span><\/span>\n\/\/  Implicit Conversion Problem<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/17\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#ifndef<\/span> Stack_h<\/span><\/span>\n#define<\/span> Stack_h<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Stack<\/span><\/span>\n{<\/span><\/span>\n  \/\/ ...<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>explicit<\/span> <\/span>Stack<\/span>(<\/span>int<\/span> <\/span>size<\/span>)<\/span> \/\/ stack size<\/span><\/span>\n  {<\/span><\/span>\n    p = <\/span>new<\/span> <\/span>int<\/span>[size];<\/span><\/span>\n  }<\/span><\/span>\n  <\/span>~Stack<\/span>()<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>delete<\/span> <\/span>[]<\/span> p;<\/span><\/span>\n  }<\/span><\/span>\nprivate:<\/span><\/span>\n  <\/span>int<\/span> *p;<\/span> \/\/ Pointer to stack of ints<\/span><\/span>\n};<\/span><\/span>\n<\/span>\n#endif<\/span> \/* Stack_h *\/<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                    \n
                    We made one addition to the original Stack.h file:<\/p>\n\n\n\n
                      \n
                    • Added the ‘explicit’ keyword to the Constructor declaration.<\/li>\n<\/ul>\n<\/div>\n<\/div>\n\n\n\n
                      \n
                      \n
                      <\/path><\/path><\/svg><\/span>
                      \/\/<\/span><\/span>\n\/\/  main.cpp<\/span><\/span>\n\/\/  Implicit Conversion Problem<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/17\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span>"Stack.h"<\/span><\/span>\n<\/span>\nvoid<\/span> <\/span>DoIt<\/span>(<\/span>Stack<\/span> <\/span>s<\/span>)<\/span><\/span>\n{<\/span><\/span>\n  \/\/ Do something...<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  Stack <\/span>s<\/span>(<\/span>30<\/span>);<\/span>\/\/ stack of 30 ints<\/span><\/span>\n  <\/span>DoIt<\/span>(<\/span>4<\/span>);<\/span>    \/\/ what happens here?<\/span><\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                      \n
                      I made no changes in the main.cpp program, but…<\/p>\n\n\n\n
                      Now, the C++ compiler issues an error for line 18:<\/p>\n\n\n\n
                      No matching function for call to ‘DoIt’<\/strong><\/p>\n\n\n\n
                      In other words, the implicit conversion has been suppressed.<\/p>\n<\/div>\n<\/div>\n\n\n\n
                      <\/span>Declaring a \u2018Stand-in\u2019 Class<\/span><\/h4>\n\n\n\n
                      Here’s an example of how to use a ‘stand-in’ class to avoid the problem:<\/p>\n\n\n\n
                      \n
                      \n
                      <\/path><\/path><\/svg><\/span>
                      \/\/<\/span><\/span>\n\/\/  Stack.h<\/span><\/span>\n\/\/  Conversion Stand-in Class<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/17\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#ifndef<\/span> Stack_h<\/span><\/span>\n#define<\/span> Stack_h<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>StackSize<\/span><\/span>\n{<\/span><\/span>\n  <\/span>int<\/span> s;<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>StackSize<\/span>(<\/span>int<\/span> <\/span>size<\/span>)<\/span><\/span>\n  { s = size; }<\/span><\/span>\n  <\/span>int<\/span> <\/span>Size<\/span>()<\/span><\/span>\n  { <\/span>return<\/span> s; }<\/span><\/span>\n};<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Stack<\/span><\/span>\n{<\/span><\/span>\n  \/\/ ...<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>Stack<\/span>(<\/span>StackSize<\/span> <\/span>&<\/span>size<\/span>)<\/span> \/\/ stack size<\/span><\/span>\n  {<\/span><\/span>\n    p = <\/span>new<\/span> <\/span>int<\/span>[<\/span>size<\/span>.<\/span>Size<\/span>()];<\/span><\/span>\n  }<\/span><\/span>\n  <\/span>~Stack<\/span>()<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>delete<\/span> <\/span>[]<\/span> p;<\/span><\/span>\n  }<\/span><\/span>\n  <\/span>private:<\/span><\/span>\n    <\/span>int<\/span> *p;<\/span> \/\/ Pointer to stack of ints<\/span><\/span>\n};<\/span><\/span>\n<\/span>\n#endif<\/span> \/* Stack_h *\/<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                      \n
                      This time, we added a class StackSize, which ‘stands in’ for the size of the stack, in place of a simple int.<\/p>\n\n\n\n
                      NOTE: We must use a Stack constructor of<\/p>\n\n\n\n
                      Stack(StackSize &size)<\/code><\/pre>\n\n\n\n
                      because, if we used a constructor like:<\/p>\n\n\n\n
                      Stack(StackSize size)<\/code><\/pre>\n\n\n\n
                      it would pass size as a value, and thus create an implicit copy. <\/p>\n<\/div>\n<\/div>\n\n\n\n
                      Here’s the original program again, with some changes to use the StackSize class…<\/p>\n\n\n\n
                      \n
                      \n
                      <\/path><\/path><\/svg><\/span>
                      \/\/<\/span><\/span>\n\/\/  main.cpp<\/span><\/span>\n\/\/  Implicit Conversion Problem<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/17\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span>"Stack.h"<\/span><\/span>\n<\/span>\nvoid<\/span> <\/span>DoIt<\/span>(<\/span>Stack<\/span> <\/span>s<\/span>)<\/span><\/span>\n{<\/span><\/span>\n  \/\/ Do something...<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  StackSize <\/span>size1<\/span>(<\/span>30<\/span>);<\/span><\/span>\n  Stack <\/span>s<\/span>(size1);<\/span>\/\/ stack of 30 ints<\/span><\/span>\n  StackSize <\/span>size2<\/span>(<\/span>4<\/span>);<\/span><\/span>\n  Stack <\/span>s2<\/span>(size2);<\/span> \/\/ stack of 4 ints<\/span><\/span>\n  <\/span>DoIt<\/span>(s2);<\/span>    \/\/ what happens here?<\/span><\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                      \n
                      Now, the compile-time errors have disappeared…<\/p>\n\n\n\n
                      BUT:<\/p>\n\n\n\n
                      When we run the program, we get:<\/p>\n\n\n\n
                      malloc: *** error for object 0x600000010020: pointer being freed was not allocated<\/code><\/pre>\n\n\n\n
                      The <\/p>\n\n\n\n
                      delete [] p;<\/code><\/pre>\n\n\n\n
                      in the Stack destructor is trying to delete an array that doesn’t belong to the original Stack instance being passed.<\/p>\n<\/div>\n<\/div>\n\n\n\n
                      It turns out that this was because we are passing the Stack parameter to DoIt by value.<\/em><\/p>\n\n\n\n
                      That means that the compiler generates code to create an implicit copy, and that copy is not a true instance of Stack.<\/p>\n\n\n\n
                      See, later, when we talk about copy constructors.<\/em><\/strong><\/p>\n\n\n\n
                      \n
                      \n
                      <\/path><\/path><\/svg><\/span>
                      \/\/<\/span><\/span>\n\/\/  main.cpp<\/span><\/span>\n\/\/  Implicit Conversion Problem<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/17\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span>"Stack.h"<\/span><\/span>\n<\/span>\nvoid<\/span> <\/span>DoIt<\/span>(<\/span>Stack<\/span> <\/span>&<\/span>s<\/span>)<\/span><\/span>\n{<\/span><\/span>\n  \/\/ Do something...<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  StackSize <\/span>size1<\/span>(<\/span>30<\/span>);<\/span><\/span>\n  Stack <\/span>s<\/span>(size1);<\/span>\/\/ stack of 30 ints<\/span><\/span>\n  StackSize <\/span>size2<\/span>(<\/span>4<\/span>);<\/span><\/span>\n  Stack <\/span>s2<\/span>(size2);<\/span> \/\/ stack of 4 ints<\/span><\/span>\n  <\/span>DoIt<\/span>(s2);<\/span>    \/\/ what happens here?<\/span><\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                      \n
                      Simply changing the one parameter of DoIt to pass by reference fixes the problem.<\/p>\n<\/div>\n<\/div>\n\n\n\n
                      <\/span>Shortcomings of Conversion Constructors<\/span><\/h3>\n\n\n\n
                      A conversion constructor, by definition, converts a class or type into an instance of its own class<\/em>.  For example :<\/p>\n\n\n\n
                      Complex(double);  \/\/ 'convert' double to Complex<\/code><\/pre>\n\n\n\n
                      But conversion constructors:<\/p>\n\n\n\n