Is this warning anything to worry about? I've read that it can cause erratic behaviour?
It's an example I'm trying to compile, could someone explain to me why the author declares the object as a class but then typedef's it to a structure? Is it perfectly normal to do so if the class is POD?
Thanks.
This warning appears when you have a one type declaration that contradicts another (one says "class", the other says "struct"). Given the one definition rule, all declarations except for at most one must be forward declarations. The warning will generally indicate that a forward declaration of a type is wrong and is usually a simple typo and should be fixed. In this case there should be no side effects, but you really should fix it.
There can be, however, some very nasty things happen if you have type name clashes (perhaps caused by using "using namespace" clauses or global namespace pollution). These warnings could be indicating that you are mixing headers from two different libraries and the type names have clashes. Code compiled under these conditions could do some very unexpected things.
My advice - understand why the warning has appeared and fix it. If the warning is in a third party product, insist that they fix it.
Just to bring the comment by MSalters against this post above to the top level. I have had several hard to find linker errors as a result of VC using the 'class' or 'struct' keyword in its mangling of names.
If you don't expect it to be a problem you can be left scratching your head for hours!
Richard Corden is correct - there is a reason MS has this warning. For the MS compiler, decorated (mangled) names include which class-key (struct or class) is used to declare a type. If a function that takes some object as an argument or returns that object is referenced somewhere when the wrong class-key is visible, you will not get a compiler error but the linker will complain because the decorated names differ. The linker error only shows the symbol it's looking for, and it's easy to overlook the class-key mismatch there, so the earlier, more detailed compiler warning is valuable. It's still possible that the two versions don't appear in the same compilation unit, of course, and you will probably be scratching your head for a while if you believe that the only difference is default member visibility.
The difference in mangling conflicts with the C++ standard, which says that forward declarations like struct Foo; and class Foo; are equivalent, and so should use the same mangling.
I discuss this warning in depth in my blog posting "Is C4099 really a sillywarning?". My conclusion is that it is best turned off. :-) Well, at least for me.
One thing I've seen that can cause this warning is trying to #import the .tlb file from a DLL while also having the same DLL as a reference in your project. I just fixed a problem with this by removing the DLL as a reference from within my project.
Although this is considered bad practice, I think there should be no problem mixing class definition and struct declaration, as they are basically the same data type. The main difference is that struct members are by default public, contrary to class members which are private, but otherwise the memory layout is identical.
In c++ the only difference between a class and a struct is that class's member variables, member functions and base classes are private by default, while in a struct they're by default public; so, the fact that the class is POD should not make any difference here.
I would guess that this warning comes from code maintenance (definition updated somewhere but not somewhere else), and fix the code so that the warning disappears (e.g. using class in the typedef).
It looks like there is a mismatch between forward declaration and actual declaration. This warning usually comes when you have declared your forward declaration as struct but you declared a class. Making your forward declaration also a class would solve this warning.
