(sp07t2)
2. Write a template for the class Comaprable that stores an instance of some
variable for which "<" is defined. Instances of the class should respond to
the methods min()  (max()) by returning an instance of Comparable containing
the value from the smaller  (larger) of two instances.  For example, the code
below should produce the indicated output.
   Comparable <int> a(5),b(3);
   cout<<a.min(b)<<" "<<a.max(b)<<endl;  // [3] [5]
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
template <class X>
class Comparable{
public:
  Comparable(const X &x);
  Comparable min(const Comparable &t)const;
  Comparable  max(const Comparable &t)const;
  template <class V>
  friend ostream & operator<<(ostream &out,const Comparable<V> &c);
private:
  X data;
};

template <class X>
Comparable<X>::Comparable(const X &x):data(x){}

template <class X>
Comparable<X> Comparable<X>::min(const Comparable&t)const{
  if(data<t.data)
    return *this;
  return t;
}

template <class X>
Comparable<X> Comparable<X>::max(const Comparable&t)const{
  if(data>t.data)
    return *this;
  return t;
}

template <class X>
ostream &operator <<(ostream &out,const Comparable<X> &c){
  out<<"["<<c.data<<"]";
  return out;
}
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
(sp07f)
2. Write a template for the class Magnitude that stores an instance of some
variable or object for which "<", "==", and "<<" are defined. Instances of the
class should respond to the binary operators "<", "==", and "<=".  Below is
some sample code.
  Magnitude <int> m(5), n(3);
  cout<<"("<<m<<"=="<<n<<")=="<<(m==n)<<endl; //OUTPUT: (5==3)==0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
template <class C>
class Mag{
public:
  Mag(const C&c=NULL);
  template <class A>
  friend bool operator<(const Mag<A>&a, const Mag<A> &b);
  template <class A>
  friend bool operator<=(const Mag<A>&a, const Mag<A> &b);
  template <class A>
  friend bool operator==(const Mag<A>&a, const Mag<A> &b);
  template <class A>
  friend ostream & operator<<(ostream &out,const Mag<A> &m);
private:
  C x;
};

template <class A>
Mag<A>::Mag(const A &c):x(c){}

template <class A>
 bool operator<(const Mag<A>&a, const Mag<A> &b){
   return a.x<b.x;
}
template <class A>
bool operator<=(const Mag<A>&a, const Mag<A> &b){
  return a.x<b.x || a.x==b.x;
}
template <class A>
bool operator==(const Mag<A>&a, const Mag<A> &b){
  return a.x==b.x;
}
template <class A>
ostream & operator<<(ostream &out,const Mag<A> &m){
  out<<m.x;
  return out;
}
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
(sp07f)
6.  Write a class to represent a bank account to which one may make deposits
(with the += operator), from which one may make withdrawals (with the -=
operator), and from which one can get a report of the current balance (with
the method balance()).  Below is some sample code, where the account is
opened with an initial deposit of $50.
  Account x(50);
  x+=23;
  cout<<"The account has $"<<x.balance()<<endl;
      //OUTPUT: The account has $73
  x-=30;
  cout<<"Now the account has $"<<x.balance()<<endl;
      //OUTPUT:  Now the account has $43
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#include <iostream>
using namespace std;

class Account{
public:
  Account(double j=0);
  Account & operator+=(double j);
  Account & operator-=(double j);
  double balance()const;
private:
  double money;
  void check(bool b, char *mess);
};

Account::Account(double j):money(j){
  check(money>=0,"Cannot open with a negative amount");
}

Account & Account::operator+=(double d){
  check(d>=0,"Cannot deposit a negative amount");
  money+=d;
  return *this;
}

Account & Account::operator-=(double d){
  check(d>=0,"Cannot withdraw a negative amount");
  check(money-d>=0,"Cannot overdraw account");
  money-=d;
  return *this;
}

double Account::balance()const{return money;}

void Account::check(bool b, char *mess){
  if(!b){
      cerr<<"ERROR: "<<mess<<endl;
      exit(1);
  }
}

<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
(f06f)
3.  An "association" consists of a "key" and a "value" (e.g., a dictionary
is a collection of associations, whose keys are the words to be defined, and
the values are the definitions), where the key is set at creation, but the
value may be changed later.  Write a template for an Association class.
It should have sufficient functionality (and need not have any more
functionality) so that the follow code will compile and generate the
indicated output.
      Association <int, double>  y(2,5.6),z(y);
      z.setVal(32.2);
      cout<<y.getKey()<<" "<<y.getVal()<<" "
          << (y<z) << (y.getKey()<z.getKey())
               //both comparisons always produce the same result
          <<" "<<z<<endl;
     //output: 2 5.6 0 0 {key: 2, value: 32.2}
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
#include <iostream>
using namespace std;

