{"id":36,"date":"2024-08-01T18:35:48","date_gmt":"2024-08-01T18:35:48","guid":{"rendered":"https:\/\/bhiggs.x10hosting.com\/PracticalC%2B%2BProgramming\/?page_id=36"},"modified":"2025-01-20T21:03:58","modified_gmt":"2025-01-20T21:03:58","slug":"assignment-6","status":"publish","type":"page","link":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/assignments\/assignment-6\/","title":{"rendered":"Assignment 6"},"content":{"rendered":"\n

<\/span>Vector<\/strong>: A Dynamic Array Class<\/span><\/h3>\n\n\n\n

The standard Java class library contains a useful class called Vector<\/code><\/strong>. It is actually a kind of dynamic array. <\/p>\n\n\n\n

This assignment involves writing a C++ class, called DynArray<\/code><\/strong>, that emulates a subset of the Java Vector<\/code><\/strong> class (see here<\/a>). In addition, it involves writing other, related, classes, and is a useful exercise in the use of class inheritance and virtual functions.<\/p>\n\n\n\n

<\/span>Concepts<\/em><\/span><\/h4>\n\n\n\n

To implement such a dynamic class, it is necessary to use arrays of pointers, and to use new and delete to allocate and de-allocate memory for these arrays of pointers. Perhaps a picture would help:<\/p>\n\n\n\n

\"\"<\/figure>\n\n\n\n

Here, the first five elements of the array (on the left) point to elements, while the remainder are empty (i.e., are NULL<\/code><\/strong> pointers). The topmost element is at index 0, the next at index 1, etc.<\/p>\n\n\n\n

When an element is ‘added’ to the array, a pointer to that element is entered into the next available pointer slot. If there is no space left in the pointer array, then the array is automatically expanded by capacityIncrement<\/code><\/strong> elements to make space. This expansion is accomplished by:<\/p>\n\n\n\n

    \n
  1. Determining how large the pointer array needs to become, and performing a new to allocate that amount of space for the array (not<\/strong> what the array elements point to),<\/li>\n\n\n\n
  2. Copying the entries of the existing pointer array into the new pointer array, and zeroing out the remaining entries in the new pointer array,<\/li>\n\n\n\n
  3. Deleting the old pointer array.<\/li>\n\n\n\n
  4. Updating all the necessary internal data in the class to reflect the newly expanded array.<\/li>\n<\/ol>\n\n\n\n

    When an element is ‘removed’ from the array, the corresponding array pointer entry is zeroed, and then all the array pointer entries above it are moved down one, to fill in the gap (which means that their index values also change). All internal data in the class is updated to reflect the new state of the array.<\/p>\n\n\n\n

    <\/span>Strategy<\/em><\/span><\/h4>\n\n\n\n

    Our DynArray<\/code><\/strong> is an array of … what? On the one hand, we’d like to implement a dynamic array that would be generally useful — an array of Widget<\/code><\/strong>s, an array of Person<\/code><\/strong>s, an array of Vehicle<\/code><\/strong>s, — whatever. On the other hand, how do we do this without writing a new kind of array for each type of element we might want to store into it?<\/p>\n\n\n\n

    We can solve this problem by using inheritance; we will implement a DynArray<\/code><\/strong> class that can store instances of any class derived from an abstract base class called DynArrayElement<\/strong>.<\/p>\n\n\n\n

    So far, so good. But think about the problem some more. Wouldn’t it be a good idea for an instance of each class derived from DynArrayElement<\/code><\/strong> to be informed when it is being added to a DynArray<\/code><\/strong>? and when it is being removed from a DynArray<\/code><\/strong>? For one thing, it would be nice if an element could determine whether it currently is in a DynArray<\/code><\/strong>, before it silently disappears as a result of being destroyed. <\/p>\n\n\n\n

    For example:<\/p>\n\n\n\n

    \n
    \n
    <\/path><\/path><\/svg><\/span>
    DynArray<\/span> <\/span>myArray<\/span>(<\/span>100<\/span>, <\/span>10<\/span>);<\/span>    \/\/ initialCapacity 100,<\/span><\/span>\n\t                            \/\/ capacityIncrement 10<\/span><\/span>\nMyElement *myElement = <\/span>new<\/span> MyElement;<\/span><\/span>\n<\/span>\nmyArray<\/span>.<\/span>AddElement<\/span>(*myElement);<\/span><\/span>\n<\/span>\ndelete<\/span> myElement;<\/span>\t\/\/ What happens to the array pointer?<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
    \n
    Clearly, we would like to catch this error as early as possible. We can add code to the element’s destructor to make us aware of this situation, if the element is in a DynArray<\/code><\/strong>.<\/p>\n\n\n\n
    How can the element tell that it’s stored in a DynArray<\/code><\/strong>? Actually, the element may be in several DynArray<\/code><\/strong>s simultaneously, or even in the same DynArray<\/code><\/strong> more than once! So, it makes sense to keep a count of how many arrays each element is currently in; if the count is not zero at the time its destructor is called, it’s an ERROR!<\/p>\n<\/div>\n<\/div>\n\n\n\n
    How might we accomplish this? Well, let’s require that every class derived from DynArrayElement<\/code><\/strong> must implement a standard set of virtual functions. We can do that by writing our DynArrayElement<\/code><\/strong> class to include them as pure virtual functions:<\/p>\n\n\n\n
    \n
    \n
    <\/path><\/path><\/svg><\/span>
    class<\/span> <\/span>DynArrayElement<\/span><\/span>\n{<\/span><\/span>\n  <\/span>public:<\/span><\/span>\n    <\/span>virtual<\/span> <\/span>~DynArrayElement<\/span>();<\/span>  \/\/ Why virtual?<\/span><\/span>\n    \/\/ Virtual functions to be implemented<\/span><\/span>\n    \/\/ by all derived classes<\/span><\/span>\n    <\/span>virtual<\/span> <\/span>void<\/span> <\/span>OnInsertion<\/span>(<\/span>DynArray<\/span> <\/span>&<\/span>array<\/span>) = <\/span>0<\/span>;<\/span><\/span>\n    <\/span>virtual<\/span> <\/span>void<\/span> <\/span>OnRemoval<\/span>(<\/span>DynArray<\/span> <\/span>&<\/span>array<\/span>) = <\/span>0<\/span>;<\/span><\/span>\n};<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
    \n
    Function OnInsertion()<\/code><\/strong> is called by the DynArray<\/code> <\/strong>code when it inserts an element into itself, and function OnRemoval()<\/code><\/strong> is called by the DynArray<\/code> <\/strong>code when it removes it from itself. In each case, the function provides a reference to the DynArray<\/code> <\/strong>instance to which the element is being added, in case the element needs to make use of that information. What each function does is totally dependent on the derived class. Indeed, different derived classes may do totally different things. These functions may keep a count of the number of arrays the instance is in, or they may perform more complex housekeeping. What they do, or should do, is the business of that class, and not of the DynArray<\/code><\/strong> class. So we delegate<\/em><\/strong> those functions to the element class, where it belongs.<\/p>\n<\/div>\n<\/div>\n\n\n\n
    \n
    Note<\/strong>: Since we always use the DynArrayElement<\/code><\/strong> class with the DynArray<\/code> <\/strong>class, we will place its declarations in the dynarray.h<\/code>
    file. The implementation of the DynArray<\/code><\/strong> class will be in the dynarray.cpp<\/code> file.<\/p>\n<\/blockquote>\n\n\n\n
    <\/span>Use of Exceptions<\/em><\/span><\/h4>\n\n\n\n
    Several of the member functions of the DynArray<\/code> <\/strong>class have to deal with exceptional conditions. For example, an attempt to access an element via an index, when there is no element at that index, should be invalid. In this case, the function will throw an exception — specifically an ArrayOutOfBoundsException<\/code><\/strong>.<\/p>\n\n\n\n
    To make our exceptions simpler to deal with, we organize them into a class hierarchy:<\/p>\n\n\n\n
    \n
    \n
    <\/path><\/path><\/svg><\/span>
    class<\/span> <\/span>Exception<\/span><\/span>\n{<\/span><\/span>\n  <\/span>public:<\/span><\/span>\n    <\/span>virtual<\/span> <\/span>~Exception<\/span>() {}<\/span><\/span>\n};<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>OutOfMemoryError<\/span> : <\/span>public<\/span> <\/span>Exception<\/span><\/span>\n{<\/span><\/span>\n};<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>ArrayOutOfBoundsException<\/span> : <\/span>public<\/span> <\/span>Exception<\/span><\/span>\n{<\/span><\/span>\n};<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
    Since we are using these exceptions only for the DynArray<\/code> <\/strong>class, we will place their declarations in the dynarray.h<\/code> file.<\/p>\n<\/div>\n\n\n\n
    \n
    We do this so that we can catch a specific one of these exceptions by doing something like:<\/p>\n\n\n\n
    <\/path><\/path><\/svg><\/span>
      <\/span>try<\/span><\/span>\n  {<\/span><\/span>\n    \/\/ code that may throw an exception<\/span><\/span>\n  }<\/span><\/span>\n  <\/span>catch<\/span> (ArrayOutOfBoundsException &e)<\/span><\/span>\n  {<\/span><\/span>\n    \/\/ Do something...<\/span><\/span>\n  }<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
    Alternatively, we can catch any of these exceptions by doing something like:<\/p>\n\n\n\n
    <\/path><\/path><\/svg><\/span>
      <\/span>try<\/span><\/span>\n  {<\/span><\/span>\n    \/\/ code that may throw an exception<\/span><\/span>\n  }<\/span><\/span>\n  <\/span>catch<\/span> (Exception &e)<\/span><\/span>\n  {<\/span><\/span>\n    \/\/ Do something...<\/span><\/span>\n  }<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n<\/div>\n\n\n\n
    <\/span>Requirements for the <\/em>DynArray<\/code> class<\/em><\/span><\/h4>\n\n\n\n
    Here are the requirements for this DynArray<\/code><\/strong> class:<\/p>\n\n\n\n
      \n
    1. A constructor that accepts two arguments: int initialCapacity<\/code><\/strong>, the initial storage capacity of the array, and int capacityIncrement<\/code><\/strong>, how much to increase the element’s capacity on each expansion. The default value for each of these arguments will be 10: DynArray(int initialCapacity = 10, int capacityIncrement = 10);<\/strong><\/li>\n\n\n\n
    2. The copy constructor and the assignment operator will be disabled (at least for the moment): 
      DynArray(const DynArray &array);<\/strong> 
      DynArray &operator=(const DynArray &array);<\/strong><\/li>\n\n\n\n
    3. A destructor that performs the necessary cleanup for the array: ~DynArray();<\/strong> What does ‘necessary cleanup’ mean here? [Hint: It means more than a simple delete<\/strong>!]<\/strong><\/li>\n\n\n\n
    4. An access method to return the number of elements currently stored in the array: int ElementCount() const ;<\/strong><\/li>\n\n\n\n
    5. An access method to return the current capacity of the array: int Capacity() const;<\/strong><\/li>\n\n\n\n
    6. An access method to return the array’s capacity increment: int CapacityIncrement() const;<\/strong><\/li>\n\n\n\n
    7. A method to ensure that the array has at least the specified capacity. If it doesn’t, then the array is expanded appropriately: void EnsureCapacity(int minCapacity);<\/strong> If the function fails to expand the array, it throws OutOfMemoryError<\/strong>.<\/li>\n\n\n\n
    8. A method to trim the array’s capacity down to size (i.e. reduce its capacity to the actual number of elements currently stored): void TrimToSize();<\/strong> If the function fails to contract the array, it throws OutOfMemoryError<\/strong>.<\/li>\n\n\n\n
    9. A method to determine whether the array is empty or not: bool IsEmpty() const;<\/strong> Returns a Boolean value; true if the array has no elements, false otherwise.<\/li>\n\n\n\n
    10. A method to determine whether the specified element is in the array: bool Contains(const DynArrayElement &element) const;<\/strong> Returns a Boolean value; true if element is in the array, false otherwise. Note that it is possible for an element to be in the array more than once.
      Hint<\/strong>: This may be implemented by delegating most of its work to another member function in this class.<\/em><\/li>\n\n\n\n
    11. A method to add an element to the end of the array: void AddElement(const DynArrayElement &element);<\/strong> 
      Note that, if there is insufficient capacity for this element to be added, the array of pointers will be automatically extended. If the function fails to expand the array, it throws OutOfMemoryError<\/strong>. An element may be placed in the same array more than once.<\/li>\n\n\n\n
    12. A method to remove an element from an array: bool RemoveElement(const DynArrayElement &element);<\/strong> Returns a Boolean value; true if the element was found and removed, false otherwise. If an element occurs more than once in the array, only the first occurrence is removed.<\/li>\n\n\n\n
    13. A method to remove an element from an array, using its index: void RemoveElementAt(int index);<\/strong> If there is no element with that index, the function throws ArrayOutOfBoundsException<\/strong>.<\/li>\n\n\n\n
    14. A method to remove all elements from an array, from last to first: void RemoveAllElements();<\/strong> 
      (Think about how one might do this efficiently.)<\/li>\n\n\n\n
    15. A method to set an element into the array at a particular index, replacing the element that was previously there: void SetElementAt(const DynArrayElement &element, int index);<\/strong> The index must be within the range: (0 <\/strong>to ElementCount()-1)<\/strong>, else the function throws an ArrayOutOfBoundsException<\/strong>. The previous element at that index is discarded (removed from the array).<\/li>\n\n\n\n
    16. A method to insert an element into the array at a particular index: void InsertElementAt(const DynArrayElement &element, int index);<\/strong> The index must be within the range: (0 <\/strong>to ElementCount()-1)<\/strong>, else the function throws an ArrayOutOfBoundsException<\/strong>. Elements with an index greater than or equal to the current index are shifted up to make room.<\/li>\n\n\n\n
    17. A method to return the index of an element in the array: int IndexOf(const DynArrayElement &element, int indexStart = 0) const;<\/strong> Searches the array for the specified element, starting from indexStart. Returns the index of the element, if it is in the array; -1 if it is not in the array. If the element is in the array more than once, the index of the first occurrence encountered is returned.<\/li>\n\n\n\n
    18. An overloaded operator[]<\/strong><\/code> :DynArrayElement &operator[](int index);<\/strong> Allows the user to access DynArrayElement<\/strong>s stored in a DynArray<\/strong> using subscript syntax (for example da[5]<\/strong><\/code>). <\/li>\n\n\n\n
    19. An overloaded operator[]<\/code><\/strong> :const DynArrayElement &operator[](int index) const;<\/strong>Allows the user to access DynArrayElement<\/strong>s stored in a const DynArray<\/strong> using subscript syntax.<\/li>\n<\/ol>\n\n\n\n
      \n
      Note that the overloaded operator[]<\/code><\/strong> operators do not<\/em> do the equivalent of SetElementAt<\/code><\/strong>, or InsertElementAt<\/strong><\/code>, or RemoveElementAt<\/code><\/strong>.  Do you understand why?<\/p>\n<\/blockquote>\n\n\n\n
      <\/span>Requirements for testing<\/em><\/span><\/h4>\n\n\n\n
      You will need to test your DynArray <\/strong>class, and so you’ll need to create a non-abstract class that can be used in such an array. In other words, it must be derived from DynArrayElement<\/strong>, and must implement the OnInsertion() and OnRemoval() virtual member functions. Let’s use something really simple: a Double<\/strong> class:<\/p>\n\n\n\n
      \n
      \n
      <\/path><\/path><\/svg><\/span>
      class<\/span> <\/span>Double<\/span> : <\/span>public<\/span> <\/span>DynArrayElement<\/span><\/span>\n{<\/span><\/span>\n  <\/span>public:<\/span><\/span>\n    <\/span>Double<\/span>(<\/span>double<\/span> <\/span>d<\/span>);<\/span><\/span>\n    <\/span>Double<\/span>(<\/span>const<\/span> <\/span>Double<\/span> <\/span>&<\/span>d<\/span>);<\/span><\/span>\n    <\/span>Double<\/span> <\/span>&<\/span>operator=<\/span>(<\/span>const<\/span> <\/span>Double<\/span> <\/span>&<\/span>d<\/span>);<\/span><\/span>\n    <\/span>virtual<\/span> <\/span>~Double<\/span>();<\/span><\/span>\n    <\/span>double<\/span> <\/span>DoubleValue<\/span>() <\/span>const<\/span>;<\/span>  \/\/ return m_value<\/span><\/span>\n<\/span>\n    <\/span>virtual<\/span> <\/span>void<\/span> <\/span>OnInsertion<\/span>(<\/span>DynArray<\/span> <\/span>&<\/span>array<\/span>);<\/span><\/span>\n    <\/span>virtual<\/span> <\/span>void<\/span> <\/span>OnRemoval<\/span>(<\/span>DynArray<\/span> <\/span>&<\/span>array<\/span>);<\/span><\/span>\n  <\/span>private:<\/span><\/span>\n    <\/span>double<\/span> m_value;<\/span>     \/\/ The encapsulated value<\/span><\/span>\n    <\/span>int<\/span> m_inArrayCount;<\/span> \/\/ Count of array memberships<\/span><\/span>\n                        \/\/ (initialized to 0)<\/span><\/span>\n};<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
      \n
      Here’s what you’ll need to implement the Double <\/strong>class<\/p>\n\n\n\n
        \n
      • The constructors. These should be self-explanatory (but don’t forget to use initializer lists!)<\/li>\n\n\n\n
      • The assignment operator. Again, this should be simple (but don’t forget the assignment to self problem!)<\/li>\n\n\n\n
      • The DoubleValue()<\/strong> access method. Trivial!<\/li>\n\n\n\n
      • The OnInsertion()<\/strong> function. It should simply increment the m_inArrayCount<\/code><\/strong>.<\/li>\n\n\n\n
      • The OnRemoval()<\/strong> function. It should simply decrement the m_inArrayCount<\/strong>.<\/li>\n\n\n\n
      • The destructor. This is very slightly trickier — you will need to test whether m_inArrayCount<\/strong> is zero or not. Use the assert<\/strong> macro to assert that its value should be zero. (See assert.h<\/strong>)<\/li>\n<\/ul>\n<\/div>\n<\/div>\n\n\n\n
        Note that it is a good idea to ‘instrument’ your code with stuff like:<\/p>\n\n\n\n
        cout << \"Double element inserted into DynArray\" << endl;<\/strong><\/code><\/pre>\n\n\n\n
        so you can trace what’s happening during execution.<\/p>\n\n\n\n
        Write yourself a test program to test that everything works. Be thorough!<\/p>\n\n\n\n
        <\/span>Part 2: Enhancements <\/em><\/span><\/h3>\n\n\n\n
        Change your DynArray <\/strong>class so that it is derived from DynArrayElement<\/strong>. Why might this be a good idea?<\/p>\n\n\n\n
        Does your class now compile? What do you have to do to make it compile?<\/p>\n\n\n\n
        Here is a function you can use to test this out:<\/p>\n\n\n\n
        \n
        \n
        <\/path><\/path><\/svg><\/span>
        void<\/span> <\/span>TestIt<\/span>(<\/span>void<\/span>)<\/span><\/span>\n{<\/span><\/span>\n  DynArray parent;<\/span><\/span>\n  DynArray child1, child2, child3;<\/span><\/span>\n<\/span>\n  <\/span>parent<\/span>.<\/span>AddElement<\/span>(child1);<\/span><\/span>\n  <\/span>parent<\/span>.<\/span>AddElement<\/span>(child2);<\/span><\/span>\n  <\/span>parent<\/span>.<\/span>AddElement<\/span>(child3);<\/span><\/span>\n<\/span>\n  Double <\/span>d1<\/span>(<\/span>1.0<\/span>), <\/span>d2<\/span>(<\/span>2.0<\/span>), <\/span>d3<\/span>(<\/span>3.0<\/span>);<\/span><\/span>\n<\/span>\n  <\/span>child1<\/span>.<\/span>AddElement<\/span>(d1);<\/span><\/span>\n  <\/span>child1<\/span>.<\/span>AddElement<\/span>(d2);<\/span><\/span>\n  <\/span>child1<\/span>.<\/span>AddElement<\/span>(d3);<\/span><\/span>\n<\/span>\n  Double <\/span>d4<\/span>(<\/span>4.0<\/span>), <\/span>d5<\/span>(<\/span>5.0<\/span>), <\/span>d6<\/span>(<\/span>6.0<\/span>);<\/span><\/span>\n<\/span>\n  <\/span>child2<\/span>.<\/span>AddElement<\/span>(d4);<\/span><\/span>\n  <\/span>child2<\/span>.<\/span>AddElement<\/span>(d5);<\/span><\/span>\n  <\/span>child2<\/span>.<\/span>AddElement<\/span>(d6);<\/span><\/span>\n<\/span>\n  Double <\/span>d7<\/span>(<\/span>7.0<\/span>), <\/span>d8<\/span>(<\/span>8.0<\/span>), <\/span>d9<\/span>(<\/span>9.0<\/span>);<\/span><\/span>\n<\/span>\n  <\/span>child3<\/span>.<\/span>AddElement<\/span>(d7);<\/span><\/span>\n  <\/span>child3<\/span>.<\/span>AddElement<\/span>(d8);<\/span><\/span>\n  <\/span>child3<\/span>.<\/span>AddElement<\/span>(d9);<\/span><\/span>\n  cout << <\/span>" "<\/span>;<\/span><\/span>\n  <\/span>for<\/span> (<\/span>int<\/span> k = <\/span>0<\/span>; k < <\/span>child1<\/span>.<\/span>ElementCount<\/span>(); k++)<\/span><\/span>\n  {<\/span><\/span>\n    cout << <\/span>"["<\/span> << k << <\/span>"] "<\/span>;<\/span><\/span>\n  }<\/span><\/span>\n  cout << endl;<\/span><\/span>\n  <\/span>for<\/span> (<\/span>int<\/span> i = <\/span>0<\/span>; i < <\/span>parent<\/span>.<\/span>ElementCount<\/span>(); i++)<\/span><\/span>\n  {<\/span><\/span>\n    DynArray &child = (DynArray &)(<\/span>parent<\/span>[i]);<\/span><\/span>\n    cout << <\/span>"["<\/span> << i << <\/span>"]: "<\/span>;<\/span><\/span>\n    <\/span>for<\/span> (<\/span>int<\/span> j = <\/span>0<\/span>; j < <\/span>child<\/span>.<\/span>ElementCount<\/span>(); j++)<\/span><\/span>\n    {<\/span><\/span>\n      Double &d = (Double &)(<\/span>child<\/span>[j]);<\/span><\/span>\n      cout << <\/span>d<\/span>.<\/span>DoubleValue<\/span>() << <\/span>" "<\/span>;<\/span><\/span>\n  }<\/span><\/span>\n    cout << endl;<\/span><\/span>\n  }<\/span><\/span>\n<\/span>\n  <\/span>child3<\/span>.<\/span>RemoveAllElements<\/span>();<\/span><\/span>\n  <\/span>child2<\/span>.<\/span>RemoveAllElements<\/span>();<\/span><\/span>\n  <\/span>child1<\/span>.<\/span>RemoveAllElements<\/span>();<\/span><\/span>\n  <\/span>parent<\/span>.<\/span>RemoveAllElements<\/span>();<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
        \n
        Before you get too concerned about the amount of work you might have to do for this assignment, here’s some statistics from my implementation, including the enhancements:<\/p>\n\n\n\n
          \n
        • dynarray.h:<\/code> approximately 95 lines of code, including whitespace and comments<\/li>\n\n\n\n
        • dynarray.cpp<\/code>:<\/strong> approximately 240 lines of code, including whitespace and comments.<\/li>\n\n\n\n
        • longest function: 38 lines of code, including whitespace and comments.<\/li>\n\n\n\n
        • most functions 10 lines or less, including whitespace and comments.<\/li>\n<\/ul>\n<\/div>\n<\/div>\n\n\n\n
          Happy coding!<\/strong><\/p>\n\n\n\n
          <\/p>\n","protected":false},"excerpt":{"rendered":"
          Vector: A Dynamic Array Class The standard Java class library contains a useful class called Vector. It is actually a kind of dynamic array. This assignment involves writing a C++ class, called DynArray, that emulates a subset of the Java Vector class (see here). In addition, it involves writing other, related, classes, and is a useful exercise in the […]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":29,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"","meta":{"footnotes":""},"class_list":["post-36","page","type-page","status-publish","hentry"],"blocksy_meta":[],"_links":{"self":[{"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages\/36","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=36"}],"version-history":[{"count":9,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages\/36\/revisions"}],"predecessor-version":[{"id":1697,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages\/36\/revisions\/1697"}],"up":[{"embeddable":true,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages\/29"}],"wp:attachment":[{"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/media?parent=36"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}