C++ operator overloading, twice

Question

I'm trying to make an example exam for my test tomorrow but I ran into a small problem which will probably be a stupid mistake. There's a class which contains a char* that contains a C-string and an int that contains the length of that string. Now i need to make something like class[5] = 'd' work. But I've got no idea how. I know I can overload the [] operator to return a pointer to a specific letter of the string, but I can't assign a char directly to it.

My code:

#include <iostream>
#include <string>

using namespace std;

class DynString
{
private:
    char * _theString;
    int _charCount;

public:
    DynString(char * theString = nullptr) {
        if(theString == nullptr)
            _charCount = 0;
        else {
            _charCount = strlen(theString);
            _theString = new char[strlen(theString) + 1]; // +1 null-terminator
            strcpy(_theString, theString);
        }
    }

    char* operator[](int index) {
        return &_theString[index];
    }

    DynString operator+(const DynString& theStringTwo) {
        DynString conCat(strcat(_theString, theStringTwo._theString));
        return conCat;
    }

    void operator=(const DynString &obj) {
        _theString = obj._theString;
        _charCount = obj._charCount;
    }

    friend ostream& operator<< (ostream &stream, const DynString& theString);
    friend DynString operator+(char * ptrChar, const DynString& theString);

};

ostream& operator<<(ostream &stream, const DynString& theString)
{
    return stream << theString._theString;
}

DynString operator+(char * ptrChar, const DynString& theString) {
    char * tempStor = new char[strlen(ptrChar) + theString._charCount + 1] ;// +1 null-terminator
    strcat(tempStor, ptrChar);
    strcat(tempStor, theString._theString);

    DynString conCat(tempStor);
    return conCat;
}


int main()
{
    DynString stringA("Hello");
    DynString stringB(" Worlt");
    cout << stringA << stringB << std::endl;

    stringB[5] = 'd'; // Problem

    DynString stringC = stringA + stringB;
    std::cout << stringC << std::endl;

    DynString stringD;
    stringD = "The" + stringB + " Wide Web";
    std::cout << stringD << std::endl;

    return 0;
}

Answer 1

A little demonstration.

#include <iostream>
#include <string.h>
using namespace std;

class String
{
private:
    char *data;
    int length;
public:
    String(const char * str)
    {
        data = new char[strlen(str)];
        strcpy(data, str);
        length = strlen(data);
    }
    char &operator[](int index)
    {
        //dont forget to check bounds
        return data[index];
    }
    int getLength() const
    {
         return length;
    }
    friend ostream & operator << (ostream &out, String &s);
};
ostream &operator << (ostream &out, String &s)
{
    for (int i = 0; i < s.getLength(); i++)
        out << s[i];
    return out;
}
int main()
{
    String string("test");
    string[1] = 'x';

    cout << string;

    return 0;
}