template <class X,class Y>
class Association
{public:
  Association(const X&a,const Y&b);
  Association(const Association &a);
  void setVal(const Y&a);
  X getKey()const;
  Y getVal()const;
  bool operator<(const Association & a);
  template <class U, class V>
  friend ostream & operator<<(ostream &out,const Association<U,V> & a);
private:
  X key;
  Y value;
};

template <class X, class Y>
Association<X,Y>::Association(const X&a,const Y&b):key(a),value(b){}

template <class X, class Y>
Association<X,Y>::Association(const Association &a):key(a.key),value(a.value){}

template <class X, class Y>
X Association<X,Y>::getKey()const{return key;}

template <class X, class Y>
void Association<X,Y>::setVal(const Y&a){value=a;}

template <class X, class Y>
Y Association<X,Y>::getVal()const{return value;}

template <class X, class Y>
bool Association<X,Y>::operator<(const Association & a){return key<a.key;}

template <class X, class Y>
ostream & operator<<(ostream & out, const Association<X,Y> & a)
{out<<"{key "<<a.key<<", value: "<<a.value<<"}";
return out;
}
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
(s06t1)
3. Abstractly, the node of a linked list consists of a key, used for sorting,
a pointer to the next Link, and a variable containing the actual information.
Minimally, the key should be required to  enable the operations of "<" and
"==", and "<<" should be overloaded for both keys and the variable containing
the information.  Write a template for a class Link to implement such a
template. Below are some uses of the template.
Link <int, double> a(6,3.0), c(9,3.7);//key of type int, data of type double
Link <String, Rek> b;   //the key is of type String, data of type Rek
cout<<"This is link a: "<<a<<endl;
cout<<(a<c)<<endl;
Hint: Model your template after the class Link we developed in class
==========================================================================
#include <iostream>
using namespace std;
template <class X, class Y>
class Link
{public:
  Link();
  Link(const X &x,const Y &y);
  bool operator<(const Link& a)const;
  bool operator==(const Link& a)const;
  bool operator<=(const Link& a)const;  //not really required
  template <class U, class W>
  friend ostream & operator<<(ostream & out, const Link<U,W> & a);
  Y data;
Link *next;
 private:
  X key;
};

template <class X, class Y>
Link<X,Y>::Link(const X &x, const Y &y):data(y),key(x){}

template <class X, class Y>
Link<X,Y>::Link():{}

template <class X, class Y>
bool Link<X,Y>::operator<(const Link &a)const
{return key<a.key;}

template <class X, class Y>
bool Link<X,Y>::operator<=(const Link &a)const
{return key<=a.key;}

template <class X, class Y>
bool Link<X,Y>::operator==(const Link &a)const
{return key==a.key;}

template <class U, class W>
ostream & operator<<(ostream &out, const Link<U,W> & a)
{out<<"["<<a.key<<", "<<a.data<<"]";
 return out;
}
==============================================================
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
(s06f)
6.  Write the template for a class ShowRay which is intended to save the
reference to an array of some type and then display (parts of) the array
to the screen in various formats. The code below indicates how the templated
class should behave.

int y[10];
ShowRay<int> sy(y);
for(int j=0;j<10;j++)
 y[j]=j*j+6;
sy.show(3,6,'[',']','|');//show y[3]..y[6] surrounded by [] and separated by |
        //[ 15| 22| 31| 42]
sy.show(6,7,'{','}',',');
           //show y[6], y[7], surrounded by by {} and separated by ,
           //{ 42, 55}
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
#include <iostream>
using namespace std;
template <class X>
class ShowRay
{public:
  ShowRay(X * r);
  void show(int j, int k,char left='[', char right=']',char sep=',');
 private:
  X *ray;
};

template <class X>
ShowRay<X>::ShowRay(X *r):ray(r){}

template <class X>
void ShowRay<X>::show(int j, int k, char left, char right, char sep)
{cout<<left<<" ";
 for(int n=j; n<=k; n++)
   {if(n>j)
     cout<<sep<<" ";
   cout<<ray[n];
   }
 cout<<right;
}
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
(f05t1)
2. An abstraction of a "message" consists of an object that can hold at most
one item.  It starts out empty and then items can be added and removed so long
an item is added only when the "message" is empty, and an item is removed
only when the "message" contains an item. Write a templated class that
implements the abstracton of a "message."  Below is some code that uses the
template, using the type A:
  class A
  {public:
     A(int n){j=n;}
     int j;
  };
