Array classes

A major advantage of C++ over `traditional' programming languages is the ability to define array variables whose sizes are chosen at run time. The classes described here implement general array objects.

Extensive use is made of template classes, which are class definitions with arguments. For example, the generic array class can be used for arrays of any type of object. When an instance of the class is declared in a program, the type of object in an array is defined. This is illustrated in the examples below.

General array template

Definition

template  class Array

Data objects

int n; // number of elements in array

Methods

• Create completely new array.

     void Create(unsigned int nreq)
  

  (nreq is the requested number of elements)
• Recreate existing array, possible with a different size.

     void Recreate(unsigned int nreq)
  

  (nreq is the requested number of elements)
• Read from an input stream (elements only, not size).

     void Read_elements(istream &stream)
  

• Read from an input stream. (inherits through class classio, so >> operator can be used)
• Write to an output stream (elements only, not size).

     void Write_elements(ostream &stream)
  

• Write to an output stream. (inherits through class classio, so << operator can be used)
• Fill array with identical copies of an object.

     void Fill(const type& t)
  

  (t is the value to copy into each element of the array)
• Copy another object.

     Array& operator=(const Array& a)
  

  e.g.

     Array<double> a, b; cin >> a; b = a;
  

• Access an element in the array.

     type& operator[](const int& i) const
  

  e.g.

     Array<double> a; cin >> a; int i = 3; cout << a[i];
  

• Add a new element.

     void add_element(const type& newobj)
  

• Add several new elements.

     void add_elements(const array& newobj)
  

• Remove an element.

     void remove_element(const int& rem)
  

• Scatter elements into a larger array using a mask.

  friend void scatter(const array& gathered, const Array<int>& mask, array& full)
  

  mask is an array of zeroes and ones, one for each element of array full. Elements of gathered are copied into the elements of full corresponding to ones in mask.
• Gather elements from a larger array using a mask.

  friend void gather(const Array& full, const Array<int>& mask, Array& gathered)
  

  Inverse of scatter.
• Map elements into a new array using an array of indices.
  • Member function:

    Array map(const Array<int>& idx) const
    

    returns an array whose element i is element idx[i] in the present array.
  • Friend function:

    friend void map(const Array& a, const Array<int>& idx, Array& b) 
    

    maps a to b such that b[i] = a[idx[i]].
• Concatenate two arrays.

  friend Array concat(const Array& a, const Array& b)
  

  e.g.

  Array<double> a, b, c; cin >> a >> b; c = concat(a,b);
  

• Reverse the order of elements in the array.
  • Member function:

    void reverse()
    

    e.g.

    Array<double> a; cin >> a; a.reverse();
    

  • Friend function:

    friend Array reverse(const Array& a)
    

    e.g.

    Array<double> a, b; cin >> a; b = reverse(a);
    

• Create a new array whose elements are those of an existing array, in reverse order.

• Perform a generic operation on each element.

• Test arrays for (in)equality.

• Sort an array. Methods are included to sort by insertion, Shell's method, or heap-sorting, to sort in ascending or descending order, and to sort an index array instead of the data array. There are also methods which automatically select which sorting algorithm to use based on the number of elements in the array.

  // General sorting of array...
  template 
  void sort(Array& a, const int ascend = 1);
  // ... and index array (must be pre-dimensioned with the correct size)
  template 
  void sort(const Array& a, Array& idx, const int ascend = 1);
  
  // insertion
  template 
  void insertsort(Array& a, const int ascend = 1);
  template 
  void insertsort(const Array& a, Array& idx, const int ascend = 1);
  
  // Shell
  template 
  void shellsort(Array& a, const int ascend = 1);
  template 
  void shellsort(const Array& a, Array& idx, const int ascend = 1);
  
  // heap
  template 
  void heapsort(Array& a, const int ascend = 1);
  template 
  void heapsort(const Array& a, Array& idx, const int ascend = 1);
  

• Limit index range to fit in array
  • Global (array size must be supplied):

    static void spanlimit(
       const int ntot, // elements in array
       const int span, // elements in range
       int& start // suggested start of range in; corrected value out
    )
    

  • Using size of present array:

    void spanlimit(
       const int span, // elements in range
       int& start // suggested start of range in; corrected value out
    ) const
    

Arithmetic array template

Definition

General array template with stack space

Definition

General array template of named elements

Definition

General N-dimensional matrix template

Definition

N-dimensional arithmetic matrix template

Definition

N-dimensional arithmetic matrix template (fixed rank)

Definition

Subclasses of specific rank