Using a pointer to add an object to an array

[365X92yv]

That's pretty much it. I need to use a class with a private data member pointer, and use that pointer to create an array and then use that array to put the object in it, then take care of deleting the pointer.

[Moschops]

use that pointer to create an array and then use that array to put the object in it, then take care of deleting the pointer.

use that pointer to create an array

pointer = new int[1000];

that array to put the object in it

pointer[0] = someIntegerObject;

then take care of deleting the pointer.

delete [] pointer; // Deallocate memory, lose forever what was just stored in the array This bit seems a bit odd - why throw it all away immediately after creating it?

[365X92yv]

What I'm trying to simulate is an online shopping cart. I'd like to create my item objects and use dynamic memory to add these items to an on demand created array. Thats probably where I'm lost. I can't keep the data I put in the pointer created array.

[Moschops]

If you're not forced to use new and delete, just use a vector. It takes care of its own memory, expanding as needed.

// Make a vector of objects, named contentsOfShoppingCart
vector<objects> contentsOfShoppingCart;

contentsOfShoppingCart.push_back(someObject); // add someObject to end of vector
contentsOfShoppingCart.push_back(someOtherObject); // add someOtherObject to end of vector 

[365X92yv]

I "need" to use new and delete.

[Moschops]

It's pretty simple. Create some class containing a pointer to whatever kind of object can be held in the shoppginCart.

On creation (i.e. in a constructor) use new to make that pointer point to an array.

Each time you add to the cart, put the object into the next element of the array.

Give the shoppingCart class a destructor that uses delete on the pointer.

For extra points, keep track of how many objects are in the cart and expand the size of the array if needed.

Do as much of this as you can, and then come back with your code and question.

[365X92yv]

Right now, I've got my container class creating a private array of size 100. What I would want to do is change that from a static declaration in my class into a pointer....


So, from:

Item _Items[100];

Into...

Item *Items;

???


And then in my constructor I have it do this..

Container::Container(int s)
{
	cout << "Int Constructor" << endl;
	size = s;
	Items = new Item[size];
	position = size - 1;
}

[365X92yv]

I use my pointer to create an array the size of one for adding a single object to it. But when I try to add my item object to the item array, it doesn't keep the data saved to the object array.

[365X92yv]

My code so far.

Container.h

#include "item.h"

class Container
{
private:
	Item *Items;
	int size, position;
public:
	Container();
	Container(int);
	~Container();
	void Add(Item &);
	void Delete();
	int Size();
	void Show();
	void Remove(int pos);

};

Container.cpp
#include <iostream>
#include <string>
#include "Container.h"

Container::Container()
{
	cout << "Default Constructor" << endl;
	size = 0;
	position = 0;
}

Container::Container(int s)
{
	cout << "Int Constructor" << endl;
	size = s;
	Items = new Item[size];
	position = size - 1;
}

Container::~Container()
{
	cout << "Destructor" << endl;
	delete []Items;
}

void Container::Add(Item &item)
{
	Item Items = item;
}

void Container::Delete() { delete Items; }

int Container::Size() {	return size; }

void Container::Show()
{
	for(int i=0;i<size;i++)
	{
		cout << Items[i].toString() << endl;
	}
	//prints out all items on the list.
}

void Container::Remove(int pos)
{
//remove item at pos, then move items up one slot
	for(int i=0;i<size;i++)
	{
		if(i == pos)
		{
			Items[ i ] = Items [ i + 1];
			for(i = pos;i< size;i++)
			{
				Items[ i ] = Items[ i + 1 ];
			}
			size--;
		}		
	}
}

[Moschops]

void Container::Add(Item &item)
{
	Item Items = item;
}

So you pass this function the item you want to store, and it copies it to a brand new local variable, which is promply destroyed when the function ends.

I suggest that instead of copying it to a brand new local variable, you instead store it in the array you made, perhaps like this:

void Container::Add(Item &item)
{
	Items[ nextEmptySlot ] = item;
}

[365X92yv]

So would I be able to use the same pointer to point to a new array with a new size to make room for new objects I need to add?

[Moschops]