////sample code
  Message <A> m;
  m.add(A(3));
  cout<<"This message contains "<< m.get().j <<endl;    //This message contains 3
  cout<<"Now remove "<< m.remove().j <<endl;    //Now remove 3
  if(m.empty())
    cout <<"The message contains no item.\n";  //The message contains no item
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
#include <fstream.h>

template <class X>
class Message
{public:
  Message();
  void add(const X &x);
  X remove();
  X get()const;
  bool empty()const;
private:
 X data;
 bool occupied;
 static void check(bool b,char *mess);
};

template <class X>
 Message<X>::Message():occupied(false){}

template <class X>
void Message<X>::add(const X &x)
{check(!occupied,"Adding to occupied message");
  data=x;
 occupied=true;
}

template <class X>
X Message<X>::remove()
{check(!occupied,"ERROR: Trying to remove an empty message");
 occupied=false;
 return data;
}

template <class X>
bool Message<X>::empty()const
{return !occupied;}

template <class X>
void Message<X>::check(bool b, char *mess)
{if(!b)
  {cerr<<"ERROR: "<<mess<<endl;
   exit(1);
  }
}
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
(f05f)
3.  We normally think of a point as a pair of ints (or doubles), but we could
generalize the idea to a pair where the first member of the pair is of one
type and the second member of the pair is of a second type.  Write a
template (the declaration and code) for a class called Point whose instances
have variables of different types for the two entries. Below is code that
should compile and produce the indicated output, given your template.  Your
template need only have the necessary declarations to enable the code below
to compile and run correctly.
  Point <bool,char> p(true,'a');
  cout<<p<<endl;     //OUTPUT: (1,a)
                     //NOTE: "cout<<true<<false" displays 10
  p.setX(false).setY('q');
  cout<<p<<endl;     //OUTPUT:  (0,q)
  Point <double, Point<bool,char> > r(7.3,p);
  cout<<r<<endl;     //OUTPUT:  (7.3, (0,q))
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
#include <fstream.h>

template <class X, class Y>
class Point
{public:
  Point(const X & a, const Y & b);
  Point & setX(const X &a);
  Point& setY(const Y &b);
  template <class A, class B>
  friend ostream & operator << (ostream & out,const Point<A,B> & p);
private:
  X x;
  Y y;
};

template <class X, class Y>
Point<X,Y>::Point(const X & a, const Y & b):x(a), y(b){}

template <class X, class Y>
Point<X,Y> &Point<X,Y>::setX(const X &a){x=a; return *this;}

template <class X, class Y>
Point<X,Y>& Point<X,Y>::setY(const Y & b){ y=b; return *this;}

template <class X, class Y>
ostream & operator << (ostream & out, const Point<X,Y> &p)
{out<<"("<<p.x<<", "<<p.y<<")";
 return out;
}

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
(s05f)
2.  Write a template for (the definition and code for) a class called Range
that maintains the largest and smallest values it has been given, discarding
the rest.  It should have a constructor that takes two values of the base
type to set the initial range.  It should overload += to enable (the potential)
addition of new values to the range, it should have methods max() and min() for
access to the largest and smallest value, and it should overload << for display
of the largest and smallest value, e.g., "[12, 23]".  The class can assume
that instances of the base type enable '<' and '>'. Here is some sample
code.
    Range<int> x(10,20); //constructor requires min before max, min<max
    x+=3; //range changed to [3,20]
    x+=17; //range unaffected
    cout<<x,min()<<" "<<x.max()<<" "<<x<<endl; //"3 20 [3,20]"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#include <fstream.h>

template <class X>
class Range
{public:
  Range(const X &a, const X&b);
  Range();
  X min()const;
  X max()const;
  Range & operator+=(const X&x);
  template <class Y>
  friend ostream & operator<<(ostream & out,const Range<Y> &r);
 private:
  X small,large;
  static void check(bool b, char*mess);
};

template <class X>
Range<X>::Range(const X&a, const X&b):small(a),large(b)
{check(a<b,"Bad initial range"); }

template <class X>
Range<X>::Range(){check(false,"No range specified");}

template <class X>
X Range<X>::min()const{return small;}

template <class X>
X Range<X>::max()const{return large;}

template <class X>
Range<X> & Range<X>::operator+=(const X &x)
  {if(x<small)
    small=x;
   else if(x>large)
    large=x;
   return *this;
}

template <class X>
ostream & operator<<(ostream & out,const Range<X> &r)
{out<<"["<<r.small<<", "<<r.large<<"]";
 return out;
}

