Перегрузка оператора +

myclass b, c;
myclass a = b + c;

friend SomeClass operator+ ( const SomeClass&, const SomeClass& );

class String
{
private:
    char* ptr;
    size_t size;
public:
    String() 
    {
        size = 0;
    }
    ~String()
    {
        if (size) delete[] ptr;
    }
    size_t length();
    bool SetLength(size_t NewLength)
    {
        if (!size)
        {
            size = NewLength;
            ptr = (char*)calloc(NewLength, sizeof(char));
        }
        else
        {
            size = NewLength;
            ptr = (char*)realloc(ptr, size * sizeof(char));
        }
        return true;
    }
    const char operator[] (size_t index)
    {
        return ptr[index];
    }
    const char* operator= (const char* str)
    {
        if (size) delete[] ptr;
        size = strlen(str);
        ptr = new char[size + 1];
        strcpy(ptr, str);
        return str;
    }
    const char* operator+ (const char* str1, const char* str2)
    {
 
    }
};

#include <iostream>
using namespace std;
 
class cClass1
{
    protected:
        double value;
    public:
        cClass1() {
            value = 0;
        }
        double operator + (const cClass1 &pAdd);
        double operator + (const double  &pAdd);
        double GetValue(){return value;}
};
 
double cClass1::operator + (const cClass1 &pAdd){
    return value + pAdd.value;
}
 
double cClass1::operator + (const double  &pAdd){
    return value + pAdd;
}
 
int main(){
    cClass1 p;
    double q = p + 5;
    cout<<q<<endl;
    return 0;
}

friend const char* operator+ (const char* str1, const char* str2)

String val = String(str1) + str2;

struct PasString
{
unsigned char size;
unsigned char[0];
}

class String
{
private:
    char* ptr;
    size_t size;
public:
    String() 
    {
        size = 0;
    }
    String(const char* str)
    {
        size = strlen(str);
        ptr = (char*)calloc(size + 1, sizeof(char));
        strcpy(ptr, str);
    }
    ~String()
    {
        if (size) delete[] ptr;
    }
    size_t length()
    {
        return size;
    }
    bool SetLength(size_t NewLength)
    {
        if (!size)
        {
            size = NewLength;
            ptr = (char*)calloc(size, sizeof(char));
        }
        else
        {
            size = NewLength;
            ptr = (char*)realloc(ptr, size * sizeof(char));
        }
        return true;
    }
    const char operator[] (size_t index)
    {
        return ptr[index];
    }
    const char* operator= (const char* str)
    {
        if (size) delete[] ptr;
        size = strlen(str);
        ptr = new char[size + 1];
        strcpy(ptr, str);
        return str;
    }
    /*const char* operator= (const String str)
    {
        if (size) delete[] ptr;
        size = str.length();
    }*/
    const String operator+ (const char* str)
    {
        char* tmp = (char*)calloc(size + strlen(str) + 1, sizeof(char));
        strcpy(tmp, ptr);
        strcat(tmp, str);
        return String(tmp);
    }
};