C++/ADT/strings/arrays

• I will assume you have the C++ stuff down. (4.1 - 4.3)
• This is not primarily about C/C++, we just need to be able to read the book.
• Let us take a closer look at Arrays and strings.
• An Abstract Data Type is a specification of a set of data and the operations that can be performed on that data, which is independent of any implementation.
• Let us examine this in more detail
  • Integer:
    • What is the data
    • What are the operations?
    • Do we care (at this level) how an integer is represented or how the operations are performed?
  • String
    • What is the data? A collection of characters
    • What are the operations?
      • Assignment, comparison, length
      • substring extraction, substring location
      • concatenation
      • Actually, looking at the C++ book, there are MANY string operations.
    • What are the performance characteristics of a string?
      • Or at least what do we expect them to be?
      • Copy, creation? O(n), where n is the number of characters in the string.
      • Comparison? O(n)
      • Size? O(1)
      • Character extraction string[n]?
      • Substring insertion? Extraction?
    • In C++ do you know how the string is stored?
    • Two possible Implementations
      • A struct
        • The struct holds two fields
          • An array of characters
          • An int, indicating the size.
      • An array of characters terminated with a special character
    • In C, the second was used
      • This took one additional space
      • And the user had to maintain the null terminator '\0'
      • As well as all other memory.
      • Note, this was not very clean, and for the most part, you could not use strings until you could use arrays.
      • Is this the case with C++ strings?
• Notice, the string in C++ has the characteristics of an ADT, but the string in C does not.
• Look at Arrays
  • Is an Array an ADT?
    • As an abstract idea?
    • As is implemented in C/C++?
  • The array ADT
    • Data: a collection of homogeneous elements.
    • Operations:
      • Creation
      • Insertion
      • Random Access
      • Size
      • Copy?, Comparison?
      • Delete?, Insert
      • Resize?
  • C++ provides a set of standard containers
  • One of these is the vector class.
    • #include <vector>
    • vector <type> identifier;
    • vector <int> mytemps;
    • size() returns the number of elements.
    • cout << mytemps.size();
    • [] works like you would expect, as long as the index is valid.
    • Adding Elements:
      • push_back(element)
        • adds to the end of the vector.
        • This will change the size of the vector.
      • resize(sz, fill_element)
        • Will make the vector contain sz elements
        • Will fill with fill elements if it is not that size
        • Will delete the last size-sz elements if it is larger than sz.
      • Indexing [] works, as long as the index is between 0 and the size-1
    • Other Operations:
      • empty() returns true if the vector is empty.
      • clear() erases all elements
      • erase(begin, end) deletes all elements between beginning and end.
      • pop_back() deletes the last element
      • Comparisons and copy work as well.
    • There are other operators, get a good book for a reference.
    • You may, unless otherwise instructed, use the vector class for work in this class.
    • Let us put off discussion of how this is implemented and performance for now.
    • Iterators
      • vector <type>::iterator i;
      • vector <type>::const_iterator ci;
      • vector <type>::reverse_iterator ri;
      • vector <type>::const_reverse_iterator cri;
      • Const iterators point to items that we can't change.
      • V.begin() - points to the first element in the vector
      • V.end() points one past the last
      • for(i=V.begin();i != V.end(),i++)
      • The same is true for V.rbegin() - the last element
      • V.rend() - one past the first (a non element);
      • Iterators and reverse iterators are not the same type
      • Iterator operations on an vector
        • V.erase(j) erases the data at position j
        • V.insert(itr, value)
        • V.insert(itr, count, value)
      • From the C++ nutshell book:

        The most important point to remember about iterators is that they are inherently unsafe.
        	   

        • V.end() is not a data element
        • after v.erase(iterator) the iterator is no longer valid.
        • just like pointers into a list.
        • Iterators for a vector become invalid when the vector is reallocated:
          • erase (some)
          • insert
      • Some example code