String Class Problems

[DeathbyRegret]

Hi, I'm currently working on making a string class and there are a few parts I'm stuck on.

1. I overloaded my >> operator to take in a string of characters from the keyboard but I don't know how to get it to where it reads all the characters until it's done instead of white space. I figured I could use the getline function but I get the error: "no matching function for call to 'getline(std::istream&, char [200])"

2. I'm trying to overload my + operator to add two string of characters together and also add a single character with a string of characters but I'm get the
error: "must take either zero or one argument" for both of the operations.

3. I have to create a function that sees if there is a string of characters in a given object but I can't think of an algorithmic way of doing this. I was able to create a function to find a single character in an object but i can't think of a way to find consecutive characters. Any brief pseudocode would be great.

Any help on these 3 things would be appreciated. Here is my code:

//Header file

#ifndef STRING_H
#define	STRING_H

const int CAPACITY = 200;

class string
{
public:
    //CONSTRUCTORS

    string();
    string(const char[]);
    string(const char);
    
    //CONST MEMBER FUNCTIONS
    
    char operator[](const int) const;
    int length() const;
    bool operator ==(const string& rhs) const;
    bool operator !=(const string& rhs) const;
    bool operator < (const string& rhs) const;
    bool operator > (const string& rhs) const;
    bool operator <= (const string& rhs) const;
    bool operator >= (const string& rhs) const;
    string operator +(const string& rhs) const;
    bool findchar(const char& x) const;
    bool findstring(const string& x) const;
    
    //MEMBER FUNCTIONS

    char& operator[](const int);
    friend std::ostream& operator << (std::ostream& out, const string& a);
    friend std::istream& operator >> (std::istream& in, string& a);
    friend string operator +(const string& lhs, const string& rhs);
    friend string operator +(const char lhs, const string& rhs);


private:

    char str[CAPACITY];

};


#endif	/* STRING_H */


//------------------------------------------------------------------------------


//Implementation file 

#include <iostream>
#include <cassert>
#include "string.h"

/////////////////////////////CONSTRUCTORS//////////////////////////////////////

string::string()
{
    str[0] = '\0';
}

//------------------------------------------------------------------------------

string::string(const char a[])
{
    int i = 0;
    while(a[i] != '\0')
    {
        str[i] = a[i];
        ++i;
    }

    str[i] = '\0';

}

//------------------------------------------------------------------------------

string::string(const char a)
{
    str[0] = a;
    str[1] = '\0';
}

//------------------------------------------------------------------------------

/////////////////////////CONST MEMBER FUNCTIONS/////////////////////////////////

int string::length() const
{
    int num = 0;

    while(str[num] != '\0')
        ++num;

    return num;
}

//------------------------------------------------------------------------------

char string::operator[](const int i) const
{
    assert((i >= 0) && (i < CAPACITY));
    return str[i];
}

//------------------------------------------------------------------------------

bool string::operator ==(const string& rhs) const
{
    int i = 0;
    while((str[i]!= '\0') && (rhs.str[i] != '\0') && (str[i]==rhs.str[i]))
        ++i;

    if((str[i] == '\0') && (rhs.str[i] == '\0')) return true;
    else return false;
}

//------------------------------------------------------------------------------

 bool string::operator !=(const string& rhs) const
 {
     return !operator ==(rhs);
 }

 //-----------------------------------------------------------------------------

  bool string::operator <= (const string& rhs) const
  {
      int i = 0;
      while((str[i] != '\0') && (rhs.str[i] != '\0'))
      {
          if(str[i] <= rhs.str[i]) return true;
          if(str[i] >= rhs.str[i]) return false;
          ++i;
      }

      if((str[i] =='\0') && (rhs.str[i] != '\0')) return true;
      else return false;
  }

//------------------------------------------------------------------------------

  bool string::operator < (const string& rhs) const
  {
      int i = 0;
      while((str[i] != '\0') && (rhs.str[i] != '\0'))
      {
          if(str[i] < rhs.str[i]) return true;
          if(str[i] > rhs.str[i]) return false;
          ++i;
      }

      if((str[i] =='\0') && (rhs.str[i] != '\0')) return true;
      else return false;
  }

//------------------------------------------------------------------------------

  bool string::operator > (const string& rhs) const
  {
      return !operator <(rhs);
  }

//------------------------------------------------------------------------------

    bool string::operator >= (const string& rhs) const
    {
        return !operator <= (rhs);
    }

//------------------------------------------------------------------------------


string string::operator +(const string& rhs) const
{
    string result;
    int i =0;
    int size = length();
    while(rhs.str[i] != '\0')
    {
        result.str[size+i] = rhs.str[i];
        ++i;
    }
    return result.str[size + i] = '\0';
    return result;
}

//------------------------------------------------------------------------------

string string::operator +(const string& lhs, const string& rhs)
//Must either take one or no arguments error
{
    return lhs + rhs;
}

//------------------------------------------------------------------------------

string string::operator +(const char lhs, const string& rhs)
//Must either take one or no arguments error
{
    return lhs + rhs;
}

//------------------------------------------------------------------------------

bool string::findchar(const char& x) const
{
    int i = 0;
    while(str[i] != '\0')
    {
        if(str[i] != x)
            ++i;
        if(str[i] == x)
            return true;
    }

    return false;
    
}

//------------------------------------------------------------------------------

 bool string::findstring(const string& x) const
 {
     int i = 0;
     while (str[i] != '\0')
     {

     }

     return false;

 }

///////////////////////////MEMBER FUNCTIONS/////////////////////////////////////

std::ostream& operator << (std::ostream& out, const string& a)
{

    out << a.str;
    return out;
}

//------------------------------------------------------------------------------

std::istream& operator >> (std::istream& in, string& a)
{
  
    in >> a.str; //Works fine but only works until whitespace
    getline(in, a.str); //Get no matching function for call to getline error
    return in;
}

//------------------------------------------------------------------------------

char& string::operator[](const int i)
{
    assert((i >= 0) && (i < CAPACITY));
    return str[i];
}