Yes. Don't forget to copy all the old things into the new array, and to delete that original array.

[Taran Gadal]

If you use the same pointer to point to a new array with a new size, you lose the array you were originally pointing at. You'll need to copy everything from the original array you're pointing to, to a temporary array, say, Temp[size]...then you'll have to delete the memory your pointer was pointing at, and then use the new operator, and copy all the information from Temp[] to your new block of data.

You could try creating another pointer to your original block of data, but the moment you use your original pointer to delete it, it's essentially the same as deleting your old pointer as well. That's why the idea of using some sort of temporary spot is a better bet. Lemme know how it goes!

[365X92yv]

Can I use the destructor to do that? Or would I need a seperate method to do the deleting?

[Taran Gadal]

I would recommend a different method, maybe just an inline method or something. Destructors have special meaning to the compiler, calling the destructor causes your destructor function to execute once, but, after the closing brace (}) of your destructor, the compiler will do a few special things. For one, destructors are built for the sole purpose of destroying an object, and de-allocating it from memory. I believe once the destructor is called, it's like giving the compiler the "OK" to store new information at the address the object was allocated at.

So to sum up, NO, do not explicitly call the destructor. Definitely not from within another local function. The only time it is safe to explicitly call a destructor is from an outside function, and is usually only ever necessary when your object has been mapped into some absolute address you're aware of.

dynamically allocated objects, for example, when you use the delete keyword on them, the compiler will call the destructor of that object.

EDIT:

Also, if your class derives any other classes, a call to the destructor will also trigger calls to all the base classes' destructors as well.

[365X92yv]

So what I want to do is use my pointer to point at a new array of objects, with the bigger size, then copy from the smaller array to the larger one, with a for loop, and then delete the memory used for the smaller array?


Err..... would I need to copy my original array into a temporary local array?

[Moschops]

Err..... would I need to copy my original array into a temporary local array?

No. Copy it into the new array.

[365X92yv]

I'm having a hard time creating a second array using the same pointer. Its not liking my syntax and I'm not sure what I'm doing wrong.

I thought it was pointer = new classType[ variable size ];

Ex.

#include <iostream>
#include <string>
#include "Container.h"

Container::Container()
{
	cout << "Default Constructor" << endl;
	size = 0;
	position = 0;
}

Container::Container(int s)
{
	cout << "Int Constructor" << endl;
	size = s;
	Items = new Item[size];
	position = 0;
}

Container::~Container()
{
	cout << "Destructor" << endl;
	delete []Items;
}

void Container::Add(Item &item)
{
	if(position == size)
	{
		cout << "SUP" << endl;
		Container(size + 1);
		Copy();
		// call a method to create a new array, new size, and then copy
		// then take it and delete the old one.
	}
	else
	{
		Items[position] = item;
		position++;
	}
}

void Container::Copy()
{
	for(int i=0;i<size;i++)
		cout << "STUFF" << endl;
		//new array copy, from slot 0 until the whole array has been copied
}

int Container::Size() {	return size; }

void Container::Show()
{
	for(int i=0;i<size;i++)
	{
		cout << Items[i].toString() << endl;
	}
	//prints out all items on the list.
}

void Container::Remove(int pos)
{
//remove item at pos, then move items up one slot
	for(int i=0;i<size;i++)
	{
		if(i == pos)
		{
			Items[ i ] = Items [ i + 1];
			for(i = pos;i< size;i++)
			{
				Items[ i ] = Items[ i + 1 ];
			}
			size--;
		}		
	}
}

[Moschops]

How about something like this

void Container::expandStorage ()
{
  Item* newArray = new Item[size*2]; // Create new array, twice the size
  memcpy (newArray, Items, size * sizeof(Item));  // Copy old into new
   size = size * 2;
  delete Items;  // delete old array
  Items = newArray; // set Items pointer to point to the new array
}

[365X92yv]

So memcpy would be a faster way to copy from one array to another?


EDIT :

Also, when I'm in my IDE and I use the debugger, usually you need to delete that memory you used in the heap, does that memory, if not deleted, take up actual memory space and cause actual problems outside your IDE?