A visual history of Visual C++ (2017)(malsmith.net) |
A visual history of Visual C++ (2017)(malsmith.net) |
visual assist x worked better.
But with a focus more on C++ features.
I started with Visual C++ 1.0. There were no templates.
Visual C++ 2.0 had templates.
There was by Visual C++ 3.0. They went to 4.0 to sync the MFC (Microsoft Foundation Classes) versions.
IIRC, you could use a bit of STL with 4.0
Visual C++ 5.0 was mainly optimizer differences.
Visual C++ 6.0 was actually pretty good. However it lacked partial template specialization. I was a Boost author at the time and lots of Boost code had specific workarounds for Visual C++ 6.
Visual C++ 2002 also had no partial template specialization.
Visual C++ 2003 was the first version with partial template specialization and that could compile all of Boost.
Visual C++ 2005 and 2008 did not have much changes.
Visual C++ 2010 tried to get back to 6 in the IDE (there was a deliberate marketing as such). It also had some C++11 features. But no variadic templates.
Visual C++ 2012 had no variadic templates.
Visual C++ 2013 was the first with variadic templates.
Nowadays, Visual C++’is doing much better tracking the C++ standard and often has compiler and library features before clang and GCC.
C++/CLI could have been it (after the Managed C++ reboot), but its integration with Windows Forms has always been clunky, nevermind WPF.
Then C++/CX could have been it, but then there was this rebellion replacing it with C++/WinRT, nowadays in maintenance, only getting bug fixes, being good enough for WinUI 2.0 and WinAppSDK low level stuff and that is about it.
I was big into Borland from their early MS-DOS compilers, all the way into 1999.
Embarcadero might not be Borland, but still manages to put out great GUI RAD tooling, whereas Microsoft lost sight of what means a great developer experience for native applications.
I don't actually know in which release that transition happened. But since there's a screenshot of each version in the article, presumably that transition is visually documented...
Visual C++ v4.2b generating an assignment operator which invoked the destructor of a returned object before assigning it to the lval.
That was fun to figure out. :-/
class A { int a }
int main(...)
Hard reboot left it doa. With today’s tools it could have been recovered but I lacked gparted and a kali thumb stick to bring it back. So thankful for Linux.
I had dabbled in both QuickBASIC and Quick C on MS-DOS building very simple text games and such. When Visual Basic for Windows came out, I was ten years old. It was a revelation because it let me build something that felt like real software. Place controls on a canvas and start wiring them up with event handlers — so easy!
When Visual C++ was announced, I figured it would be the next step up. I had already learned some simple C, so probably it’s just like Visual Basic but you use an improved C for your event handlers? I harangued my dad to “borrow” a copy from his work, and sat down with the Hello World… Which was an incomprehensible 300 lines of Win32 message handlers and Hungarian notation variable names. Nothing “Visual” about it.
It did give me an appreciation for just how much work the Visual Basic team had done to hide the ugly guts of GUI programming.
- -
[1] I had a very easy childhood by most standards.
It was a revelation for me on the power of OOD/OOP in practice and a defining educational moment on Software Design, Frameworks and Libraries.
Lets also add MFC was born as Application Framework, and dumbed down because hardcore Win16/Win32 C folks at Microsoft were against its original design.
The multiple confusing version numbers are caused by each software component (e.g. "cl.exe" vs "msbuild.exe" vs IDE "devenv.exe" vs platform toolkit SDK) evolving separately over decades. (https://en.wikipedia.org/wiki/Microsoft_Visual_C%2B%2B#Inter...)
E.g. Today's "cl.exe" at version 19.x goes all the way back to 1983 with Microsoft C 1.0 for MS-DOS. Just a text-based command line compiler with no C++, no GUI, no "Studio", etc. 43 years of the core compiler going from 1.x to 19.x. The Visual IDE component of VC++ version 17.x has a different version history going back to 1993 with 1.0. Microsoft C# also has different version numbers of C# language version vs .NET version vs CLR version, etc.
It's analogous to Linux world of different tools with different version numbers. GCC is 15.x, glibc is 2.4, make is 4.4, etc. If you include a "visual GUI IDE" like Jetbrains CLion, that's yet another different version (252.x) that doesn't match any of the others.
Microsoft could hypothetically "synchronize/unify" all version numbers for all disparate products to be a single number ... akin to Apple using version "26" to synchronize Xcode with iOS, etc by introducing large numerical gaps like v18 --> v26. That's probably not going to happen. Likewise, different groups at GNU are not going to agree to synchronize all version numbers such that next release will be GCC 20.0, glibc 20.0, and make 20.0.
To this day, I experience a very brief spasm of regret when I just exit Visual Studio without closing the solution first.
This transition was not great for Visual Basic developers either since their language was transitioned from generating native code (VB6) to becoming dependent upon the .NET Framework (VB.NET), supported secondarily to C#.
Quite awkward for what is such a key technology on Windows.
n.b. I worked on the Visual Studio Core team, which maintained devenv.exe, among other things, from 2003-2007'ish.
It’s also a product of the segmentation of the developer tools in Microsoft. The Windows team was responsible for the compiler rather than the Developer Tools team.
Don't remember when DevTools was re-orged out from under Windows, but I'm pretty sure it was by '95, and well before VC++ 6.
MFC was no dumbed down application framework but a higher level OO abstraction on top of Win16/32 SDK. It is one of the largest and most successful application frameworks in the industry. You had to learn its own concepts and architecture which were somewhat complex and had a steep learning curve but the payoff was excellent. I remember going through all the MFC Tech Notes from MSDN and poring over the "MFC Internals" book to get insight into its design and techniques. You learnt how to modulate OOD/OOP principles in service of practical implementations. Two good examples are; 1) Making all member variables of framework classes "public" (!) in order to allow the developer to drop back to Win16/32 SDK as needed and not be constrained by the application framework 2) The technique of MESSAGE_MAPS to avoid vtable memory blowup but still provide virtual function like functionality.
When i see kids on HN badmouth OOD/OOP and specifically Inheritance for code reuse via application frameworks for skeleton apps, i just shake my head and control the urge to smack them up the side of the head :-) They have been so spoiled with all the powerful application frameworks/libraries available today they simply have no idea of the design effort it took to come up with these frameworks/libraries but take everything for granted.
> One quirk of MFC is the use of "Afx" as the prefix for many functions, macros and the standard precompiled header name "stdafx.h". During early development, what became MFC was called "Application Framework Extensions" and abbreviated "Afx". The name Microsoft Foundation Classes (MFC) was adopted too late in the release cycle to change these reference
MFC was a dumbed down version of Application Framework Extensions, which was more in line with the higher level approach done by OWL and CSet++.
It might have seen brilliant for those coming from raw C and Petzold never having seen what Borland and IBM were doing, but other folks like myself have knew better.
Unfortunately Borland's mismanagement eventually gave the crown of Windows C++ frameworks to Microsoft, and IBM also wasn't much better with OS/2.
And to this day there is nothing visual in Visual C++, to the level of C++ Builder, and FireMonkey framework.
While ironically ATL, WRL and WinRT are all worse in developer tooling than what MFC had to offer.
In 2025 starting a new Visual Studio project, it is the grandpa MFC that wins out in Visual Wizards, dialogue editors and COM integration tools.
Agree that many folks around HN and similar sites lack the background of having been actually there, moving up from MS-DOS, getting to carry around Petzold's book, learning the new way of doing UIs, and why things became as they are.
Borland's OWL predated MFC (not sure by how many years) and hence held the lead before MFC came along. Once the latter become available there was no longer any compelling reason to stick with Borland and of course their management failed to counter the threat and lost it all.
I myself started with Borland's tools on MS-DOS, moved to Windows with straight Win16/32 SDK programming and then moved to VC++/MFC before moving away from Microsoft platforms to Unix/Linux in the late 90's. It was a highly educational and career-forming experience.
> The system maintains the z-order in a single list. It adds windows to the z-order based on whether they are topmost windows, top-level windows, or child windows.
https://learn.microsoft.com/en-us/windows/win32/winmsg/windo...
The WS_CLIPSIBLINGS window style is also explicitly for controlling cross-clipping of child windows during painting:
> Clips child windows relative to each other; that is, when a particular child window receives a WM_PAINT message, the WS_CLIPSIBLINGS style clips all other overlapping child windows out of the region of the child window to be updated.
https://learn.microsoft.com/en-us/windows/win32/winmsg/windo...
Furthermore, group boxes and tab controls require overlapping child windows, because they are designed for the controls that visually appear within them to be sibling controls that are raised in Z-order. This is why the dialog editor's current behavior is broken, because the editor's picking behavior is opposite the drawing behavior and USER32's hit test order.
So you totally missed / skipped Borland's VCL[1], right?
That would explain your comments: It's the only way I can see how one could come to think that "Microsoft had the lead" in Windows IDEs at... Well, ever.
___
[1]: Written in Delphi and of course used there, but also used in C++ Builder.
So VC++/MFC was already established by the time VCL/C++Builder came along. Also it was aimed mostly at the Delphi/Object Pascal crowd whereas most Win16/32 C SDK crowd found the transition to VC++ more natural.
Thanks!