This program runs for a few seconds and then bombs out

[Bopaki]

It runs okay but bombs out with this message:
Example10-1.exe has stopped working

A problem caused the program to stop working correctly.
Windows will close the program and notify you if a solution is available.

Then there is an option to Debug or Close program.

  #ifndef H_arrayListType
#define H_arrayListType

#include <iostream>
#include <cassert>

using namespace std;

template <class elemType>
class arrayListType
{
public:
    const arrayListType<elemType>& operator=(const arrayListType<elemType>&);
		//Overload the assignment operator

    bool isEmpty();
		//Function to determine whether the list is empty
		//Postcondition: Returns true if the list is empty; 
 		//        	    otherwise, returns false.
    bool isFull();
		//Function to determine whether the list is full
		//Postcondition: Returns true if the list is full; 
 		//               otherwise, returns false.
    int listSize();
		//Function to determine the number of elements in the list
		//Postcondition: Returns the value of length.
    int maxListSize();
		//Function to determine the size of the list
 		//Postcondition: Returns the value of maxSize.
    void print() const;
		//Function to output the elements of the list
		//Postcondition: Elements of the list are output on the 
 		//               standard output device.
    bool isItemAtEqual(int location, const elemType& item);
		//Function to determine whether the item is the same 
 		//as the item in the list at the position specified by
		//Postcondition: Returns true if the list[location] 
		//               is the same as the item; otherwise, 
		//		     returns false.
   void insertAt(int location, const elemType& insertItem);
		//Function to insert an item in the list at the 
		//position specified by location. The item to be inserted 
		//is passed as a parameter to the function.
		//Postcondition: Starting at location, the elements 
 		//               of the list are shifted down, 
 		//               list[location] = insertItem;, and
 		//               length++;    
 		//       If the list is full or location is out of
		//	   range, an appropriate message is displayed.    
   void insertEnd(const elemType& insertItem);
		//Function to insert an item at the end of the list 
		//The parameter insertItem specifies the item to be 
		//inserted.
		//Postcondition: list[length] = insertItem; and length++;
 		//               If the list is full, an appropriate 
		//               message is displayed.
    void removeAt(int location);
		//Function to remove the item from the list at the 
		//position specified by location 
		//Postcondition: The list element at list[location] is 
		//               removed and length is decremented by 1.
		//       If location is out of range, an appropriate message
		//       is displayed.
    void retrieveAt(int location, elemType& retItem);
		//Function to retrieve the element from the list at the  
		//position specified by location 
		//Postcondition: retItem = list[location] 
		//      If location is out of range, an appropriate 
		//      message is displayed.
    void replaceAt(int location, const elemType& repItem);
		//Function to replace the elements in the list at the 
		//position specified by location. The item to be replaced 
		//is specified by the parameter repItem.
		//Postcondition: list[location] = repItem 
		//      If location is out of range, an appropriate 
		//      message is displayed.
    void clearList();
		//Function to remove all the elements from the list 
		//After this operation, the size of the list is zero.
 		//Postcondition: length = 0;
    int seqSearch(const elemType& item);
  		//Function to search the list for a given item. 
		//Postcondition: If the item is found, returns the location 
		//               in the array where the item is found; 
   		//               otherwise, returns -1.
    void insert(const elemType& insertItem);
		//Function to insert the item specified by the parameter 
		//insertItem at the end of the list. However, first the
		//list is searched to see whether the item to be inserted 
		//is already in the list. 
		//Postcondition: list[length] = insertItem and length++
		//     If the item is already in the list or the list
		//     is full, an appropriate message is displayed.
    void remove(const elemType& removeItem);
		//Function to remove an item from the list. The parameter 
		//removeItem specifies the item to be removed.
		//Postcondition: If removeItem is found in the list,
		//      it is removed from the list and length is 
		//      decremented by one.

    arrayListType(int size = 100);
		//constructor
		//Creates an array of the size specified by the 
		//parameter size. The default array size is 100.
		//Postcondition: The list points to the array, length = 0, 
		//               and maxSize = size

    arrayListType(const arrayListType<elemType>& otherList); 
		//copy constructor

    ~arrayListType();
		//destructor
		//Deallocates the memory occupied by the array.

protected:
    elemType *list; 	//array to hold the list elements
    int length;		//to store the length of the list
    int maxSize;		//to store the maximum size of the list
};

[Bopaki]

here is the continuation of the implementation:

template<class elemType>
arrayListType<elemType>::~arrayListType()
{
	delete [] list;
}
template<class elemType>
arrayListType<elemType>::arrayListType(int size)
	{
		if(size < 0)
		{
			cerr<<"The array size must be positive. Creating "
			    <<"an array of size 100." <<endl;
			
			maxSize = 100;
		}
		else
			maxSize = size;
		length = 0;
		
		list = new elemType[maxSize];
		assert(list != NULL);
	}
	
