Funny C Rules (And Low-Level Languages in general)

[Spike]

stdcall dates back to when there were multiple languages and compilers for native code... microsoft used it in the hope that it would give people less reasons to hate windows, and its been plaguing c/c++ users ever since.
I think windows has some special magic so that message handlers can use either convention without exploding, because if people can muck it up, then they will do so, and have done so. This doesn't mean that you should do so.

stdcall is nice because if you passed the wrong number of arguments, your whole program explodes...
using cdecl means you probably won't notice for years.
stdcall's symbol decorations that add @4 or whatever depending on the number of arguments help when you have dodgy function protypes all over the place. personally I use fastcall as a default calling convention in debug builds so stuff like this is blatent, its like stdcall but with the added illusion of extra speed!

win64 has only one calling convention. it'll ignore any stdcall/cdecl/fastcall markup (it might still warn though, for compat with 32bit code if its later compiled for that instead).
and 64bit linux/unix predates that with a different one (except for wine, anyway).

[Baker]

Interesting. So multiple calling conventions is a "Windows things".

[frag.machine]

Indeed.

http://blogs.msdn.com/b/oldnewthing/arc ... 48616.aspx

To be fair, according to one of the commenters in the link above, _fastcall was created by Borland to use with Delphi.

[jitspoe]

[Baker]

If you are going to use #pragma message (I use it a lot), don't use the word "warning" in the text. #pragma message is awesome to remind you to revisit code because it prints when you compile.

#pragma message ("If we aren't reading from server every frame, this stuff will break ...") // A note I stuck in make myself aware of a weakness in client/server separation

The compiler may see the word "warning" and interpret it as being a compile warning:
Don't do: #pragma message ("This causes a warning")

yourbin.exe 0 error(s), 1 warning(s)

[mankrip]

[Baker]

[revelator]

while malloc and free are usable in C++ i guess new and delete would be a better choice
allthough if you need something like _aligned_malloc/_aligned_free you would probably have to write it yourself.
atleast gcc does not accept malloc without typecasts in C, looks like void * is not treated as a valid pointer so gcc barfs.

[mankrip]

Anyway, since my last post I made all malloc typecasts explicit already.

I do plan on moving on to C++ in the future, so that may help.

[mh]

I think the C-like subset of C++ is just a flat-out better language than C. It's worthwhile just renaming your .c files to .cpp and getting a clean compile. You'll be surprised at the amount of nastiness that lurks behind valid C code. Having features like stronger type-safety and explicit forward declarations will just make you a better programmer (your code will be cleaner too!); you don't have to descend to the ninth circle of template insanity in order to write C++ code.

There are some other C++ features such as function overloading and optional parameters/default parameter values that make code nicer too. A lot of C fans who dismiss C++ seem to do so based on some of the more extreme examples of C++ code imaginable, and apparently without even having much knowledge of the language, assuming that you must write classes for everything and use templates wherever possible (I'm thinking of something like Linus Torvalds' rant about C++ here, where he really showed how ignorant he is of what he was talking about more than anything else; unfortunately people will read that crap and believe it). None of that is true; the C-like subset is quite lean and simple.

As a bonus you can now link to and use both C and C++ libraries without any contortions.

As for compile times: just use precompiled headers. Even with C you can get the compile time for something like FitzQuake down from 10+ seconds to under 1 second.

[mankrip]

Getting a bit off-topic here, what confuses me the most in C++ are namespaces. Classes and such are fine, I've learned about them during the Java classes in college.

And a Java feature that I love is to be able to access a public variable of an object directly from the return of a statement that returns that object. My Java skills are rusted, but an example would be somewhat like
{
(guy = new player (teleport.getOrigin()) ).setName ("Quake Guy Jr.");
}
instead of this:
{
guy = new player (teleport.getOrigin());
guy.setName ("Quake Guy Jr.");
}
I don't remember specific examples of code where I used this, but it simplified my code design a lot by allowing me to use nameless objects.

[revelator]

namespaces are a bit like C structs grouping together a bunch of functions
a simple way to explain it when in C you do something like thispointer->thisfunction to access say typedef struct thispointer { char *thisfunction; }
a namespace works much the same way but it looks a little different see -> thispointer::thisfunction. One big difference is that you can do namespace thispointer { char *thisfunction = wtf; }
while a C struct does not allow that as far as i know.

[Baker]

Here's a fun one.

float bob = 494;

What is type of !!bob ?

Is it still a float? Or did it turn into an int? I'm guessing it's an int because it is a logical operation result like ( == )

[revelator]

could probably be a float if bob = 494.0f; hehe but i get your meaning
actually 494.0f would be a double so whoops

[ericw]