namespace util
{

    class indexException:public std::exception
    {
        public:
        virtual const char* what()
        {
            return "Index is either too long, or negative";
        }
    };

    class string
    {
        public:
        static const unsigned int length_max=100;
        string(const char* field=NULL)
        {
            if(field!=NULL)
            {
                const unsigned int length=strlen(field);
                this->field=new char[length+1];
                this->length=length;
                strcpy(this->field,field);
            }
            else
            {
                this->field=NULL;
                length=0;
            }
        }
        string(const string& str)
        {
            *this=str.field;
        }
        ~string()
        {
            if(length>0)
                delete[] field;
            length=0;
        }
        char& operator[] (int i) const throw()
        {
            try
            {
                if(i<0 || i>=(int)length)
                    throw indexException();
            }
            catch(indexException& e)
            {
                std::cerr << e.what() << std::endl;
            }
            return field[i];
        }
        string& operator=(const char* field)
        {
            unsigned int length=0;
            if(field!=NULL)
                length=strlen(field);
            else
                field="";
            if(this->length>0)
                delete[] this->field;
            this->field=new char[length+1];
            this->length=length;
            strcpy(this->field,field);
            return *this;
        }
        string& operator= (const string& str)
        {
            if(this!=&str)
                *this=str.field;
            return *this;
        }
        operator char* ()
        {
            return field;
        }
        friend std::ostream& operator<< (std::ostream& out, string& str);
        friend std::istream& operator>> (std::istream& in, string& str);
        public:
        unsigned int length;
        char* field;
    };

    std::ostream& operator<<(std::ostream& out, string& str)
    {
        out << str.field;
        return out;
    }

    std::istream& operator>> (std::istream& in, string& str)
    {
        char temp[string::length_max];
        in >> temp;
        str=temp;
        return in;
    }

}

using namespace util;

int main(int argc, char **argv)
{
    string str("ciao");
    string str2;
    str2=str;
    return 0;
}