// CS401 - C++
// FLOYD PORTER
// HOMEWORK #2

// ****************************************************************
//
// EXERCISE 4-1. HOW SHOULD THE FOLLOWING ERROR FUNCTION BE DEFINED
//               IN ORDER TO HANDLE THE FOLLOWING CALLS:
//
// *****************************************************************

//               error("Array out of bounds :", index, upperBound);
//               error("Division by zero");
//               error("Invalid selection", selectVal);

//     ANSWER :  error(char* int int)

//               DEFAULT VALUE PASSED FOR 2nd AND 3rd INSTANCES





// *****************************************************************
//
// EXERCISE 4-2. IDENTIFY WHICH, IF ANY, OF THE FOLLOWING TEMPLATE 
//               FUNCTION DEFINITIONS ARE ILLEGAL. CORRECT EACH ONE
//               YOU IDENTIFY.
//
//******************************************************************


//     ANSWER :  THE FOLLOWING TEMPLATE FUNCTION IS ILLEGAL:

//               a. template <class T, U, class V>         // error
//                  void foo( T, U, V):

//                  template <class T, class U, class V>   // correct
//                  void foo( T, U, V):




// *******************************************************************
//
// EXERCISE 4-3. GIVEN THE FOLLOWING SET OF TEMPLATE INSTANCES,
//               SPECIALIZATIONS AND VARIABLE DECLARATIONS:
//
// *******************************************************************
//
//               int i;               unsigned int ui;
//               char str[24];        int ia[24];

//               template <class T> T max(T*,int);
//               template <class T> T max(T,T);
//               char max( char*, int );
//               double max( double, double );

//               IDENTIFY WHICH, IF ANY, TEMPLATE INSTANCE IS INVOKE
//               FOR EACH OF THE FOLLOWING CALLS:

//     ANSWER :  a. char max( str, 24 );
//               b. none
//               c. template <class T> T max(T*,int);
//               d. template <class T> T max(T,T);
//               e. template <class T> T max(T*,int);
//               f. char max( str, 24 );




// **************************************************************
//
// EXERCISE 4-4. REWRITE THE BINARY SEARCH FUNCTION DEFINED IN
//               SECTION 3.10 (PAGE 140) AS A TEMPLATE FUNCTION
//               WRITE A PROGRAM TO CALL IT. PASS IT IN TURN AN
//               ARRAY OF doubles AND AN ARRAY OF ints.
//
// ***************************************************************



const notFound = -1;                          // global scope

template <class T>
T binSearch( T *ia, int sz, T val )

// try changing int sz & int val to Ts

{

// local scope: level #1

   int low = 0;
   int high = sz - 1;

   while ( low <= high )
   {
//  local scope: level #2

    int mid = (low+high)/2;
    if (val == ia[ mid ]) 
       return mid;
    if (val < ia[ mid ])
       high = mid-1;
    else
       low = mid+1;
   }
   return notFound;                           // local scope: level #1
}
            



// TEST PROGRAM FOR BINARY SEARCH

#include <iostream.h>

void main()
{

 double darray[] = { 5.58, 3.35, 4.19, 9.69 };
 
 int iarray[] = { 12, 16, 25, 15, 62};

 cout << " ****  THE OUPUT OF binSearch ****" << "\n\n\n";

 cout << "The search for 4.19 reveals " <<
       binSearch( darray, 4, 4.19 ) << "\n";

 cout << "The search for 12.12 reveals " <<
       binSearch( darray, 4, 12.12 ) << "\n";

 cout << "The search for 12 reveals " <<
       binSearch( iarray, 5, 12 ) << "\n";

 cout << "The search for 13 reveals " <<
       binSearch( iarray, 5, 45 ) << "\n";

}