Example of Visual C++ nonconformant code?

Question

What are some examples of code that are not standards compliant when using visual C++? Something that is allowed to compile under visual C++ but nothing else.

Answer 1

You can find all the Microsoft language extensions here; you may also want to have a look to the areas of the language where VC++ is not compliant to the standard.

One that I thought was standard (I noticed it when I enabled the /Za switch) is the "magic l-value cast":

char *p;
(( int * ) p )++; 

Answer 2

Some version of Visual C++ accept to pass non-const reference to temporary object. Something like that :

void DoSomething(std::string& str);

void NonConformantFunction()
{
    DoSomething("Temporary std::string created here");
}

Answer 3

"Something that is allowed to compile under visual C++ but nothing else"

and

"code that are not standards compliant"

do not describe exactly the same thing. A compiler may be fully standard compliant while having extensions that are unique to that compiler, while a non-compliance is something explicitly prohibited by the standard. There is also a number of "undefined" or "implementation defined" parts of the ISO standard that might prevent portability without being non-compliant. Moreover many supported extensions are supported by other compilers so are examples of one of your constraints but not the other.

Now that said, the major extension of VC++ that would render its code non-portable are all of the C++/CLI extensions, and therefore also the .NET Framework class library which requires them.

Answer 4

There is an official page on microsoft.com saying what are the parts where VC++ is not compatible with the standard. However a different issue is where it is compatible by default with the standard. For example the default scope for for variables is still wrong in VC++2010.

Answer 5

I don't have a VC compiler to test this, but if I recall correctly this will compile fine in Visual Studio regardless of the commented errors:

template <typename T>
struct base {
   void foo() {
      T::type v = 0;    // standard requires typename here
      std::cout << v << std::endl;
   }
};
template <typename T>
struct derived : base<T>
{
   void bar() {
      foo();            // foo() is not dependent this should not compile   
   }
};
struct test {
   typedef int type;
};
int main() {
   derived<test> o;
   o.bar();
}

Answer 6

One thing MSVC++ allows you to do is to explicitly specialize templates within a class. Eg.

class X {
public:
    template <typename T> void doStuff(T value);

    template <> void doStuff<bool>(bool value) {
        // ..do something specific to bool.
    }
};

This compiles fine in VS, but attempting to compile in GCC will give an error telling you that you have an explicit specialization in the non-namespace scope. The solution to which is to simply drag out the specialization.

class X {
public:
    template <typename T> void doStuff(T value);
};

template <> void X::doStuff<bool>(bool value) {
    // ..do something specific to bool.
}

GCC is correct on this issue though, according to the spec, which states that all explicit specializations should be in the namespace scope.

Possibly worth noting that in the latter case, you must define your specialization within the header file, and not the implementation file like you would normally expect. Both the compilers mentioned are non compliant with the standard which would solve this problem, which is the export keyword declared on the specialization within an implementation file. This feature is not implemented by most compilers though, and there are plans to remove it from the next version of the specification.