problem with overloader bracker operator

Hey guys ive created an overload bracket operator. For some reason I had to create an initialize function to set the array value. After it is set, the overloaded operator works fine. I would like to fix the operator so I didnt have to call an addation function before I use it. Here is my code.

Code:

---

#ifndef ASSOCARRAY_H
#define ASSOCARRAY_H

#include <iostream>
#include <cstdlib>
#include <string>

using namespace std;

template < class T >

class AssocArray
{
       
        struct data                                                                                       
        {
                T value;
                string index;
               
        };

        public :
                AssocArray(int size);
                AssocArray(const AssocArray &object);
                ~AssocArray();
               
                T &operator[](const string &cell);
                void initialize(const string &cell, T input);

        private:
                data *ptr;
                int total;
                int arraySize;

};

/* ===================================== */

template< class T >                                                                                       

/* default AssocArray constructot */
AssocArray < T > ::AssocArray(int inSize)
{       
        total = 0;
        arraySize = inSize;
        ptr = new data[arraySize];       
}



template< class T >                                                                                        /* AssocArray copy constructor */
AssocArray < T > ::AssocArray(const AssocArray &object)
{

        total = object.total;
        arraySize = object.arraySize;
        ptr = new data[arraySize];
        for (int count = 0 ; count < arraySize ; count++)
                *(ptr + count) = *(object.ptr + count);
}



template< class T >                                                                                        /* AssocArray destructor */
AssocArray < T > ::~AssocArray()
{       
}

template< class T>                                                                                        /* initialize values */
void AssocArray < T > ::initialize(const string &cell, T input)
{
        ptr[total].index = cell;
        ptr[total].value = input;
        total++;
}


template< class T >                                                                                        /* Overloaded bracket operator */
T &AssocArray < T > ::operator[](const string &cell)
{
        if (cell == "")
        {

                cout<<"no room"<<endl;

                exit(1);
        }
        else
        {
                for (int count = 0 ; count < arraySize ; count++)
                {
                        if (ptr[count].index == cell)
                        return (ptr[count].value);
                }
               
                exit(1);
        }

}

#endif

---

The implamentation file is empty because all the function are template related.

My main looks like this....

Code:

---

#include <iostream>
#include "AssocArray.h"


using namespace std;
int main(int argc, char *argv[])
{
       
        /* Create three different data type */
       
        typedef AssocArray< int > intclass;
       

        intclass age(2);
       
        age.initialize("chris",21);
       

        age["chris"]=25;
               
        cout << age["chris"] << endl;
       
       

        return 0;
}

---

If anyone see where I can change it so I can get rid of initialize function let me know.
Thanks a lot.

The subscript operator should return a reference to the element specified by the key, and if that element does not exist, it should be inserted, which means you need to grow your array to make room for it.

Well,l im working on an exercise using exception handling. So I want it to be a fixed size so I can cause it to have a run-time error.

Then throw an error when your class is asked to insert another object when it's full.

I understand that, but how to I prevent having to initialize each element.

What I was trying to say before is that the work of making room for an element should be done in the operator[] function or in a private function called by it. Come to think of it, why not call your initialization function inside operator[]?

Cause then you would reinitialize it everytime you used that operator.

You need only initialize when that key isn't yet an element in the associative array.

Regardless of where I call the initialize function it will still get an error in the function. I need throw it in the operator function.