#include <iostream>
#include <fstream>
#include <sstream>
#include <iomanip>
#include <string>
#include <new>
#include <cstdlib>

using namespace std;

class STRING 
{
    friend ostream &operator << ( ostream &, const STRING & );
    friend istream &operator >> ( istream &, STRING & );
    
    public :
        STRING ( const char* = "" ); /*Conversion constructor*/
        STRING ( const STRING & ); /*Copy constructor*/
       ~STRING(); /*Destructor*/

        const STRING &operator = ( const STRING & );
        const STRING &operator += ( const STRING & );
            
        bool operator ! () const;
        bool operator == ( const STRING & ) const;
        bool operator < ( const STRING & ) const;

        
/* FOUR BOOL FUNCTION */
bool operator != ( const STRING &object ) const
{
    return ! ( *this == object );
}

bool operator > ( const STRING &object ) const 
{
    return object < *this;
}

bool operator <= ( const STRING &object ) const
{
    return ! ( object < *this );
}

bool operator >= ( const STRING &object ) const 
{
    return ! ( *this > object );
}

/*END ALL BOOL FUNCTION*/
        
        char &operator [] ( int );
        const char &operator [] ( int ) const;
        STRING operator () ( int, int );
        
        int getLength() const;
    private :
        int LEN;
        char *sPointer;
    
        void setString ( const char * );/*Utility function*/
};



/*Default constructor */
STRING::STRING ( const char *aString ) : LEN (strlen(aString))
{
    cout << "Conversion constructor : " << aString << "\n";
    setString ( aString );
}

/*Copy constructor receive one argument passed by reference*/
STRING::STRING ( const STRING &itsCopy ) : LEN ( itsCopy.LEN )
{
    cout << "Copy constructor [][][][] " << itsCopy.sPointer << endl;
    setString ( itsCopy.sPointer );
}

STRING::~STRING()
{
    cout << "RECLAIM MEMORY ! " << sPointer << endl;
    delete [] sPointer;
}

const STRING &STRING::operator = ( const STRING &object )
{
    cout << " OPERATOR = " << endl;
    if ( &object != this )
    {
        delete [] sPointer;
        LEN = object.LEN;
        setString ( object.sPointer );
    }
    else
        cout << "Assign a string to itself !!";
    
    return *this;
}

const STRING &STRING::operator += ( const STRING &object )
{
    size_t newLength = LEN + object.LEN;
    char *tmp = new char[newLength + 1];
    
    strcpy ( tmp, sPointer );
    strcpy ( tmp + LEN, object.sPointer );
    
    delete [] sPointer;
    sPointer = tmp;
    LEN = newLength;

    return *this;
}

bool STRING::operator !() const
{
    return LEN == 0;
}

bool STRING::operator == ( const STRING &object ) const
{
    return strcmp ( sPointer, object.sPointer ) == 0;
}

bool STRING::operator < ( const STRING &object ) const
{
    return strcmp ( sPointer, object.sPointer ) < 0;
}

char &STRING::operator [] ( int subscript )
{
    if ( subscript < 0 || subscript >= LEN )
    {
        cout << "ERROR : " << endl;
    
        exit (1);
    }
    return sPointer[subscript];
}

const char &STRING::operator [] ( int subscript ) const
{
    if ( subscript < 0 || subscript >= LEN )
    {
        cout << "ERROR CONST " << endl;
        
        exit (1);
    }
    return sPointer[subscript];
}

STRING STRING::operator () ( int dex, int subL )
{
    if ( dex < 0 || dex >= LEN || subL < 0 )
    {
        return "";
    }
    
    int tmpLength;
    
    if ( (subL == 0) || ( dex + subL > LEN ) )
        tmpLength = LEN - dex;
    else
        tmpLength = subL;
    
    char *tmpPointer = new char[tmpLength + 1];
    
    strncpy ( tmpPointer, &sPointer[dex], tmpLength );
    tmpPointer[tmpLength] = '\0';

    /*Create temporary STRING object containing the substring*/
    STRING objectString ( tmpPointer );
    delete [] tmpPointer;
    
    return objectString; /*return copy of the objectString*/
}

int STRING::getLength() const
{
    return LEN;
}

/*Utility function*/
void STRING::setString ( const char *STR )
{
    sPointer = new char[LEN + 1];
    strcpy ( sPointer, STR );
}

ostream &operator << ( ostream &output, const STRING &object )
{
    output << object.sPointer;
    return output;
}

istream &operator >> ( istream &input, STRING &object )
{
    char tmp[100]; /*buffer store input*/
    input >> setw(100) >> tmp;
    object = tmp; /*using assignment operator*/
    
    return input;
}

int main()
{
    STRING chan( "happy" );
    STRING bao ( "birthday");
    STRING another;
    
    cout << chan << endl;
    cout << bao << endl;
    cout << another << endl;

    cout << ( chan == bao ? "true" : "false" ) << endl;
    cout << ( chan != bao ? "true" : "false" ) << endl;
    cout << ( chan > bao ? "true" : "false" ) << endl;
    cout << ( chan < bao ? "true" : "false" ) << endl;
    cout << ( chan >= bao ? "true" : "false" ) << endl;
    cout << ( chan <= bao ? "true" : "false" ) << endl;
    
    if ( !another )
    {
        cout << "Iam empty, assign chan to another " << endl;
        another = chan;
    }
    
    cout << "chan += bao ";
    chan += bao;
    cout << chan << endl;
    
    chan += "to you";
    cout << chan << endl;
    
    
    cout << chan ( 0, 13 ) << "\n\n";
    
    
    /*create a new object by using copy constructor*/
    STRING *ptr = new STRING (chan );
    
    *ptr = *ptr;
    cout << *ptr;
    
    delete ptr;
    chan[0] = 'H';
    chan[6] = 'B';    
    
    system ("pause");
}