Is there a memory leak?

Question

I have tried to write my own String class in C++ using Microsoft Visual Studio 2015. I wrote the class like this;

#include<string.h>
class myString {
    private:
        char* content;
    public:
        int size;
        myString();
        myString(char*);
        ~myString();
        bool operator==     (const myString &) const;
        bool operator!=     (const myString &) const;
        myString operator=  (const myString &);
        myString operator+  (const myString &) const;
        myString operator+= (const myString &);
        friend std::ostream& operator<< (std::ostream &os, const myString &);
        char operator[] (int &) const;
};

std::ostream& operator<<(std::ostream &os, const myString &string) {
    os << string.content;
    return os;
}

myString::myString() {
    size = 0;
    content = "\0";
}

myString::myString(char* newContent) {
    size = strlen(newContent);
    content = new char[size+1];
    strcpy(content, newContent);
}

myString::~myString() {
    delete[] content;
}

myString myString::operator= (const myString &string) {
    if (size != string.size) {
        delete[] content;
        size = string.size;
        content = new char[size+1];
    }
    strcpy(content, string.content);
    return *this;
}

bool myString::operator== (const myString &string) const {
    if (size != string.size)
        return false;
    if (strcmp(content, string.content))
        return false;
    return true;
}

bool myString::operator!= (const myString &string) const {
    if (*this == string)
        return false;
    return true;
}

myString myString::operator+ (const myString &string) const {
    int newSize = size + string.size;
    char* newContent = new char[newSize];
    strcpy(newContent, content);
    strcat(newContent, string.content);
    return myString(newContent);
}

myString myString::operator+= (const myString &string) {
    *this = *this + string;
    return *this;
}

char myString::operator[] (int &index) const {
    return content[index];
}

It works fine when I tried to do this;

#include<iostream>
#include "MyString.h"
using namespace std;

int main() {
    myString s("my new");
    cout << s+" string" << endl;    
}

But I am not sure if there is any memory leak in operator+ function in the line char* newContent = new char[newSize]; I am allocating new space from the memory and I need it in the return statement return myString(newContent); .

So I can not deallocate it before this line and I can not deallocate it after the return statement. Am I correct, is there a memory leak? If so, how can I fix this?

EDIT 1 : I've changed the operator+ function as follows with the help of Prince Dhaliwal;

myString myString::operator+ (const myString &string) const {
    myString temp;
    int newSize = size + string.size;
    char* newContent = new char[newSize + 1];
    temp.size = newSize;
    strcpy(newContent, content);
    strcat(newContent, string.content);
    temp.content = newContent;
    return temp;
}

But since I created the temp locally it calls its destructor before returning it and gives error. I supposed I should allocate memory for temp too. And I changed the function as follows;

myString myString::operator+ (const myString &string) const {
    myString* temp= new myString;
    int newSize = size + string.size;
    char* newContent = new char[newSize+1];
    temp->size = newSize;
    strcpy(newContent, content);
    strcat(newContent, string.content);
    temp->content = newContent;
    return *temp;
}

It works fine now, but I believe there is still memory leak because of the temp variable. If there is a memory leak, how to fix this?

EDIT 2 : I've fixed it simply by creating a Copy Constructor

Answer 1

There is actually a memory leak in your code. When you are using the + operator in s + " string" . In your operator+() definition ie

myString myString::operator+ (const myString &string) const {
    int newSize = size + string.size;
    char* newContent = new char[newSize];
    strcpy(newContent, content);
    strcat(newContent, string.content);
    return myString(newContent);
}

You are allocating the new string here char* newContent = new char[newSize]; , copying the older and new part to the new string. And again you are allocating the new string in the constructor return myString(newContent); . But where are you deleting your old string? Its nowhere in your code. So you have to delete the string newContent . You can do this

myString myString::operator+ (const myString &string) const {
    myString temp;
    int newSize = size + string.size;
    char* newContent = new char[newSize + 1];
    temp.size = newSize;
    strcpy(newContent, content);
    strcat(newContent, string.content);
    temp.content = newContent;
    return temp;
}

UPDATE You have to create a copy constructor.

myString(const myString &rhs) :
size(rhs.size) {
    content = new char[size + 1];
    strcpy(content, rhs.content);
}