template <class X>
void Range<X>::check(bool b,char*mess)
 {if(!b)
   {cerr<<"ERROR: "<<mess<<endl;
    exit(1);
   }
 }
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
(f04t1)
3.  Write the template for a class Point that behaves like the one we
discussed in class. In particular, the following code should compile
and produce the output indicated:
   Point<int> a(2,3);
   a.set(Point<int>::X,32);
   //Note: This could also be written a.set(a.X,32);
   cout<<"The point "<<a<<" has y component "<<a.get(Point<int>::Y)<<endl;
   //  Output: The point (32,3) has y component 3
   //Note: The above code could also be
   //cout<<"The point "<<a<<" has y component "<<a.get(a.Y)<<endl;
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
template <class T>
class Point
{public:
  static const int X=0,Y=1;
  Point(const T & ex, const T & why);
  void set(int k,const T &t);
  T get(int k) const;
  template <class V>
  friend ostream & operator<<(ostream &out,const Point<V> & p);
 private:
   T x,y;
};

template <class T>
Point<T>::Point(const T & ex, const T & why):x(ex),y(why){}

template <class T>
void Point<T>::set(int k, const T &t)
{if(k==X)
  x=t;
 else
  y=t;//doesn't detect t!=Y
}

template <class T>
T Point<T>::get(int k)const
{if(k==X)
  return x;
 else
  return y; //doesn't detect t!=Y
}
  template <class V>
  ostream & operator<<(ostream &out,const Point<V> & p)
{out<<"("<<p.x<<", "<<p.y<<")";
 return out;
}
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
(s04f)
6. Create a class called Stack that has the properties of a stack. Write the
class declaration and definitions (code) so that class Stack can do the
following, where we assume class Word, which holds strings of char.

int main()
{
   Stack <double> a;
   Stack  <Word> b;
   a.push(2.5);
   cout << a.pop();
   b.push("hello");
   cout << b.pop();
   return 0;
}
#include <fstream.h>
#include "word.cc"
template <class T>
class Stack
{public:
  Stack();
  Stack& push(T t);
  T pop();
private:
  int top;
  T stack[40];
  static void check(bool b,char *mess);
};
template <class T>
Stack<T>::Stack()
  {top = 0;}
template <class T>
Stack<T> & Stack<T>::push(T n)
  {check(top < 40,"stack overflow");
   stack[top]=n;
   top++;
   return  *this;
  }
template <class T>
T Stack<T>::pop()
  {check(top > 0,"stack underflow");
   top--;
   return stack[top];
  }
template <class T>
void Stack<T>::check(bool b,char *mess)
{if(!b)
  {cerr<<"ERROR[Stack<>]: "<<mess<<endl;
   exit(1);
  }
}
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
(f03t2)
1.  Write a template for a class Between.  Instances of Between are created
with two values and respond to the message good() by returning true if and
only if good()'s argument lies between the two values (inclusive).  For
example, given  Between <Word> a("good","bad");  a.good("cool") returns true,
while a.good("man") returns false.  For another example, given
Between <int> b(12,18); b.good(18) returns true, while b.good(21) returns
false.
>>>>>>>>>>>>>>>>>>>>>>>>.
template <class T>
class Between
{public:
  Between(const T &a, const T&b);
  bool good(const T &t);
 private:
  T low,high;
};

template <class T>
Between<T>::Between(const T&a,const T&b)
{if(a<b)
  {low=a;
   high=b;
  }
 else
  {low=b;
   high=a;
  }
}

template <class T>
bool Between<T>::good(const T&t)
{return low<=t && t<=high;}
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
(f03f)
5.  Write the template for a class RayDisplay whose only purpose is to
display the contents of an array.  The following code should compile and
list the contents of each array, one entry per line.
int main()
{ int x[]={1,2,3};
  double y[]={2.3, 2.4, 2.5, 2.8, 2.9};
  RayDisplay <int> a(x,3);
  RayDisplay <double> b(y,5);
  cout<<a<<b;
}

#include <fstream.h>
#include <stdlib.h>
template <class X>
class RayDisplay
 {public:
   RayDisplay(X x[],int n);
   ~RayDisplay();
  template <class Y>
   friend ostream & operator << (ostream &out,const RayDisplay<Y> & r);
  private:
   X *y;
   int size;
 };

template <class X>
RayDisplay<X>::RayDisplay(X x[],int n)
{bool good;
 if(n<=0)
  good=false;
 else y=new X[n];
 good=good && y!=NULL;
 if(!good)
  {cerr<<" Bad n or heap overflow\n";
   exit(1);
  }
 size=n;
 for(int j=0; j<size; j++)
  y[j]=x[j];
}

template <class Y>
  RayDisplay<Y>:: ~RayDisplay(){delete []y;}

template <class Y>
ostream & operator<<(ostream &out,const RayDisplay<Y> & r)
{for(int j=0; j<r.size; j++)
  out<<r.y[j]<<endl;
 return out;
}
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<