Overload operator[] for Char assignment - C++

Question

I am fairly new to C++, although I do have some experience programming. I have built a Text class that uses a dynamic char* as it's main member. The class definition is below.

#include <iostream>
#include <cstring>
using namespace std;


class Text
{
  public:

    Text();
    Text(const char*); // Type cast char* to Text obj
    Text(const Text&); // Copy constructor
    ~Text();

    // Overloaded operators
    Text& operator=(const Text&);
    Text operator+(const Text&) const; // Concat
    bool operator==(const Text&) const;
    char operator[](const size_t&) const; // Retrieve char at
    friend ostream& operator<<(ostream&, const Text&);

    void get_input(istream&); // User input

  private:
    int length;
    char* str;
};

The issue I am having is I don't know how to use operator[] to assign a char value at the given index that's passed in. The current overloaded operator operator[] is being used to return the char at the index supplied. Anyone have experience with this?

I would like to be able to do something similar to:

int main()
{
  Text example = "Batman";
  example[2] = 'd';

  cout << example << endl;
  return 0;
}

Any help and/or advice is appreciated!

Solution provided - Thanks a bunch for all the replies

char& operator[](size_t&); works

Answer 1

You need to provide a reference to the character.

#include <iostream>

struct Foo {
   char m_array[64];
   char& operator[](size_t index) { return m_array[index]; }
   char operator[](size_t index) const { return m_array[index]; }
};

int main() {
    Foo foo;
    foo[0] = 'H';
    foo[1] = 'i';
    foo[2] = 0;
    std::cout << foo[0] << ", " << foo.m_array << '\n';
    return 0;
}

http://ideone.com/srBurV

Note that size_t is unsigned, because negative indexes are never good.

Answer 2

You should overload operator[] as non const method and return a reference from it

char& operator[](const int&);

Answer 3

This article is the definitive guide to operator overloading in C++ (which, to be honest, is mainly boilerplate code for syntactic sugar). It explains everything that is possible: Operator overloading

Here's the portion that is of interest to you:

class X {
        value_type& operator[](index_type idx);
  const value_type& operator[](index_type idx) const;
  // ...
};

And yes, this is possible, for the many of the STL containers (the vector for example), allow for array subscript notation to access data.

So you can do something along the lines of this:

char & operator[]( size_t i )
{
    return *(str + i);
}