Gamedev forum software crapped its pants again, so can not use any formatting. Did my best to make it readable.

------------------------

frob: "4201 is valid unless you told the compiler to use c++11."

VC++ does not have such a specific switch - all that it is capable of supporting is enabled by default. And i use a lot of c++11 features. One might say that vc++ is not really c11 - but that is not an useful distinction as it tries to be everywhere else.

frob: "The invalid automatic functions are correct, these are not things the compiler can automatically generate."

_Nor does it need to_. The warning is a very low priority bug in the compiler: http://connect.microsoft.com/VisualStudio/feedback/details/488660/improper-issuance-of-c4610

Even so, it is still an useless warning as the language does not allow improper use anyway (ie. more than it normally does) - there is nothing worth warning about.

And yes, one should generally avoid such structures. Exceptions excepted (funny: commented out the warning to see where i use them => apparently i do not use them at all anymore [except a few of the assignment ones - adding "=delete" assignments]).

frob: "4100 is a fun one that requires an understanding of the language history."

Interesting. I did not know that backstory. Thanks.

frob: "The 4310 case is VERY valid in this case. int16(0x8000) is an overflow"

Exactly. Which is why it is tagged "UNHELPFUL" instead of "BOGUS" or "USELESS". Unhelpful is a fairly subjective tag (*).

I use, in every language, hex-notation to signify bit-patterns. Ie. "int16(0x8000)" should be interpreted as bit-pattern 0x8000 in int16 storage (_ie. platform dependently interpreted as some 16 bit integer_). Obviously, C does not interpret it that way and never will - not a problem here.

The warning is very rare.

I have only a few of them from various macro-driven tests. Platform specific integer conversion ... the only place where anyone would write stuff like "int16(0x8000)". Hm, i should move the pragma there and undo it after the test section - much more sane. Thanks.

(*) I copy pasted thous few example lines out - leaving out some less likely useful ones (and commented out unused ones) and a few comments. One of them probably bited here. Pragma reminder-comment in split with "//": left of it is about the warning - to the right is for use-case reminders of how one might get the warning etc. So, BOGUS for "int16(0x8000)" does not mean the warning is bogus! - it signifies that it is UNHELPFUL as it is BOGUS for the use-case (the bit pattern fits nicely).

Perhaps i should have left out all the UNHELPFUL tagged ones here due of their high subjectivity.

#pragma warning(disable : 4127) // (UNHELPFUL) conditional expression is constant // this is actually almost always desired

It is? Isn't the conditional expression rather pointless if it is constant or am I missing something?

while(RUNNING == gameState)
{
  // Run Game Code
}

Oh, missed a post.

#pragma warning(disable : 4127) // (UNHELPFUL) conditional expression is constant // this is actually almost always desired

It is? Isn't the conditional expression rather pointless if it is constant or am I missing something?

Typical direct example: "while(true) { ... }". But it usually comes indirectly from macros and templates (ie. stuff that is not, in its final, form written by the programmer).

Ie. the warning is valid, but unfortunately tends to flag code that is perfectly fine - which is just too annoying of a problem when one treats warnings as errors that could be temporarily ignored. Hence: UNHELPFUL.

while(RUNNING == gameState)
{
  // Run Game Code
}

That's not a constant conditional expression, unless gameState is const, which I assume it is not...

But it usually comes indirectly from macros and templates (ie. stuff that is not, in its final, form written by the programmer).
Ie. the warning is valid, but unfortunately tends to flag code that is perfectly fine - which is just too annoying of a problem when one treats warnings as errors that could be temporarily ignored. Hence: UNHELPFUL.

Ah of course, got it.

I personally prefer to just pay attention to the compiler warning me about a possible wrong assignment in a conditional. I do still occasionally make this typo but the compiler has been warning be about it for at least the last ten years.

Me too.

I'm sure this habit was invented before compilers were as good as they are today with warnings and such.