Using shared_ptr instead of raw pointers

Hi,

I want to used shared_ptr here instead of raw pointers. How can the following code be changed to use shared_ptr or shared_array?

Code:

#define  MAX_COLS 1000

MyClass
{
     private:
                int	**m_value;
                ...
		...
     public:
        Myclass()
	{
		m_value = new int *[MAX_COLS];	
		
		for(int count = 0; count < MAX_COLS; count++ )
		{
			m_value[count] = NULL;
		}	
	}

        ~MyClass();
	{
		if(m_value)
		{
			for(int i = 0; i < MAX_COLS ; i++)
			{
				delete [](m_value[i]);
			}
			delete []m_value;
			m_value = NULL;
		}
		
	}

	
	void insert(index, int* data);
	{
		//do all the preliminary checks like bounds, null check
		m_value[index] = data;
		
	}
	

	void processData()
	{
		for(int count = 0; count < MAX_COLS; count++  )
		{
			int *data  = m_value[count];
			//Write the data to a file or do something with it
		}
		
	}
	
        //other members
};

std::tr1::shared_ptr is probably inappropriate here since you appear to be dealing with some kind of container of objects rather than a pointer to a single object.

boost::shared_array might be appropriate since it looks like the insert member function does not make a copy. On the other hand, is this lack of a copy intentional, or is it an oversight? If it is intentional, perhaps a std::vector<boost::shared_array<int> > would be appropriate (or you could use a std::tr1::array<boost::shared_array<int>, MAX_COLS> instead). If not, perhaps a std::vector<std::vector<int> > would be better. Of course, you should change the insert member function's signature accordingly.

If the indices can have many gaps in the sequence, perhaps a std::map would be better than a std::vector to store the shared_array or vector.

You seem to be using the old "C" way of 2D arrays. Are you use a std::vector< std::vector<int> > won't do?
Consider also using const T instead of #define.

Thanks for ideas. The insert without copy is intentional.

When do you use shared_ptr<> and when shared_array<>.

what does these signify?

boost::shared_ptr<int> smrtptr (new int[256]);
and
boost::shared_array<int> smrtarray (new int[256]);

shared_ptr deletes with delete and shared_array deletes with delete[].

shared_array also implements operator [] for element access, and I would assume has less overhead than an array of shared_ptr's.