template<class elemType>
void arrayListType<elemType>::insert(const elemType& insertItem)
{
	int loc;
	
	if(length == 0)                        //the list is empty
		list[length++] = insertItem; 		//insert the item and increment the length
	else
		if(length == maxSize)
			cerr<<"Cannot insert in a full list."<<endl;
		else
		{
			loc = seqSearch(insertItem);
			
			if(loc == -1)       //the item to be inserted
								//does not exist in the list
				list[length++] = insertItem;
			else
				cerr<<"The item to be inserted is already in "
				    <<"the list. No duplicates are allowed."<<endl;
		} //end insert
}
template<class elemType>
void arrayListType<elemType>::print() const
{
	for(int i = 0; i < length; i++)
		cout<<list[i] << " ";
	cout<<endl;
}
template<class elemType>
int arrayListType<elemType>::seqSearch(const elemType& item)
{
	int loc;
	bool found = false;
	
	for(loc = 0; loc < length; loc++)
		if(list[loc]  == item)
		{
			found = true;
			break;
		 } 
	if(found) 
		return loc;
	else
	return -1;
}   //end seqsearch

#endif

//#include "arrayListType.h"
#ifndef H_OrderedListType
#define H_OrderedListType

#include <iostream>
//#include "arrayListType.h"
//#include "listType.h"

using namespace std;

template<class elemType>
class orderedArrayListType: public arrayListType<elemType>
{
	public:
		void insertOrd(const elemType&);
		int binarySearch(const elemType& item);
		void selectionSort();
		
		orderedArrayListType(int size = 100);
	private:
		void swap(int first, int second);
		int minLocation(int first, int last);
};

template <class elemType>
void orderedArrayListType<elemType>::insertOrd(const elemType& item)
{
	int length;
    int first = 0;
    int last = length - 1;
    int mid;
    int list[100];
    int maxSize;

    bool found = false;

    if (length == 0)   //the list is empty
    {
       // listType[0] = item;
        list[0] = item;
		length++;
    }
    else if (length == maxSize)
        cerr << "Cannot insert into a full list." << endl;
    else
    {
        while (first <= last && !found)
        {
            mid = (first + last) / 2;

            if (list[mid] == item)
                found = true;
            else if (list[mid] > item)
                last = mid - 1;
            else
                first = mid + 1;
        }//end while

        if (found)
            cerr << "The insert item is already in the list. "
                 << "Duplicates are not allowed." << endl;
        else
        {
            if (list[mid] < item)
                mid++;

            insertAt(mid, item);
        }
    }
}//end insertOrd

//template<class elemType>
//int orderedArrayListType<elemType>::binarySearch
  //                                   (const elemType& item) const
//{
//	int length;
//	int first = 0;
  //  int last = length - 1;
//    int mid;
    
//    int list[100];

//    bool found = false;

//    while (first <= last && !found)
//    {
//        mid = (first + last) / 2;

//        if (list[mid] == item)
//            found = true;
//        else if (list[mid] > item)
//            last = mid - 1;
//        else
//            first = mid + 1;
//   }

//    if (found) 
//        return mid;
    //else
       // return ?1;
//       ;
//}//end binarySearch

template <class elemType>
void orderedArrayListType<elemType>::selectionSort()
{
	int i, j, n, loc, temp, min, array[100];
	 for(i = 0; i < n - 1; i++)
    {
        min = array[i];
        loc = i;
        for(j = i + 1; j < n; j++)
        {
            if(min > array[j])
            {
                min = array[j];
                loc = j;
            }
        }

        temp = array[i];
        array[i] = array[loc];
        array[loc] = temp;
    }
}
template<class elemType>
orderedArrayListType<elemType>::orderedArrayListType(int size)
 //: arrayListType(size)
{
	 size = 100;
}

#endif
//#ifndef ORDEREDARRAYLISTTYPE_H
//#define ORDEREDARRAYLISTTYPE_H

//class orderedArrayListType<elemType>
//{
//	public:
//	protected:
//};

//#endif
#include<iostream>
//#include "orderedArrayListType.h"

using namespace std;

int main() {
	
	orderedArrayListType<int> list;
	
	int num; 
	int i, n, array[10];
	
	cout<<"\nEnter numbers ending with -999\n";
	
	cin >> num;
	while(num != -999)
	{
		list.insert(num);
		cin >> num;
   	}
	
	cout<<"The list before sorting:"<<endl;
	list.print();
	cout<<endl;
	
	list.selectionSort();
	
	cout<<"The list after sorting:"<<endl;
	list.print();
	cout<<endl;
	
	return 0;
}

[keskiverto]

[EDIT] (Was too quick)

When does the program crash? You do have some printouts. Which do appear before the crash?

void orderedArrayListType<elemType>::selectionSort()
{
  int i, j, n, loc, temp, min, array[100]; // What is the value of array[0] now?
  for(i = 0; i < n - 1; i++) // What is the value of n here?
  {
    min = array[i];