Update: Microsoft have released a preview patch to Visual Studio 2012 that adds additional support for C++11 features, most notably for variadic templates. I’m pleased to see that Microsoft responded so quickly to customer outcry (not only mine) that Visual Studio’s C++11 support was far too backward. They moved much more quickly than I thought they would. Maybe we’re looking at a new, faster, leaner, humbler Microsoft. (?)
I’m still waiting for non-static data member initializers, but in other respects I now find Visual Studio 2012 much less of a speed bump to adopting modern C+11 features. So the state of C++ portability is already much less sorry than when I posted this article.
I love C++. I love C++11 to pieces. But poor C++11 support in Visual Studio 2010 and 2012 have made porting modern C++ code a misery.
I recently released an iOS game called House of Shadows that features some sophisticated coding including non-trivial AI and advanced lighting and shadows. It’s written entirely in C++ and uses many C++11 features, including lambdas, std::bind, std::shared_ptr, variadic templates, and non-static data member initializers. It compiles beautifully on iOS, Mac, and Linux using either Clang or GCC.
Yet Visual Studio balks. To see why, make a quick comparison of the charts showing whether Clang or Visual Studio support the various C++11 features. Executive summary: Clang’s chart (like GCC’s) is full of Yes’es; Microsoft’s chart is full of No’s. Because my game uses a wide range of C++11 features, Visual Studio—even Visual Studio 2012—won’t begin to compile it.
Herb Sutter—Microsoft’s chief C++ language guru—recently admitted that Microsoft found implementing variadic templates—a C++11 feature that the open-sourced GCC had already possessed for a couple of years—simply too hard. Makes you wonder about brain drain at Microsoft.
Visual Studio 2010 had promising early support for C++0x, as it was then called. They had lambdas. They had std::shared_ptr. They had function objects and std::bind, albeit in MACRO-mad hacked-together form.
But variadic templates are tremendously helpful for building scriptable C++ objects and introspection systems, and Visual Studio 2012 still lacks them two years later. Non-static data member initializers are syntactic candy, but the guarantee that they provide (data members will be initialized across all constructors) offers a powerful antidote to one of the worst and most common programmer mistakes—namely, forgetting to initialize data.
Put simply, the lack of these and other important features in Visual Studio 2012 means that a C++ programmer wishing to write modern C++11 code must either (1) avoid Windows, (2) avoid using features that make up a significant part of C++11′s value, or (3) use an alternative compiler on Windows.
An alternative compiler is possible. Clang is beautiful and is developing with amazing speed, but its Windows support is still spotty at best.
GCC, on the other hand, works well on Windows now. But it needs help from a build system like MinGW/MSYS. Adopting GCC, therefore, means leaving behind the ease and comfort of Visual Studio and entering the hairy world of UNIX ports, Windows command lines, and makefiles. CMake can help take the edge off managing a project’s build process, but this, too, is a new, non-trivial skill to learn.
Perhaps by 2014 or so, Microsoft will have overcome their intellectual challenges and Visual Studio will have implemented C++11. Until then, creating games or other projects that run across all major platforms will involve mucking about in the wild world of GCC, MinGW, and CMake. If you’re hoping to ride the bus we call the C++ renaissance all the way to cross-platform bliss, just keep an eye out for that sodden pothole.
54 Comments
Couldn’t agree more. Thanks for your thoughts.
The most ridiculous aspect of this has to be precisely that Microsoft, at least on the surface, seems to be a lot more pro-C++11 than any of the other major companies. Sure, Apple drives clang development but they would prefer it if you’d develop on Objective-C. Microsoft are the ones who’ve hired some of the biggest names in the C++ world, who’ve put out video after video about the great new features in C++11, and who’ve hosted multiple events about the future of C++. The fact that they can’t get their own compiler to work properly is just plain embarrassing.
I left windows development behind several years ago, and I’m never going to back.
So true. Apple doesn’t try to promote C++, yet succeeds; Microsoft tries hard to promote C++ and fails. Zeitgeist.
I wonder couldn’t you just use clang on Windows to port your game? So far i have only used VS on Windows.
I hear tell that Clang is working on Windows support, but haven’t seen reports of resounding success. GCC—with its MinGW support—is better established.
https://github.com/DevO2012/ClangVSx
What about Intel C++, Portland Group C++ or C++ Builder?
Those are also C++ compiler offerings for Windows.
Good point. Do any of these cover all the platforms I’m interested in, including iOS? Android? I’m kinda thinking not. For broad portability as a game would want—iOS, Android, Windows, Mac, Linux—I think GCC may be the only game in town. Am I wrong?
Linux, Mac OS X and Windows, yes.
Not sure about Android and iOS.
Regarding your complaint.
This is the price to pay for using languages that depend on ANSI/ISO standards.
Not all vendors feel the urge to comply to the standards the same way.
And all of them love to provide their own set of extensions.
Microsoft is not the only one not 100% fully compliant.
You could consider using simpler code generation + simpler c++ paradigms. It isn’t too hard to build a custom Clang frontend that takes the clang AST and generates more source code.
Aside from that, usually people working in games shy away from advanced compiler features precisely because they can make portability a problem. And they tend to be under-optimized making your optimization process a lot longer.
Personally if I were you I would attempt to use Clang to compile my game. At least to compile all but a small portion of it. The only pieces that Clang chokes on are windows headers that have VC-specific isms in them. Other than that, it works just fine.
The option of writing a custom Clang frontend to produce VS-compliant code is intriguing. Thanks for bringing that up.
Sorry, but I think you made a great mistake writing production code using brand-new language features without really checking out their applicability in the real world. You play with new features as they become available, and explore the possibilities, but if they don’t work yet you have to wait for the implementations to get there. I can remember the ages I seemed to be using strstreams because proper stringstreams were so long coming to GCC (those were the bad days of EGCS, etc).
That having been said I avoid Microsoft as much as absolutely possible; despite all the noise I don’t really believe they want C++ to succeed but are still banking on C#, and I absolutely abhor their APIs and attempts to subvert language and POSIX standards (cue max and min macros, 64-bit time_t’s…).
If I had relied on Windows support, it would have been a great mistake. But Windows is gravy for me, and the pothole is a frustration rather than a catastrophe. But it could be a catastrophe for some, and in any case it seems unnecessary.
“Sorry, but I think you made a great mistake writing production code using brand-new language features without really checking out their applicability in the real world”
It’s the only way to get vendor to work on this stuff, doesn’t matter if it’s Apple or MS. HTML5 adoption is being pushed by webies using the new latests features, not waiting for them to mature.
Microsoft’s standards support has always been ‘good enough’. It’s time to demand more for our MSDN licenses.
I concur. I’ve subscribed to Dale’s view through most of my 20-year programming career. I never wanted to use the latest language and library features because I knew that compiler vendors would be slow to implement them. But you know, this is 2012. Technology is supposed to be getting better or something, right…? And as someone else mentioned, C++11 had quite a long and open adoption phase. Much of it started out as part of Boost upwards of 5 years ago. Then it became C++0x, and it was such a much-needed shot in the arm for C++ that even Microsoft jumped on the bandwagon of implementing large parts of it early (in VS 201). So it’s the stall in Microsoft’s support between VS 2010 and VS 2012 that I find frustrating and really unconscionable. The fact that Microsoft admitted (via Herb Sutter) that they tried to implement it and failed because it was too hard makes me feel less anger and more pity, but either way I’m a disappointed developer being driven away from what looks more and more like a dying platform.
Two things have changed the game such that the ‘wait and see’ argument no longer holds true.
1) GCC doesn’t suck any more. Far from it, GCC builds better, faster code than MSVC or nmake and has done for years. THEY implemented the majority of the C++11 standard in a FREE multi-platform compiler so why can’t Micosoft, with all their billions, do the same for their own single platform? They should spend their money on implementing this stuff, instead of over-promising it in keynotes and tech videos.
2) Mobile. I can’t overstate how disruptive mobile (the i-devices and android) have been to Microsoft. These devices need modern tools. Apple knew this which is why LLVM was born. And GCC has been forced to compete to remain relevant. Modern tech and standards compliance is driving these devices – no one can afford to wait 5 years while the tools mature.
Microsoft are in real danger of becoming obsolete, hence the scramble with Metro and Windows phone. THEY didn’t wait for the tech to mature, so why should we, with our MSDN subscriptions, do the same?
The problem of portability between the systems you mention goes far, far beyond just language/compiler implementation differences.
The problems begin with the byzantine, opaque, ancient, and just plain bizarre build systems, and their interaction with compilers and other tools. This is possibly the most important part of a project to understand (especially when porting), and yet in the vast majority of cases the build/project structure goes completely undocumented.
In some cases, it’s laughable. Go to the LLVM site and look at their documentation. There is a bulleted list with two or three items in a row, each warning you in no uncertain terms to “go read the documentation.” Fine, so I’ll go read the documentation. The first thing it tells me is that the documentation it is horribly out of date and possibly inaccurate.
My point is that portable software starts with understanding the purpose of each component, it’s build requirements, and its dependencies. With the tools in use today it is quite frankly impossible to come into a project and understand where to even begin porting it to another operating system. It’s pathetic, actually, that after so many years our industry still uses the worst possible tools.
Have you tried the D language? It’s basically C++ done right.
Are D’s standard libraries/etc mature, stable, and fast yet? The last time anyone I know took a serious look at D was a few years ago; and his verdict was that while the language itself was good the supporting parts needed to make useful applications weren’t in place yet.
Last time I tried D, performance left a lot to be desired. [Trace]-JIT scripting languages, like Google’s V8, LuaJIT, etc. are about on par with it, and D is a statically compiled language.
It does seem like a nice language. But I also feel like it tries to be a bit of everything in the same time. You know, like C++, perl and C#…
Perhaps it’s a time to try it again once more some weekend.
It took MS about 10 years to implement the previous version of the standard, I think they are doing heap better now.
You can try mingw (gcc 4.7) if you are really keen.
We were not even supposed to get range-based for loops, but (according to an MS blog post) luckily Jonathan Caves had a weekend to spare and could push that feature into Visual Studio 2012. I wish he took more weekends off…
As for the alternative (MinGW) — there’s also VisualGDB ($$$) if you want to use GCC (and GDB) with Visual Studio: http://visualgdb.com/tutorials/mingw/
There’s another good other-compiler option you missed:
Last time we ran into a similar problem at work (which was a few years back; MSVC’s C++ support has only gotten substantially better since then, which tells you where it used to be!), we worked around the problem by using Intel’s ICC compiler — now “C++ Code Composer”. It’s about $799 for a license, but that’s cheaper than the high-end MSVC versions, and it integrates pretty seamlessly into Visual Studio. It’s also pretty much the gold standard for high-performance code generation, if that matters to you. Honestly, that’s the route I’d recommend if the slickness of Visual Studio and having tight Windows-API tie-ins matters to you.
Another alternative is a commercial GCC-and-Eclipse-based IDE — search on “Sourcery CodeBench” to find the one my company makes. (CodeBench is mostly meant for a wide variety of Linux embedded systems, but we also happen to build a Windows-target version — in large part because we need something to build our Windows-hosted tools!) Again, not free, but a viable option that removes at least some of the command-line-and-makefile pain from a standalone GCC.
Microsoft may lag behind in compiler features but, at least, their standard library is not left behind. Did you ever try to use std::regex with gcc in C++11 mode?
Sorry, but I’d rather postpone using some brand new features than getting incorrect results from my (standard) library code.
Microsoft’s C++ standard library is not made by Microsoft. They buy it from Dinkumware.
Well that’s not the whole story. They (Stephan Lavavej) works on it as well. I am not precisely sure what arrangement it is and I’m not interested as long as it works.
Indeed. I would only add: if that approach works well for the standard library they should attempt the same for the compiler as well.
In fact they are already using EDG’s C++ parser (one of the best around) as a back-end for IntelliTrace, code-refactoring features, and the static analyzer (http://goo.gl/sIYOO). They should rebuild their compiler on EDG’s to quickly fill the gap about the standard and concentrate more on what really makes the “Microsoft experience” different.
It is not about brain drain.
Microsoft only cares about promoting their own platform against the others, and therefore cross-platfrom programming is against Microsoft’s interests.
Microsoft has despeately tried to lure developers to use only their products, so as that code can only be compiled on Windows, for more than two decades.
All the programming languages Microsoft has invented have this purpose, i.e. to make products exclusive on Windows.
When was the last time you saw a car made by Ford that could have it’s engine replaced by one from GM?
Hey guys, I’m not a MS adict, but isn’t this just sane corporate/commercial sense?
We all know that other company in the IT world that plays this game a lot tougher.
No this kind of thinking only hurts your platform in the long run. Apple used to have their own propriety tech for everything (hardware and software) and it almost killed them.
It’s not a one-horse race any more, especially in mobile which is a game-changer. If MS don’t take standards seriously, they WILL be left behind. Look at what happened with IE6. MS stopped working on it, thinking that they’d destroyed the competition. But the web moved on and FireFox and Chrome FORCED them to take standards seriously.
Apple want you to use Cocoa/Objective-C but they put in the work to make C++ code work seamlessly. MS want you to use C# and didn’t bother implementing even C99, a 16-year old standard. So the best development and innovation happened outside of Windows. Now they’re playing catchup again and it shows.
Honestly, this sounds like an artifact of the fact that you started out on Clang/GCC (which, obviously, therefore meant your code already had to compile successfully for those two compilers). While Clang/GCC are ahead in terms of compiler features, MSVC is ahead in terms of the standard library (and, naturally, the table of C++11 features you linked to was originally put together by the GCC team, and it seems more focused on the compiler features). If you started out on MSVC and got used to having the complete working standard library on hand, including full asynchronous and threading support, you’d be running into a similar level of difficulty having to hack your way around Clang and GCC’s limited and incomplete implementations of C++11′s new standard library. I imagine having to reimplement would be as annoying as having to use MSVC’s macro hackery for simulating variadic templates.
> the wild world of GCC, MinGW, and CMake
wow, you’re a lamer if you can’t handle a little command line. stay with windows, loser.
Try giving Qt Creator a spin. It’s a great multi-platform IDE for C++ development, even if you’re not specifically using Qt. It has CMake support, and supports both MSVC and MinGW compilers on Windows. I’d dare argue that for C++ development it’s even a more comfortable IDE than Visual Studio, so no need for “entering the hairy world of UNIX ports”
Thanks for the recommendation, Arend!
I just found that one, QT. it looks promising. There is both commercial and open source versions.
because MS still busy with their lang : C++ / CX
http://blogs.msdn.com/b/vcblog/archive/2011/10/20/10228473.aspx
so I avoid windows
Better yet, Microsoft should start investing in Clang and bringing it in to Visual Studio.
Even though Microsoft is little behind with C++11 support, I still find VC way more productive environment compared to xCode/Clang/GCC. As a pro iOS developer I use xCode on a daily basis and it’s just pain full of compromises, it’s buggy and especially GDB/LLDB debugging is just a joke compared to the comfort of Visual Studio. Just try to browse a STL container for example. So IMHO a powerful IDE is way more important than the use of the latest C++ features when it comes to overall productivity.
@FipS
Well, IDE and compiler is pretty much independent, as you can use for example several different compilers with the same IDE. It is pointless to compare an IDE to a compiler, they are just offering something completely different. Your comparison is an xCode vs Visual Studio (and maybe gdb vs VS’s debugger) comparison and has nothing to do with the compilers themselves.
Well, I certainly didn’t want to mix compilers and IDEs, but rather tried to express the idea that even the latest compiler gets crippled without decent tools like debuggers and IDEs and all the advanced language features are nice yet very impractical without a possibility to debug them.
Visual Studio is the IE6 of the C++ world.
Another thumbs up for QtCreator here. It’s a better IDE in many ways than MSVC out of the box and can be used with any back-end (cmake, make files, MSVC, GCC, clang etc) and has built-in integration for all major source control systems. You don’t have to use it for Qt.
I’m a window dev (MSVC 10) and mac user and while Microsoft’s terrible C++11 support is painful, they make up of it in other areas. Visual Studio’s debugger is first class while debugging even a simple C program on mac in XCode or gdb is an exercise in frustration.
I also hate XCode with a passion. XCode 1.0 was OK but the latest style-over-substance, crashy releases have been beyond awful (hence my Creator recommendation). Apple also wants you to use Cocoa and Objective-C which I find to be a pretty mediocre toolset, despite all the glitz (ever try debugging KVC bindings? Or using Core Data with real-world data?).
Microsoft also have better build and continuous integration systems, installer tech and code-signing tools. TFS, although a step-backwards in terms of source control, has incredible reporting and collaboration features. Apple, by comparison, seems to assume that every Cocoa developer works in isolation with no need for bug trackers, build servers or test frameworks.
Windows also has better support for the latest OpenGL standards too, which is pretty critical for game devs. Apple have only recently started to take OpenGL seriously.
You should definitely give MINGW/MYSYS a go. It’s nasty but it works. I’m actually working on some C++11 projects on mac right now which I hope to port to Windows some day. We SHOULD be using the very latest features and shouldn’t be held back by Microsoft. We have to pressure them to get these things implemented or take our business elsewhere – MINGW/MYSY is a lot more appealing when you consider MSDN subscription costs.
For the features I’m interested in, (threads, regex) VS2012 has complied with the standard and runs fine. Unfortunately, the standard does not support Perl syntax or thread priority setting (or counting semaphores) which I’ve had to “port” using preprocessor directives and other shenanigans.
I will say that using boost is still a good way to achieve portable C++. Furthermore, many of the boost libraries become the standards of the language.
What can you say! Writing a real program that’s going to be ported using latest C++ features – absolutely crazy – Well nearly as crazy as then going on to moan about it! Most production code writers will keep to the tried and tested and give at least 5 maybe even 10 years to ensure features are both implemented and correct, the latter being even more important!
Yes Microsoft should keep up with the latest standards, but can see their point a lot of C++ 11 features are probably not needed by most users and I suspect there is a very much a 80:20 rule here (that’s 20% of the features used by 80% of users).
A personal view – C++ has become way to complicated and 11 makes it even worse, with a lot of features that really should not be there, the more complicated something becomes, the more ways there are to do the same thing wrongly. Why do I say this? Well I’m one of those poor unfortunates who has fix the broken code of ‘clever’ C++ 11 numpties .
Maybe the one thing I would have wished for in C+ +11 was for it not to compile unless proper comments were added
You’re repeating the wisdom of the ages. Unfortunately the wisdom of the ages is out of date.
1) The last iteration of C++ was in 2003, when waiting 5 or 10 (?!) years for compilers to catch up with the standard was perhaps acceptable. Since then, we’ve seen several major languages come into existence and mature in less time than 5-10 years. If C++ programmers have to wait 5 years for compilers to support their language, how can C++ compete with a language like C# that materialized and matured in less time than that? C++ compilers have to enter the 21st century pace of development. All have—except Microsoft.
2) C++11 does much to bring C++ up to speed with some of the modern innovations that more recent languages have brought (concurrency support, functional programming, sensible function objects and closures) while preserving C++’s performance efficiencies and access to low-level hardware features. Yes, some of these features are new. Yes, some of them take effort to learn. But paradoxically, the new complications added in C++11 actually simplify the language for most users.
If you’re feeling confused by C++11, my advice is:
1) Don’t expect powerful new language features to come free of education cost.
2) Don’t expect to learn all of C++11′s features deeply. Not everyone has to deeply understand move semantics, for example.
3) C++11 is probably easier for C++ newbies to understand than for us old-timers. If you’re upgrading your skill set from a prior C++ version, it’s sometimes best to forget some of what you thought you used to know. Learn C++11 fresh.
Unfortunately in the real hard world out there C++ code goes back a long way , ok not centuries but certainly decades – which is a testimony to the original C++ design and quite often that C++ code has been ‘classed up’/ported from C and that from earlier C styled languages. For newbies they still have to learn the old ways – unless they are lucky enough to live in a very isolated universe, but overall every new features increases complexity.
Improvements in C++ checking and improved IDE tools are what is really required and (without defending them) is what Microsoft tends to do well (2012 GUI apart!).
Don’t think it’s a competition between C++ and C# (or other languages), have to use both and again seeing a lot of the newer c# features causing more problems than they solve often the words ‘because we can’ comes to mind”. Simplest solutions are nearly always the best.
Should add
and those that don’t learn from history are doomed to repeat it!
I am far from some uber hacker, but I have to differ witht he idea that gcc is bad because developers needing to be shielded from make files. Make files pretty much say the same kinds of things that build properties and settings drilldowns in visual studio do.
Makefile project under Eclipse is pretty easy. find a make file on the internet. rename the output to what you want it to do. then, adding libs etc etc is all in one human readable text file. not a thousand different gui drilldowns. just a thought.
John – not alone there!
Great article and absolutely right.
The people here trying to “educate” Jeff into not using C++11 so soon might want to consider what they are actually suggesting.
It seems clear to me Jeff accepted he’d be losing out on the Windows market for a while. But why should he have to lose out at all?
Jeff is clearly a guy who a) wants to keep his skills up to date, and b) wants to use a useful and much improved technology – C++11. A standard that is already ratified.
Not only has he done that, but he’s also c) been creative and entrepreneurial in trying to sell a cool game. He now just wants to take that to a new level and onto other platforms. What’s wrong with that?
He’s doing EXACTLY what he should be doing: staying up to date, being entrpreneurial, and using standards. He’s exactly the person who boosts the economy, and in the right way!
And who’s holding Jeff (and others) back now? Microsoft. a) A company that has dragged its feet on C++ and other standards for a long long time, despite C++ being the technology that actually spawned their own success to start with, and despite b) themselves claiming to be fanatical supporters of it. Even now, Microsoft is still canvassing how much of the C++11 standard to commit to and in what priority.
Whilst I believe they’ll get their in the end, I’m far from confident about that and I don’t c) appreciate the dramas Microsoft create on the way or see a clear end to them, and not having any definite dates of if/when C++11 conformance will come isn’t fun as Jeff is finding. Microsoft’s is behind it’s main competitors, at least in the ways that are important to Jeff and many others and that is hurting both Jeff and Microsoft. Why would/should anyone want to support Microsoft in that? I don’t.
So Jeff’s right, and those people being Microsoft apologists, trying to “educate” Jeff; they should realise they are actually trying to educate him in how to be behind, to accept mediocrity, and to go slow, like Microsoft. Instead, they should be trying to educate Microsoft in how to be fast and how stay up to date and ahead of the curve with C++11, like Jeff is.
So support Jeff and refuse to accept Microsoft’s mediocrity and low/slow standards conformance levels, and see this all for for what it is:
Microsoft are a billion dollar company who are now holding back a lot of entrepreneurial people like Jeff – who we need to support the economy; and Jeff and Microsoft are now both suffering because of Microsoft. That’s not good for anyone.
So let’s fail Microsoft and hail Jeff and stop the “it’s your fault Jeff” talk. It’s not, it’s Microsoft’s fault. Microsoft need to listen more.
Microsoft, stop holding Jeff back! and Go Jeff!!
(Ad paid for by the Go Jeff and Say No to the Zombie Apocalypse campaign.)
I’ve been wondering about these things also. In particular the lack of support for non-static data member initialization is annoying.
It’s encouraging to read your posts about faith and the Bible. The name of my website has the word Ebenezer in it. Ebenezer means so far G-d has helped us.
On reflection, I should add one more thing to my previous comment:
Jeff, I think the title of your article should have been “Microsoft is in a sorry state, but C++11 is great!”. Infact, I think what is really warranted, is a follow up article that redresses that balance of emphasis! How about it?
I say this, because as it stands, whilst definitely correct, your article leaves one feeling that C++ land is far from a happy place. However, the real truth is also there, when you say “I love C++. I love C++11 to pieces”.
That’s the other real story. The follow up article should add that emphasis and explain why? It should also explain more of the amazing things that are happening to C++ because C++11 really is great, and a lot of really good stuff is happening there, even from Microsoft. It’s just Microsoft’s slow progress and especially their darn fool sloppy handling of their customers (see Visual Studio editor issues, windows 8 backlash etc.) which has been the really sorry state, not C++11.
C++11 is in fantastic form, clang and gcc are doing amazingly well and as people have pointed out, competition from others, like the old Borland is only just adding to that. Even Microsoft is getting there, just slowly. We’ll see just how slow, or not, from their upcoming Build conferance in the next few days.
But C++11 success is all around, the soon to be released clang 3.2 compiler in particurlar is just amazing compared to what has gone before, and it really is setting the pace of change. Clang’s careful design structure means that that pace is only going to get faster once it’s momentum kicks in. Clang’s modular design will cause an explosion in cross platform C++ design and development and tools that should address one of your criticisms and understandable reluctance to want to wrestle with make files too much. I think you’ve had comments here about QT creator etc. and cmake, that show that that is already happening and it’s just the start! The fundamentals are all set for this to continue.
So, that other story is horray for C++11. Let’s here it in your follow up article!! Hip hip!
Redmond is (half-assedly) listening?
http://blogs.msdn.com/b/vcblog/archive/2012/11/02/visual-c-c-11-and-the-future-of-c.aspx
3 Trackbacks
[...] Hacker News http://www.jeffwofford.com/?p=1102 kledingmerken This entry was posted in Uncategorized by admin. Bookmark the [...]
[...] The Sorry State of C++ Portability Posted in: C / C# / C++ [...]
[...] yet. In fact, even the newest version of MS Visual Studio does not fully support C++11. See also this rant. So we are in a state of limbo. I don’t want to talk about confusing things that are not even [...]