Major Changes from Visual C++ 5.0 to 6.0
Note Some features mentioned in this topic may not still exist in the current version of Visual C++.
Microsoft Visual C++ version 6.0 provides many new features.
Compiler and Linker
- __assume keyword.
The __assume keyword is a hint to the optimizer that says that the expression passed as the argument is true until the expression is killed. This keyword can be used in conjunction with assert() during debug builds to ensure that the expression used with __assume is always true. Specifying __assume for an expression enables the compiler to perform additional optimizations, the safety of which could not be determined without this hint from the programmer.
- Better inlining control.
For better inline control, there are three new keywords: inline, __inline, and __forceinline. The inline and __inline keywords are hints to the compiler to try to inline the function; the optimizer decides whether inlining should be performed based upon optimization switches (optimizing for size vs. speed) and other heuristics. To provide better control over which functions are inlined, the __forceinline keyword is now supported. This keyword tells the compiler to go beyond the current inlining heuristics and to absolutely inline the function(s) to which it is applied, except in cases in which inlining would be impossible.
- Dependencies now stored in a text file. Exported makefiles now put the file dependencies in a separate, editable text file.
- Dependency (.dep) file generation. This feature provides more control over writing dependency information when you export a makefile.
- Pragma warning.
You can use #pragma warning (push, n) and #pragma warning (pop) to push the current warning state (enabled or disabled) onto a stack and pop it off again. n represents a warning level whose state is to be pushed. You can use this feature when writing headers to ensure that a programmer does not compile the header with a warning level higher than you intend.
- Run-time error checks.
The Visual C++ compiler can embed certain run-time checks in code to detect common errors. The /GZ compiler option enables these checks. Run-time checks can only be used in debug (/Od) builds. There are new checks for autoinitialization of local variables, function pointer call stack validation, and call stack validation.
- Delay Load Imports.
- The new /DELAYLOAD (Delay Load Import) linker option allows you to delay loading of DLLs until they are required to continue execution. This removes the requirement that you add code to specifically load a library prior to it being used. It also resolves the problem of making sure you have that code in all of the places that it would be necessary.
- New options for linker, DUMPBIN, and EDITBIN. Visual C++ 6.0 contains new options that expose more of the operating system functionality and support more platforms.
- Revised import library format. The import library format has been revised to reduce the size of library files, including the library files that you create. Most files are 50% to 75% smaller.
- Edit and Continue.
Edit and Continue allows you to incorporate common, simple edits during a debugging session without having to quit the session, rebuild, and restart the debugger. Changes are recompiled and applied to the executing application in memory.
- GUIDs decoded for display. Types based on GUIDS (including IIDs, CLSIDs, and REFIIDs) are displayed by name (if found in the registry), or failing that, in the normal GUID hex form.
- Improved disassembler output (undecorated symbols). The disassembly window and callstack window now undecorate C++ names where they did not before, such as when displaying system callstacks from Windows NT DBG files. You now see the C++ name with a proper argument list.
- Improved vtable and function pointer display. Pointers to functions and vtable entries are now displayed symbolically wherever possible, including parameters. Previously, these items were displayed as just hex addresses in Visual C++ 5.0.
- MASM hex syntax supported. The debugger now supports MASM-format hex numbers in expressions, such as 1234h. This can make operations involving the Disassembly window easier, such as viewing DataTips.
- New formatting symbols. The following are new symbols for Watch variables: hr, st, mq, wm, and wc.
- Component manager.
The Component Manager lets you store and share objects between software tools and custom reusable components. The Component Manager was developed in order to deliver improved support for reuse, dependency tracking, tool interoperability, data resource management, and team development.
- HTML Help Workshop.
HTML Help 1.1 enables you to provide HTML-based context-sensitive help that can be integrated with the Web. HTML Help is an alternative to Windows Help. For authoring, you use HTML Help Workshop rather than Help Compiler Workshop.
- Test Container updated.
Test Container is now more robust and provides additional features, such as support for OCX 96 features, including windowless controls, inactive controls, flicker-free activation, and quick activation. Test Container also provides VBScript support for writing test scripts, selective enable/disable of container features to simulate different container environments, and selective logging of events, property changes, and property edit requests.
- Visual Studio Analyzer.
Visual Studio Analyzer server-side components provide information about the Microsoft components, such as COM, ADO, and MTS, running on a particular machine. You can use this information with the Visual Studio Analyzer client to understand what a distributed application is doing, what the performance of a distributed application is, and where problems are occurring in a distributed application.
Editors and Projects
- Automatic statement completion.
The Text editor now features Automatic Statement Completion, also known as IntelliSense. IntelliSense options put the MFC, Win32, and ATL libraries virtually at your fingertips, displaying class members, function prototypes, identifier declarations, and code comments at the cursor or mouse location while you're editing your code. Simple keystrokes insert code elements directly into the source code file in which you're working. IntelliSense also completes recognized words for you, saving you from having to repetitively type lengthy class or member names.
- Quick macro recording.
Similar to keystroke recording and playback, this feature is a menu shortcut to the more extensive macro recording. You can record any action supported by the object model into a temporary VBScript macro by selecting Record Quick Macro from the Tools menu.
- Resource editor support for Internet Explorer 4.0 controls. The Resource editor has support for IE4 controls. You can use this support with or without the MFC wrapper classes.
- Command-line builds. The new MSDEV command allows you to build a Visual C++ project from the command line without first exporting a makefile (projname.mak) and running the NMAKE utility.
- Dynamic parsing (dynamic updating of ClassWizard). When you type a new class, variable, or member function, Visual C++ updates ClassWizard and WizardBar to display the new items, without requiring you to save changes first.
- "GoTo Dialog Editor" from ClassWizard and WizardBar. You can now jump directly to the Dialog editor from a class that implements the dialog box.
- MIDL Options page: Property Pages dialog box. There is new support for .idl files; you no longer have to use a custom build step.
- "New Form" command.
This command generates a form and is available from the Insert menu and from ClassWizard and WizardBar. This command is essentially a ClassWizard for CFormView, CDialog, and the database view classes. Unlike the ClassWizard, the New Form command also creates a dialog box with all the appropriate options.
- New HTML resource type. You can insert an HTML resource by choosing Resource from the Insert menu.
- Support for environment variables in the IDE. There is now support for using environment variables in the IDE.
Automation Object Model
- New Automation properties and methods. Shell scripting (Automation) has been enhanced in Visual C++ 6.0 to give you more flexibility in creating and building projects.
- Script Debugger. If you have Visual Studio installed, the Script Debugger enables you to debug shell automation scripts, as well as HTML pages that contain Visual Basic Scripting Edition (VBScript) or JScript. If your shell script contains an error, a dialog box automatically appears and prompts you to run the Script Debugger.
- AppWizard enhancements.
In Visual C++ 6.0, there are more options when you are using MFC AppWizard to create an executable. AppWizard now supports single-document interface or multiple-document interface applications that are not based on the Document/View architecture. This enables streamlined use of MFC for applications that aren't document based. AppWizard also supports toolbars that work like Internet Explorer rebar controls, Active document containment, Windows Explorer–style applications, and Web browser–style applications (by using CHtmlView).
- AppWizard support for OLE DB. You can now select an OLE DB data source from AppWizard, in addition to DAO or ODBC. This wizard uses the MFC support for the OLE DB templates. (This feature is not the same as ATL OLE DB Provider support).
- Cluster resource type wizard.
The Cluster Resource Type Wizard generates two projects for implementing a Microsoft Cluster Server (MSCS) resource type. Writing a custom resource type allows an application to be more closely managed and monitored by MSCS. A Resource DLL project produces a DLL that is loaded by an MSCS resource monitor on a cluster node to manage and monitor the application. A Cluster Administrator Extension DLL project produces a COM in-proc server DLL for providing a user interface for managing resources of this new type.
- Custom build rules for Help files. To generate Help files, AppWizard now uses custom build rules instead of MakeHelp.bat, so each source file is only rebuilt when necessary. MakeHelp.bat is still provided for backward compatibility.
- "Delete Member Function" Command in WizardBar and ClassWizard.
You can now delete a member function by using the Delete command on the WizardBar menu or by using the ClassWizard shortcut menu. The Delete command removes the function declaration from the header (.h) file and removes any associated message map entry. It also removes entries from the SINK map, which is an ATL map used in handling events. Finally, it comments out the function definition, if one exists. The function body remains selected so that you can easily delete it.
- Internet Explorer 4.0 control support in ClassWizard.
ClassWizard now supports Add Message Handler and Add Variable for the four controls that are supported in the resource editor. You can also add new classes whose base class is one of the four new MFC IE4 control classes.
- New project types. Custom AppWizards now support Utility projects, Makefile projects, Static library, Console application, and ActiveX control projects.
- Wizards for non-MFC project types.
There are now wizards for all non-MFC project types, such as Win32 Application, Console Application, Dynamic-Link Library, or Static Library. Instead of just creating a completely empty, generic project, these AppWizards enable you to specify options; they produce boilerplate code for non-MFC apps.
OLE DB Templates and Database Support
- Database access with OLE DB. Using OLE DB Consumer templates, you can access databases from your program. You can also view data with the new COleDBRecord view MFC class.
- OLE DB Consumer and Provider templates.
OLE DB is the newest data-access methodology from Microsoft. It merges the power of COM with data-access technology. Visual C++ now abstracts the COM interfaces by providing OLE DB Templates. These templates make OLE DB much easier to use while providing excellent performance and using native C data types for OLE DB programming. The new COleDBRecordview class is an optional MFC class that wraps the OLE DB Consumer and Provider templates. This class incorporates the OLE DB templates into MFC.
- Schema rowset classes for metadata. If you need to get metadata from a data source, you can use the OLE DB consumer template schema rowset classes. These classes encapsulate many of the details that are required for retrieving metadata.
- ADO Data-Bound Dialog Wizard. The ADO Data-Bound Dialog Wizard is a Visual C++ component that guides you through the process of creating an MFC data-bound dialog box with ActiveX Data Objects (ADO). Help for the wizard is available via the More Info button in the Component and Controls Gallery.
- Data-bound controls for ADO and OLE DB. To enable you to use ADO rather than RDO for data access, there is a new datasource control called the ADO Data Control (ADODC). This allows you to access any data exposed via an OLE DB data provider. Thus, you are not restricted to accessing data from SQL-based RDBMSs.
- Oracle support in the data tools.
This version of the Microsoft Visual Database Tools gives you more power and flexibility when working with databases. The Database Designer and Query Designer work with the latest versions of SQL Server, Oracle, and Microsoft Access databases. With this release, Oracle database support has been enhanced in the Visual Database Tools. Now you can use the visual design tools to manage your Oracle databases.
- Active document containment.
Active document containment provides a single frame in which to work with documents, instead of requiring you to create and use multiple application frames for each document type. It differs from basic OLE technology in that OLE works with embedded objects within a compound document in which only a single piece of content can be active. With Active document containment, you activate an entire document, that is, an entire application, including associated menus and toolbars, within the context of a single frame. AppWizard automates the MFC coding required for Active document containment. Active document containment is implemented by using the new class COleDocObjectItem.
- Dynamic HTML control with CHtmlView.
A new MFC class, CHtmlView, enables you to host dynamic HTML within your MFC applications. CHtmlView allows your application's view to display HTML pages that contain Dynamic HTML just as a Web browser would display them. CHtmlView provides many browser features, including a history list, favorites, and security features.
- Internet Explorer 4.0 common controls.
MFC provides support for the latest Internet Explorer 4.0 common controls in classes such as CComboBoxEx, CDateTimeCtrl, CIPAddressCtrl, and CMonthCalCtrl. You can access these controls from the Controls toolbar in the Dialog editor. In addition to these new control classes, new functionality was added to most of the existing MFC common control classes. These modifications include flat toolbars, image list support for several control types (such as header, toolbar, and status bar controls), and new attributes. These new properties are also supported in the Dialog editor controls.
- Various MFC classes and globals are new or updated.
- MFC OLE DB class added. The new COleDBRecordView class is an optional MFC class to wrap the OLE DB Consumer and Provider templates. This class incorporates the OLE DB templates into MFC.
Windows NT 4.0 Option Pack
The Windows NT Option Pack delivers a set of new application services that enable the development of the next generation of distributed network applications for both Windows NT Server 4.0 and also takes advantage of the next major release.
Application services included are:
- Certificate server
- FrontPage Server Extensions
- Index server
- Internet connection services for RAS
- Internet Information Services (IIS)
- Mail and news services
- Microsoft Data Access Components
- Microsoft Management Console (MMC)
- Microsoft Message Queue Server (MSMQ)
- Microsoft Transaction Server (MTS)
- Site server
- SNA server
- Windows Scripting host