Thread: Question about the Basics of Memory Leakage

Code:

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

class Transportation
{
public:

	double dCarEngineSize;
	int iMotorcycleCCs;
	int iSemiNumberofAxels;
};

int main(int argc, char* argv[])
{
	Transportation& vehicleInfo =  *(new Transportation);
	vehicleInfo.dCarEngineSize = 3.1;
	vehicleInfo.iMotorcycleCCs = 750;
	vehicleInfo.iSemiNumberofAxels = 6;

	cout <<	vehicleInfo.dCarEngineSize << endl <<
			vehicleInfo.iMotorcycleCCs << endl <<
			vehicleInfo.iSemiNumberofAxels << endl;
	delete &vehicleInfo;
	return 0;
}

It compiles, great, but is it doing what I want it to?

I want to delete the object from the heap, so it doesn't cause a leak, is this correct? If not, what am I doing wrong?

I think Shamino's code is better than Ancient Dragon's. What's the point of using void*?

Shamino, normally, you just use the pointer and operator-> instead of using a reference to the value. When most people see a reference they don't think that it will need to be deleted, so doing it might cause confusion. Your code will work, but is there a reason you don't just use the pointer.

Code:

int main(int argc, char* argv[])
{
	Transportation* vehicleInfo =  new Transportation;
	vehicleInfo->dCarEngineSize = 3.1;
	vehicleInfo->iMotorcycleCCs = 750;
	vehicleInfo->iSemiNumberofAxels = 6;

	cout <<	vehicleInfo->dCarEngineSize << endl <<
			vehicleInfo->iMotorcycleCCs << endl <<
			vehicleInfo->iSemiNumberofAxels << endl;
	delete vehicleInfo;
	return 0;
}

BTW, <iostream.h> is old and non-standard C++ and won't compile on many modern compilers. Consider changing it to <iostream>.

Originally Posted by Daved

I think Shamino's code is better than Ancient Dragon's. What's the point of using void*?

The point? none -- I agree with you about using the pointer operation. I was NOT recommending the code I posted, just showing how it could be done. Otherwise, it pretty much sucks cannel water.

yah, the book was telling me that there was a way I could make it so I could use the . operator instead of the -> thingy... I guess theres really no difference, except it might cause confusion...

So what I'm doing in my code, is making a new * when I should be making a &, and I shuold be deleting a * when I'm deleting a &



, I think thats what you're saying ancientdragon

or to make it exception safe, and easier to use...

Code:

#include <memory>
int main(int argc, char* argv[])
{
	std::auto_ptr<Transportation> vehicleInfo(new Transportation);
	vehicleInfo->dCarEngineSize = 3.1;
	vehicleInfo->iMotorcycleCCs = 750;
	vehicleInfo->iSemiNumberofAxels = 6;

	cout <<	vehicleInfo->dCarEngineSize << endl <<
			vehicleInfo->iMotorcycleCCs << endl <<
			vehicleInfo->iSemiNumberofAxels << endl;
	return 0;
}

auto_ptr will delete the object for you when it goes out of scope.

>> So what I'm doing in my code, is making a new * when I should be making a &, and I shuold be deleting a * when I'm deleting a &

Your code is fine, just potentially confusing like you said. If for whatever reason you want to use the . operator instead of the -> operator, your code is the correct way to do it.

right right, so all except for the -> thingy part, its correct? and I COULD use the auto_ptr thingy to automatically delete it...

does this work in every case?

I'm not sure what you mean by "all except for the -> thingy part". Your code is 100% correct (except for the <iostream.h> part). It uses new to allocate space for a Transportation instance and it deletes that instance later by using operator& to get the address.

You can use the auto_ptr thing so that you don't have to remember to delete the memory yourself. There are rules about when you can use auto_ptr, so it doesn't work in every case.

BTW, I assumed you were doing this for learning purposes, but the normal way to do this is of course without using new or pointers at all.

Code:

int main(int argc, char* argv[])
{
	Transportation vehicleInfo;
	vehicleInfo.dCarEngineSize = 3.1;
	vehicleInfo.iMotorcycleCCs = 750;
	vehicleInfo.iSemiNumberofAxels = 6;

	cout <<	vehicleInfo.dCarEngineSize << endl <<
			vehicleInfo.iMotorcycleCCs << endl <<
			vehicleInfo.iSemiNumberofAxels << endl;
	return 0;
}

Yes I'm just learning how to send things directly to the heap instead of the stack, most programs have to do this, so i'm assuming its something I need to know...

Can you list a few reasons why I need to do this insead of just using the stack all the time?

If the size of what you are allocating is very large, then you want to do it on the heap instead of the stack, since the size of the stack is much smaller than the heap.

If the object you are creating needs to remain "alive" for longer than the current block of code, then you need to use the heap, since local variables on the stack are cleaned up automatically when they go out of scope. A common case of this is a function (Factory) that returns a base class pointer to a new derived instance so that it can be used polymorphically.

Smart pointers (like auto_ptr) can almost always be used to hold the dyamically allocated pointer and delete it appropriately. However, they are a bit more advanced tool that you probably don't want to worry about just yet. If you don't use smart pointers, IMO the next best way to keep track of heap allocated objects is with a simple pointer like my first example showed.

4706 ints, which are probably 4 bytes on your machine, is a little less than total 19000 bytes. That is not that much, and it can stay on the stack.