I think yes.

But if you're writing this for anything other than academic purposes, I suggest you switch to STL.

Then why do you use Allegro? Why don't you write your own code for loading bitmaps, blitting them, playing samples, setting gfx mode, getting mouse and keyboard input, etc? If you did, you would know exactly how it worked.

Let me tell you why. Because someone already wrote that for you and it works. It has been tried and tested many times and there's no reason to reinvent the wheel.

Ok Miran you're right, but I'm talking about basic data structure. First it's good to know how it works, second it's better to write your own which will be suit you, third STL produces very large exe files. But again I'm not saying STL s wrong. But when you need simple linked list, then I don't see any need to include STL.

I have done some experiments on basic hello world code. It is an iostream part of STL that causes big exe files.

hello world                             19 KB
+ my owned linked list                  54 KB
+ std::iostream                        572 KB
+ std::list                             56 KB
+ std::vector                           61 KB

Well, I still need your advice on deleting void pointer. Dev C++ warning make me unsure that deleting void* will free allocated memory properly.

Could you share the code, please? I did a simple hello world test myself and with simple std::iostream and std::list file size was ~25k, 5k when stripped, 4.5k when UPX'ed. Perhaps my test was too simple though.

Also, this was done under Linux with GCC 3.4.4. In theory I think there shouldn't be major difference between OS'es because the compiler is the same.

Though I noticed that with custom list you saved a whole two kB's
Is that enough to justify creating your own classes that you have trouble with? With STL list you wouldn't even have to make topics like this one.

As for deleting void*, I don't know. I haven't used them in my C++ projects because I haven't seen the need

Bare main()                        -> 6KB
std::list with all function called -> 27 KB

Difference                         -> 21 KB

Delete should knows size (since in most cases it uses delete which takes void * anyway) but since type is unknown it doesn't know which destructor to call. Remember, object's destructor must be called when object is destroyed.

With that code you gave I got this:

#g++ linklist.cpp ; ls -l a.out
-rwxr-xr-x  1 hoho users 8187 Dec 27 14:16 a.out

#cp a.out a1.out
#upx -9 a1.out
#ls -l a1.out
-rwxr-xr-x  1 hoho users 4830 Dec 27 14:17 a1.out

#cp a.out a2.out
#strip a2.out
#ls -l a2.out
-rwxr-xr-x  1 hoho users 4420 Dec 27 14:17 a2.out

Perhaps mingw really does create bigger executeables under windows.

With a STL list test I got this result:

#g++ linklist.cpp; ls -l a.out
-rwxr-xr-x  1 hoho users 19057 Dec 27 14:24 a.out

#cp a.out a1.out ; upx -9 a1.out ; ls -l a1.out
-rwxr-xr-x  1 hoho users 8575 Dec 27 14:25 a1.out

#cp a.out a2.out ; strip a2.out ; ls -l a2.out
-rwxr-xr-x  1 hoho users 11060 Dec 27 14:25 a2.out

#upx -9 a2.out
ls -l a2.out
-rwxr-xr-x  1 hoho users 6084 Dec 27 14:25 a2.out

Not too bad. I guess the size difference might come from if programs under Linux are dynamically linked to libstdc++. You might want to try what UPX and strip can do for the executeables under Windows. I wouldn't be surprised if the 465kB gets reduced to <50kiB

There is nothing bad about writing your own classes but you might want to write them similar to STL by using templates so you wouldn't have such problems with void pointers.

This indicates a design error. You should be deleting the object in the same context as you're creating it. Otherwise memory leaks will be the least of your problems.

Quote:
Firstly, I don't think you can call delete on a void *. Delete needs to know the size of the allocated structure

Sorry - poor wording on my part. I think we're getting at the same thing - when you delete an object, internally, delete derives the size of the allocation that's being freed since it knows the struct size of the class that's being deleted. But it still calls free() with a given byte size. And as William points out, void is not a type, so you can't call its destructor.

Which brings me back to the problem: one shouldn't use a void pointer type in the first place. It's a skanky way to short-circuit a problem, and fraught with potential gotchas. Seriously: look at template classes. This is exactly what they're for:

Apologies in advance for the sparse example - I haven't run the compiler on this, so my syntax might be off somewhere, but you get the idea. The point is that you simply call delete on the node object now, since the compiler knows what T is when you instantiate the class - you're solid.

There are some good uses to void*. In my linked list class, I use void* to whatever data is to be stored in the list. You just have to cast it whenever you want to read/use the data.

However, deleting a void* is a no-no in my books. I like to think of the void* as if pointing to something with my finger. I wouldn't want to delete my finger (ouch), I want to delete the something that it is pointing at.

Typically, what happens is that C++ stores the exact size of the allocated memory block one word "before" the allocated memory block. For example:

complex* c = new complex(1.0, -1.0); // say complex is a struct with two 4-byte floats
// address  0xF0    0xF1    0xF2
// value    2       1.0f    -1.0f
// c == 0xF1
// size of allocated memory block (2 words) stored at 0xF0

char* str = new char[16];
strcpy(str, "Hello world!!!");
// address  0xF3    0xF4    0xF5    0xF6    0xF7
// value    4       Hell    o wo    rld!    !!\0[?]
// str == 0xF4
// size of allocated memory block (4 words) stored at 0xF3

Then when delete is called, it looks one memory space to the "left" of the allocated block to know how much to delete. This is how delete knows how much memory to free when given an array, even though you don't have to write delete[16] str;for example.

Thus, requiring the type pointed to by a void* pointer is a matter of type safety re: which destructor to call, and has nothing to do with how much memory is actually being deleted.

It's worked for me so far. Maybe I'm thinking of template in more of a general definition and you have a more technical explanation. Care to share an example of what you mean?

I don't doubt it. A lot of people tell me I'm "reinventing the wheel," but of course I am. I know there's a lot of things out there (like map editors, graphics libraries, etc.). It's not that I'm trying to make a better one or "reinvent" it, but rather understand it and learn from it.