More Arrays

• Goals
  • Remember how to pass arrays to functions
  • Remember factors involved with multidimensional arrays
  • Develop methods for employing run-time allocated static arrays.
  • Understand the basics of dynamic arrays
• Passing 1D arrays to functions
  • When passing an array to a function
    • You only pass a pointer to the array
      • So they are always pass by reference, or variable parameters.
      • But they can be labeled const
      • Why is it done this way?
    • You must always pass all but one dimension as part of the parameter definition
      • This is so the compiler can do the indexing.
      • These are supposed to be compile time constants.
    • Wit one dimensional arrays, this is not an issue

      int foo(float anarray[], int dim) 
      	     

• Static multidimensional arrays
  • What do multi dimensional arrays represent?
  • How do you declare a multi dimensional array?

    int foo[5][6]][7]
    	 

  • How would you initialize such an array?
  • How is the space of a multi-dimensional array different from that of a single dimensional array?
  • How do you pass a multi-dimensional array to a routine?
• Dynamic 2D arrays
  • Allocating
    • int xdim, ydim;
    • int * array
    • array = new int [xdim * ydim]
  • Indexing
    • array[x + y * xdim]
    • or array[y + x*ydim]
    • This stinks, but Stroustrup says this is the way to do it, The C++ Programming Language, third edition, P 839.
    • The first layout is how FORTRAN handles arrays, the second C/C++, but in some sense, it doesn't matter, as long as you keep you array bounds straight.
  • Passing to functions
• Dynamic N-dimensional arrays
  • array[x + y*xdim + z * xdim*ydim]
  • Again, there are permutations of this.
• A Dynamic Array Class
  • What if we wanted an array that would grow as we needed it to?
  • In this case, we want a truly dynamic structure
  • It should support all of the operations discussed in part one of these notes.
  • But also an operation to append an item to the end of the array. (push_back)
    • The array starts with 0 elements
    • array.push_back() will put an element into position 0.
    • How big do we make the array initially?
    • When do we add more memory and how?
    • Assume we add every time we call push_back.
      • Thus each time we need to copy all of the old data

        push_back(e) {
            newarray = new int[size+1];
            for(i=0;i<size;i++) {
                newarray[i] = array[i];
            }
            newarray[size] = e;
            delete (array);
            array = newarray;
            size++;
        }
        		     

      • What is the performance of this procedure?
      • Is that as good as it gets?
    • How about if we grab double the size of the array every time
      • Start with the size a power of 2, Assume 2
      • Now size is the number of elements and maxsize is the total array size.

        pushback(e) {
            if (size < maxsize) {
               array[size] = e;
               size++;
            } else {
               newarray = new int[2*maxsize];
               for(i=0;i<size;i++) {
                   newarray[i] = array[size];
               }
               maxsize *=2;
               array[size] = e;
               size++;
            }
        }
        
        		     

      • Now what is the performance?

        We are going to give a loose argument here.
        
        push_back call  time    size    maxsize    Total   Avg 
             1           1       0         1         1      1
             2           1+1     1         2         3     1.5
             3           2+1     2         4         6     2
             4           1       3         4         7     1.75 
             5           4+1     4         8         12    2
             6           1       5         8         13    2.17
             7           1       6         8         14    2 
             8           1       7         8         15    1.88
             9           8+1     8         16        24    2.67
             10          1       9         16        25    2.5 
             11          1       10        16        26    2.36
             12          1       11        16        27    2.25
             13          1       12        16        28    2.15
             14          1       13        16        29    2.07
             15          1       14        16        30    2
             16          1       15        16        31    1.94 
        		     

      • This is O(1) on average!
  • We could delete items with the erase operation
  • The same performance argument applys for cutting an array in half every time size gets less than 1/3 of maxsize!