Operator Overloading

[H0m3r0w]

Well, I had a problem earlier that "mtbusche" helped me out earlier with, but this is a bit different. Right now, I get a "... must take either zero or one argument" when placing my operator as a prototype into my header file. This is how it looks on both;

NOTE: I only really need help with the bold sections. But if you wanna help with anything else or spots some problems, I'm all for input :)

MyString.cpp

#include "MyString.h"

//The default constructor
MyString::MyString()
{
    sSize = 0; //set size to zero
    sCapacity = 16; //and capacity to 16
    sArray = new char[sCapacity + 1];
    sArray[0] = '\0';
}

//Second default constructor
MyString::MyString(const char* s)
{
    sSize = strlen(s);

    sCapacity = (sCapacity +15) & ~15;
    sArray = new char[sCapacity + 1];

    int i = 0;
    while ( s[i]!= '\0')
        {
            sArray[i]= s[i];
            i++;
        }
            sArray[sSize] = '\0';
}

//boolean functions
bool MyString::operator==(const MyString& rightOp) const
{
    if ((strcmp(this->sArray, rightOp.sArray) == 0))
        return true;
}

bool MyString::operator==(const char* rightOp) const
{
    if((strcmp(this->sArray, rightOp) == 0))
        return true;
}
//char functions that simply return the sub value of sArray
char MyString::operator[](int sub) const
{
    return sArray[sub];
}

char& MyString::operator[](int sub)
{
    return sArray[sub];
}

//a constant character that simply returns sArray
const char* MyString::c_str() const
{
    return sArray;
}

//boolean function that checks if sSize is equal to zero or not
bool MyString::empty() const
{
    if(sSize == 0){
        return true;
    }else{
        return false;
    }
}

//int function that simply returns the value of sSize
int MyString::size() const
{
    return sSize;
}

//resets the values of sArray and sSize
void MyString::clear()
{
    sArray[0] = '\0';
    sSize = 0;
}


bool operator == (const char* leftOp, const MyString& rightOp)
{
return (strcmp(leftOp, rightOp.c_str()) == 0);
}

MyString::MyString(const MyString& s)
{

sSize = s.sSize;
sCapacity = s.sCapacity;

//sSize = 0;
sArray = new char[sCapacity + 1];

strcpy(sArray, s.sArray);

}

int MyString::capacity() const
{
    return sCapacity;
}

MyString::~MyString()
{
    delete [] sArray;
}

MyString& MyString::operator=(const MyString& rightOp)
{
    if (this != &rightOp){
                delete [] sArray;
                sSize = rightOp.sSize;
                sCapacity = rightOp.sCapacity;
                sArray = new char[sCapacity + 1];
                strcpy (sArray, rightOp.sArray);
    }
    return *this;
}

MyString& MyString::operator=(const char* rightOp)
{
    delete [] sArray;
    sSize = strlen(rightOp);
    sCapacity = (sCapacity +15) & ~15;
    sArray = new char[sCapacity + 1];
    strcpy (sArray, this->sArray);

    return *this;
}

MyString MyString::operator+(const MyString& rightOp) const
{
    MyString resultObject;

    resultObject.sSize = this->sSize + rightOp.sSize;

    if(resultObject.sSize > resultObject.sCapacity){
        delete [] resultObject.sArray;
        resultObject.sCapacity = (resultObject.sCapacity + 15) & ~15;
        resultObject.sArray =  new char[resultObject.sCapacity + 1];
    }

    strcpy(resultObject.sArray, this->sArray);
    strcat(resultObject.sArray, rightOp.sArray);

    return resultObject;
}

MyString MyString::operator+(const char* rightOp) const
{
    MyString resultObject;

    resultObject.sSize = this->sSize + strlen(rightOp);

    if(resultObject.sSize > resultObject.sCapacity){
        delete [] resultObject.sArray;
        resultObject.sCapacity = (resultObject.sCapacity + 15) & ~15;
        resultObject.sArray =  new char[resultObject.sCapacity + 1];
    }

    strcpy(resultObject.sArray, this->sArray);
    strcat(resultObject.sArray, rightOp);

    return resultObject;
}

char MyString::at(int sub) const throw(out_of_range)
{
    if(sub < 0 || sub >= sSize){
        throw out_of_range("Subscript out of range");
    }
    else
    {
        return sArray[sub];
    }
}

char& MyString::at(int sub) throw(out_of_range)
{
    if(sub < 0 || sub >= sSize){
        throw out_of_range("Subscript out of range");
    }
    else
    {
        return sArray[sub];
    }
}

ostream& operator <<(ostream& leftOp, const MyString& rightOp)
{
leftOp << rightOp.c_str() <<endl;

return leftOp;
}

istream& operator >> (istream& leftOp, MyString& rightOp)
{
char st[81];
leftOp >> st;
MyString s(st);
rightOp = s;

return leftOp;
}

MyString operator+(const char* leftOp, const MyString& rightOp)
{

    MyString resultObject;

    resultObject.sSize = strlen(leftOp) + rightOp.sSize;
 // if the string does not fit in the array
    if(resultObject.sSize > resultObject.sSize){

        delete [] resultObject.sArray;

        resultObject.sCapacity = (resultObject.sCapacity + 15) & ~15;
        resultObject.sArray =  new char[resultObject.sCapacity + 1];

        }

    strcpy(resultObject.sArray, leftOp);
    strcat(resultObject.sArray, rightOp.sArray);

    return resultObject;
}

#ifndef MYSTRING_H
#define	MYSTRING_H

#include <cstring>
#include <string>
#include <iostream>
#include <iomanip>
#include <string.h>

using namespace std;

class MyString
{
    //friends
friend ostream& operator << (ostream& leftOp, const MyString& rightOp);
friend istream& operator >> (istream& leftOp, MyString& rightOp);
friend bool operator == (const char* leftOp, const MyString& rightOp);

    //class definitions
    private:
        
        char *sArray;
        int sCapacity;
        int sSize;
     
    public:
        
        MyString();
        MyString(const char* s);

        bool operator==(const MyString& rightOp) const;
        bool operator==(const char* rightOp) const;
        char operator[](int sub) const;
        char& operator[](int sub);
        const char* c_str() const;
        
        bool empty() const;
        int size() const;
        void clear();
        MyString(const MyString& s);

        char at(int sub) const throw();
        char& at(int sub) throw();
        
        int capacity() const;
        ~MyString();

        MyString& operator=(const MyString& rightOp);
        MyString& operator=(const char*);
        MyString operator+(const MyString&) const;
        MyString operator+(const char*) const;
        MyString operator+(const char*, const MyString&);
};

#endif	/* MYSTRING_H */ 

Looks scary doesn't it? Well really, I just have a little bit that I need help on. Everything seems to be compiling fine, minus the operator's prototype and related function. I mean, if you wanna help and spot anything I need to change, feel free to PM or reply back here, but right now I'm still trying to grasp this overloading thing, and errors annoy me. Here's the exact error message:

"MyString.h:61: error: 'MyString MyString::operator+(const char*, const MyString&)' must take either zero or one argument"

Thank you for any that plan on helping

[EricDu]

MyString's operator+ is either unary or binary operator, so they can only accept 0 or 1 input parameter.

Global operator+ can accept 2 input parameters.

[mik2718]

If you have a member (unary) operator+ then the left hand operand is *this

If you want to code as a global binary operator+ and you need to access private data in the class then make it a friend of the class