Output and Subscripting of String class Objects

NOTE:

These are a little sketchy...I'll fill in details 'soon'.

Output

simple:

    ostream & operator<<(ostream & out,
                         const String & other) // friend?
    {
        return out << other.string;
    }

better:

    ostream & operator<<(ostream & out,
                         const String & other) // friend?
    {
        return out << ((other.string==nullptr)?(""):(other.string));
    }

best:

    ostream & operator<<(ostream & out,
                         const String & other) // friend?
    {
        long i, wide, shorter;
        if (other.length > 0)
        {
            wide = out.width(0);
            if (wide != 0)
            {
                shorter = min(wide,other.length);
                if (((out.flags() & ios::adjustfield) != ios::left) &&
                    (shorter < wide))
                {
                    out << setw(wide-shorter) << "";
                }
                for (i = 0; i < shorter; i++)
                {
                    out << other.string[i];
                }
                if (((out.flags() & ios::adjustfield) == ios::left) &&
                    (shorter < wide))
                {
                    out << setw(wide-shorter) << "";
                }
            }
            else
            {
                out << other.string;
            }
        }
        return out;
    }

Subscript

we'd be tempted to do:

    char String::operator[](long index)
    {
        return string[index];
    }

but that would leave much to be desired: range checking for one. to fix this you might do:

    char String::operator[](long index)
    {
        return (index < length) ? (string[index]) : (EOS);
    }

brilliant! but it forgets the most common error of programmers: negative indices! how about:

    char String::operator[](long index)
    {
        return ((index >= 0) && (index < length))
                   ? (string[index])
                   : (EOS);
    }

much better! of course, this is great when they have:
```
    String x;
    cout << x[i];
```
but it doesn't work too well when they try to do:
```
    String x;
    x[i] = 'a';
```

this doesn't work because our [] returns a (copy of a) char. in order to do assignment, we would have to have a reference. so we do:

    char & String::operator[](long index)
    {
        return ((index >= 0) && (index < length))
                   ? (string[index])
                   : (EOS);
    }

but this brings up 2 problems. first off, EOS is a constant and can't be referenced. we could make the return value a constant reference, but that would break the assignment again!
to fix the EOS problem, we'll need a new (old) concept: the static local variable. static local variables differ in several key ways from regular local variables. first off, they are preceeded by the keyword ...*drum roll*... 'static'! secondly, they continue to exist between function calls (regular locals will disappear and be recreated on the next call). this allows them to retain their value from one function call to the next. finally, static locals are only initialized during the first call to their function (that's initialized -- not assigned).

taking all of this into account, we alter our [] operator thusly:

    char & String::operator[](long index)
    {
        static char error;
        error = EOS;
        return ((index >= 0) && (index < length))
                   ? (string[index])
                   : (error);
    }

this is great! this is wonderful! this isn't quite complete!

of course, we now cannot handle things like:

    void fnc(const String & arg)
    {
        ...arg[i]...
    }

since the argument is a constant, the subscript operator won't be allowed since it is a non-const member. some of you would like to immediately do:

    char & String::operator[](long index) const
    {
        static char error;
        error = EOS;
        return ((index >= 0) && (index < length))
                   ? (string[index])
                   : (error);
    }

merely adding a const to the end of the function head. sadly, this breaks our contract with the compiler since now you are returning a reference into an array which is supposed to be constant! so that's out.
but soft! what light thru yonder window breaks! it is the overload, and const is the sun!

that's right, since we can have 2 overloaded methods differing only in their const-ness, we can do:

    char & String::operator[](long index)
    {
        static char error;
        error = EOS;
        return ((index >= 0) && (index < length))
                   ? (string[index])
                   : (error);
    }

    char String::operator[](long index) const
    {
        return ((index >= 0) && (index < length))
                   ? (string[index])
                   : (EOS);
    }

and, voila! [] which can work on const as well as non-const String objects!
(those concerned that the const version lost the static local, it is okay: it only returns a copy of the constant -- not a reference.)