String& operator=( const String& RHS); 
String& operator+=( const String& RHS);

// Return string which is the concatenation of two strings
//
String operator+( const String&, const String& );

// Compare two strings (equality and relational operators)
//
bool operator==( const String&, const String& );
bool operator!=( const String&, const String& );
bool operator< ( const String&, const String& );
bool operator<=( const String&, const String& );
bool operator> ( const String&, const String& );
bool operator>=( const String&, const String& );

String::String(const String& RHS)
{
  Length = RHS.Length;
  Capacity = RHS.Capacity;
  Mem = RHS;
}

String::String(const char[] RHS)

int foo (int bar);

int foo (int bar) {
   return 0;
}

String::String(const String& RHS)

String::String(const char[] RHS)

unsigned capacity;
unsigned length;
char * mem;

struct String {
   unsigned capacity, length;
   char * mem;
}

String::String (const char * rhs) {
   /*
    * Determine that rhs is a valid pointer and then determine it's length. If you can
    * use strlen otherwise you will need to search the char array looking for the
    * terminating '\0' character (indicating the end of the c-style string
    * Once you know the length, assign it to the appropriate field of the String object
    */

   /*
    * Allocate memory for your new string using the size you just determined. new would
    * work just fine here, but you need to remember to delete in the destructor or you
    * will have caused a memory leak
    */

   /*
    * Once you have a fresh buffer, copy the argument into it
    */

   /*
    * The capacity should initially be the size of the string (or the next higher power of 2)
    * And as the string grows the capacity should indicate how large a chunk of memory
    * you have in 'mem' and length should indicate how much of that memory is used
    * Realize that at no time should length > capacity == true
    */
}

String& String::operator+= (const String& rhs) {
   /*
    * determine the length of rhs
    * determine the length of this
    * if capacity is less than the sum of those two values, you
    * know that you have to allocate more memory. If you 
    * listened to what I mentioned earlier, you will just allocate
    * double this->capacity and then this->capacity should get
    * a new value of twice itself (since you just increased the size
    * of the buffer)
    * Otherwise, you do not need to allocate more space, just copy
    * rhs onto the end of this and return
    */
   
   return *this;
}

String& String::operator+= (const String& rhs)
{
  unsigned totalLen = rhs.Length + Length;
  if (totalLen < Capacity)
    {
      //fill the Mem[] with the rhs String
    }
  else
  {
    Capacity = totalLen; //or Capacity = Capacity*2, just something that
    //fill the Mem[] with the rhs String once Capacity has been increased
  }
  return *this;
}

String& String::operator+= (const String& rhs)
{
  unsigned totalLen = rhs.Length + Length;
  if (totalLen < Capacity)
    {
      //fill the Mem[] with the rhs String
      /*
       * You will want to place rhs.mem into this->mem starting
       * at location this->mem[this->length] since this->mem contains
       * the string for *this* object, the one we are adding to
       */
    }
  else
  {
    Capacity = totalLen; //or Capacity = Capacity*2, just something that
    //fill the Mem[] with the rhs String once Capacity has been increased
      /*
       * First, you will need a new copy of a buffer (returned by new), into that
       * you copy this->mem and then rhs.mem. Dont forget your bookeeping...
       * Adjust this->length to account for the new length of the string and free
       * the buffer that was too small before exiting this call
       */
  }
  return *this;
}

String& String::operator+= (const String& rhs) {
   /*
    * blah, blah, blah - do the copy stuff....
    */
   std::cout << "Inside operator+=, returning new String: " << mem << std::endl;
   return *this;
}