Microsoft Corporation
July 1996
Introduction
Reuse Becomes Reality
The Right Technology, Right Now
Efficient Tools for Fast Development
Conclusion
Glossary
Note This reviewers' guide covers the Microsoft® Visual C++® development system versions 4.0, 4.1, and 4.2. When a feature is specific to one of the point releases it is called out as such.
Code reuse has been a long-sought goal for C++. For C++ programmers, reuse usually means the technique of deriving new C++ classes from a pre-existing base class. Microsoft® Visual C++® version 1.0 offered this basic technique, along with wizards and base classes provided in Microsoft Foundation Classes (MFC), to make class derivation easy. The success of Visual C++ 1.0 has made it the most popular reuse mechanism today for C++ programmers.
This development system is a powerful mechanism for developers to reuse and extend what is provided in MFC. However, Microsoft customers want to apply the same techniques of reuse to their own codes and projects, and go well beyond what is possible in today's development environments. This trend has led Microsoft to a broader definition of the term "reuse."
"Reuse" also addresses the bigger challenges of "programming in the large" and reusing existing code; existing C++ classes; existing user-interface elements; existing prebuilt components; and, probably most importantly, the knowledge, programming techniques, and general experience of other developers. In a December 1994 survey conducted by Market Decision Inc., developers rated reuse of code as the most influential factor in selecting a C++ development system.
Microsoft Visual C++ version 4.0 provides real-world tools to help developers take advantage of the power of code reuse. Additionally, the Developer Studio, a truly integrated environment, combines industrial-strength power with new ways of working with C++ code. Microsoft continues its commitment to supporting the latest in Windows® operating system-based technology, including the Windows 95 operating system.
Visual C++ 4.0 is the right development system for building great applications. From mission-critical client-server solutions to high-performance multimedia applications, Microsoft Visual C++ gives the developers power to get the job done.
Today, most code reuse comes from reusable classes, such as MFC. As hundreds of thousands of professional developers using MFC will attest, reusing the more than 120,000 lines of code in MFC can save weeks or months of work. Visual C++ 4.0 provides a new approach to reuse, making it easy for developers to reuse from other people on their teams or in their companies.
Reusing components of recent projects or building up a personal library of reusable components is now possible for the developer working alone (Figure 1). The ability to reuse components from a shared library also has clear advantages for those developers working as part of a team.
Figure 1. Visual C++ 4.0 reuse architecture
In addition to the Component Gallery, which lets you add components to an existing project, you can use the AppWizard to create projects from "scratch." Introduced in Visual C++ 1.0, the AppWizard has greatly improved the ease with which people write C++ code. Custom AppWizards (Figure 2) allow you to build your own boilerplate applications so you never again have to start from scratch.
Figure 2. Creating a custom AppWizard
Visual C++ 4.0 includes AppWizards that let you build MFC applications, dynamic-link libraries (DLLs) or ActiveX™ controls. There's even an AppWizard wizard, which helps you build your own custom AppWizards.
In the forefront, Visual C++ 4.0 has the innovative Component Gallery (Figure 3), an extensible, general-purpose location for developers to store their reusable components. It covers many kinds of reuse components such as reusable C++ classes, ActiveX controls, and advanced feature components that can perform sophisticated modifications of a project's source code.
Figure 3. Choosing prebuilt components in the Component Gallery
In the Component Gallery, you can browse through the components available on your system; many come built into Visual C++, and there are others from third parties. After selecting a component from the Gallery, you only need to click the Insert button to place it into your current project.
This is more than just copying a class or a file into your project. Because of the intelligence of the Component Gallery, applying a reusable component from the Gallery not only will copy the necessary parts and information to your project, it will adjust your project, change settings, edit source code, add resources—whatever is necessary to add the desired component or feature to your project.
With a click of the mouse, you can store C++ classes in the Component Gallery and use them as reusable components in almost any MFC application, including legacy code. Component Gallery also provides the ability to add features provided by third parties. These components can provide more extensive modifications to projects and are not limited to adding classes.
The Component Gallery also stores and manages ActiveX controls. When inserting an ActiveX control into your project, the Component Gallery automatically creates a C++ class in which to encapsulate it. This lets you manipulate the ActiveX control easily from your code. Best of all, you can use ActiveX controls without an advanced understanding of OLE. Visual C++ 4.0 also includes built-in support for creating ActiveX controls, which are automatically registered in the Component Gallery for later use.
Since the first version of MFC was released, people have written their own classes to extend it. MFC is designed to be extended in an object-oriented fashion through the inheritance and overriding of class members. By doing this, you can customize MFC to perform specific functions, then reuse the code in other projects. Many developers have already begun sharing their MFC extensions, some of which add significant functionality. For example, the book "Animation Techniques in Win32®" provides a rich set of animation classes to MFC by extending the existing drawing functions.
The code reuse features of Visual C++ 4.0 have opened up new opportunities for third-party components that can help make development more efficient. This allows you to be more productive by giving you the choice of components that you can buy instead of building them yourself. More than 70 companies are planning to provide new complementary tools and add-in products by the time Visual C++ 4.0 is available in retail stores.
More than 50 companies are planning to provide OLE components that work with the Visual C++ development system. Companies such as Template Graphics Software and Crisis-in-Perspective will be providing new 3-D tools and AppWizards. Crystal Software is planning to provide new MFC add-on class libraries with the new version of Crystal Reports, as well as an ActiveX control and an AppWizard to make support of database reporting even easier. These are a few examples of companies that will be providing components and libraries.
Template Graphics' OpenInventor MFC extension class library shipped in Visual C++ 4.1 and 4.2.
As a developer, you need a development system that gives your applications the best performance and the greatest capabilities. Microsoft Visual C++ 4.0 delivers with the latest technology, giving you direct access to the powerful new features of Windows 95 and Windows NT® 4.0.
If you're planning to host your development on the Windows 95 operating system, Visual C++ 4.0 is the development system of choice. Over the last two years, Visual C++ has established its leadership position in development tools for Win32-based development with the 32-bit Visual C++ 1.1 and Visual C++ 2.x. These investments have paid off with proven 32-bit technology and support for the latest Windows 95 features.
The Visual C++ development environment, Developer Studio, meets the requirements of the Windows 95 compatibility logo, ensuring that it complies with strict user-interface standards and that it supports Windows 95. Visual C++ 4.0, runs on the Windows NT 3.51 Workstation and Server, and now, Windows NT 4.0.
Visual C++ not only runs on Windows 95, it also allows you to fully exploit the exciting new features of this mainstream operating system. Users are already demanding support for new Windows 95 features, 32-bit performance, and long file names. Visual C++ makes it easy to add these to new and existing code.
Recently, Visual C++ users have begun demanding support for Internet technologies such as Internet Information Server (IIS) and Sweeper. Visual C++ 4.1 delivered MFC classes and an AppWizard for the server side ActiveX technology, Internet Server Application Programming Interface (ISAPI). Visual C++ 4.2 now delivers MFC support for the client side ActiveX technology, Sweeper. In version 4.2, you'll find support for:
Visual C++ 4.0 offers full support for the common controls premiering in the Windows 95 and Windows NT operating systems as well as special support for the Windows 95 Explorer shell. All of the major new Windows 95-based common controls (Figure 4) are fully supported by Visual C++ in the environment; you can access them through MFC and the Win32 (API).
Figure 4. Control Palette with Windows 95 and ActiveX controls
In addition, Visual C++ supports multithreading, one of the most exciting features of Windows 95. Multithreading, the ability to run multiple parts of a program simultaneously, can provide better application performance and improved system throughput and sometimes can even simplify development of concurrent operations. MFC provides classes that encapsulate the mechanics of multithreading, including synchronization objects essential to coordinating thread actions.
With Windows 95, OLE support is more important than ever, and MFC continues its tradition of powerful yet flexible support for connections to other applications, component-based development, and the future. MFC (and the wizards) provide more than 40,000 lines of support classes for OLE containers and servers, ActiveX controls, OLE automation, and more. Everything you need to build ActiveX controls (and applications that use them) is also built into MFC.
New with Visual C++ 4.2 is support for apartment-model threading, a model that is essential to creating OLE objects in multithreaded containers.
Microsoft has vast experience building Win32-based applications. Visual C++ 4.0 is the company's third-generation Win32-targeted compiler; it has a strong heritage that has built thousands of Win32-based applications; it is even used to build the Windows 95 and Windows NT operating systems themselves.
With this experience, Microsoft has been able to add new optimizations for 32-bit development to take advantage of the larger registers, flat memory model, and new instruction set. Optimizations for the Intel Pentium are built in. This world-class optimization technology can make your 32-bit code really sizzle. Microsoft built Visual C++ 4.0 with Visual C++ 4.0, so it had to be good.
New to Visual C++ 4.1 is support for Intel's advanced MMX opcodes. More information is available about this technology at Intel's Web Site, http://www.intel.com/pc-supp/multimed/MMX/.
For many developers, meeting the requirements for the Windows 95 logo is very important. Not only does the logo help distinguish your application on a store shelf, it is also important to a growing number of corporate developers, many of whom want software that offers a familiar user interface, easy installation (and uninstallation), and compatibility with Windows NT.
Visual C++ documentation provides you with step-by-step information on meeting the Windows 95 logo requirements, through making the familiar Scribble sample logo-compliant. The Visual C++ 4.0 AppWizard helps you create a logo-compliant application right away. By choosing the right options, you can have many of the required features built for you. Additional MFC sample code is provided to get you started, including MFC source code to WordPad, the Windows 95 rich-text document editor.
MFC 4.0 automatically detects whether it is running with the new Windows 95 shell or with the original Windows 3.1 shell, and adjusts accordingly. For example, ToolTips, which are built into the new user interface, are emulated on Windows NT and the Win32s® API. This means that in many cases you don't need to create special-case code to have your application run in different environments.
The InstallShield software development kit from InstallShield Corp. is included with Visual C++ 4.0 to simplify the implementation of setup routines for your software. InstallShield makes it easy for you to check executable file and DLL versions, register icons and OLE objects, and even uninstall software. These capabilities are essential for large-scale projects as well as for obtaining a Windows 95 compliance logo.
MFC has a strong tradition of bringing the latest Windows technologies to you. From OLE to Windows Sockets, MFC has delivered powerful, upwardly compatible C++ classes for new areas of Windows. This tradition continues with MFC 4.0 support for Windows 95, ActiveX controls, and data access object (DAO) databases.
By using MFC, you can add these capabilities to your applications in an easy, object-oriented way. Starting with MFC 3.0, you could add ToolTips to your application by adding only three lines of code. Now, with MFC 4.0, a similar amount of code will enable ActiveX controls in your application. With Visual C++ 4.0, the Component Gallery will add these features and more to your applications. And with MFC 4.0, using the new Windows 95 common controls is as easy as using the original Windows controls.
But what if your application is still 16-bit? MFC helps you out there, too. By encapsulating your WndProc, dispatching messages, and converting parameter sizes, MFC makes it easy for you to migrate your 16-bit application to Windows 95 or Windows NT. In many cases, you can just convert your makefile (Developer Studio can do this for your internal makefiles automatically) and rebuild. If you need to make changes in your project, the MFC documentation has a chapter to help you. If you're just moving to MFC, we include the MFC migration kit to get you started.
For more information on the newest version of MFC, see the Microsoft Class Library version 4.0 Technical White Paper.
High-speed data access is essential to most corporate mission-critical applications and Visual C++ 4.0 delivers. Visual C++ is flexible enough to provide two means of data access, each suited to a different need. Best of all, they're built into MFC 4.0 and supported by Component Gallery and the wizards.
First, there's open database connectivity (ODBC), a standard API that allows you to work with data from many databases, including Microsoft SQL Server, Microsoft Visual FoxPro™, Microsoft Access, ORACLE, and dBASE (Figure 5). These and other drivers are included with Visual C++, and more are available from third parties.
One of the strengths of ODBC is that it allows you to write a single executable that can access data from all of these sources without your having to learn a new set of APIs for each database. Even better, you don't have to rewrite, recompile, and retest for each data source.
In the past, some have criticized ODBC 1.x for slow performance under certain conditions. With 32-bit ODBC 2.5, you can see dramatic performance increases, sometimes increasing speed by up to 1,000 percent.
Figure 5. Database architecture
New in Visual C++ 4.0 is support for DAO. The new DAO classes for MFC enable you to access the high-performance Microsoft Jet database engine directly using the Microsoft Foundation Class Library. DAO uses the same direct data-access engine in Microsoft Access for Windows 95 and the Visual Basic® programming system 4.0 to work with a local database or one shared over a network. Since Visual C++ uses the same data engine as the Visual Basic 4.0 programming system and Microsoft Access for Windows 95, the data formats are identical, so sharing data is easy.
The overall DAO architecture of MFC 4.0 is very similar to the database support of Visual Basic and Microsoft Access as well as the ODBC classes from previous versions of MFC, so developers familiar with these environments will feel right at home. As with the ODBC database classes, you can open and manipulate databases and record sets, and display the data in a form view (Figure 5). With DAO, you can also set up and use work spaces, create and manipulate tables and queries, and use and create indexes for those tables through the use of the SQL Data Definition Language.
The DAO classes encapsulate an OLE component object model (COM) interface to the Jet database engine, so you don't have to write the SQL code yourself unless you want to do so. You can also access ODBC data sources using the DAO classes through attached tables.
Figure 6. Setting database options
The AppWizard will connect to an existing database and generate the necessary support code to take advantage of the appropriate MFC database classes. ClassWizard works with the database classes to connect up database logic or even to connect dialog items to data items.
The pace of innovation in the software industry continues to accelerate. Technology that recently seemed distant, such as OLE support, is now a necessity in the marketplace. Many users of Visual C++ have found a way to keep up with the latest advances: the Visual C++ subscription.
In the past year, subscribers to Visual C++ have received the latest releases sent directly to their door. Some of the new capabilities include additional support for Windows 95, new ODBC drivers, MFC classes for Windows Sockets and MAPI, technical papers from the MFC developers conference, and tuned MFC and C run-time libraries. The subscribers even receive a copy of Visual C++ 4.0 itself.
Since the debut of Microsoft Visual C++ version 2.0, portability has been one of the biggest strengths of Visual C++. With the demands of heterogeneous environments, developers are realizing that cross-platform code portability can save a significant amount of time and money.
What's the use of having cross-development tools that require you to rewrite your code? All versions of Visual C++ support both the Win32 API and MFC, which may already be familiar. In addition to versions that run on Intel platforms, versions that run on MIPS, Alpha, and PowerPC processors are also available.
If you develop for the Apple® Macintosh®, take a look at the Visual C++ Cross-Development System for the Macintosh and Power Macintosh, which lets you work on a Windows NT or Windows 95-based machine while developing for the Macintosh. You can use your existing Win32 and MFC calls, or intermingle them with direct access to System 7 and the Toolbox, for when you need Macintosh-specific functionality.
Microsoft has licensed MFC and the Win32 API to Mainsoft and Bristol Software for products that let you target many major UNIX platforms and virtual memory systems (VMS) with your MFC and Win32 API C and C++ programs. Contact these companies for more details.
Many developers have customers the world over. That's why Visual C++ provides support for many languages. And the support continues in the libraries, resource editors, and more.
From the first screen of AppWizard, Visual C++ lets you choose from eight languages (Chinese, English, German, French, Italian, Korean, Japanese, and Spanish) in which to build your application (Figure 7).
Figure 7. Selecting a language in AppWizard
You can write applications than run with Unicode or a double-byte character set (DBCS) for markets that require non-roman characters. Special support for strings, text display, and editing functions are built in. Different currencies, dates, and numeric formats are also included. A Japanese localized version of Visual C++ 4.0 is currently available for Japanese-speaking developers.
Developer Studio (Figure 8) is the name of Microsoft's new integrated development environment (it's shared with Microsoft Visual Test, Fortran PowerStation, Microsoft Developer Library, and others).
Figure 8. Designing an application with Developer Studio
You no longer need to leave the Visual C++ environment to find a powerful source-code editor. The Developer Studio source editor includes the power features you demand without sacrificing the ease and integration that made the original Visual C++ development environment so popular.
The Developer Studio editor provides keystroke macros, remappable keys, multifile search, column select, user-definable syntax highlighting, incremental search, autoindent, soft and hard tabs, splittable panes, and complex pattern matching, just to name a few advanced features. And to make the transition easier, BRIEF and Epsilon editor emulations are available through the Options dialog box, along with the traditional Visual C++ key bindings.
The Developer Studio graphical integrated debugger makes tracking down bugs much easier. In addition to the interactive disassembly, memory, registers, and call stack windows, there are new multipane variables and watch windows. Setting breakpoints on any source line or assembly-language instruction is a snap; you can also have conditional breakpoints, pass counts, and more. To find the values of your variables, data structures, and expressions, you can drag and drop them into the watch window, type them in manually, or simply pause your mouse over your source code—DataTips will appear, showing the values (Figure 9).
Figure 9: Showing a DataTip while debugging with Developer Studio
Another time saver is Just-in-Time debugging, which lets you catch a bug before it causes your program to crash. You can then diagnose the problem and actively change the values of variables (including pointers), memory, or registers. When you're ready, resume execution at the point where the problem occurred or anywhere else in your code.
Other powerful features of Developer Studio include the ability to step into OLE remote procedure calls (RPCs), allowing you to find bugs on the client or server side of an OLE connection. You can also remotely debug over a serial port or a TCP/IP network connection (including the Internet).
The easy-to-use Visual C++ build system has been extended so that you don't need to create an external makefile to work with other compilers, assemblers, or preprocessors, since the Visual C++ build system lets you call external tools from an internal makefile. You can insert calls to external tools at any point in the build process, adding flexibility. The project system also manages multiple projects from a single work space. This means that you can work with several executable targets (including EXE, DLL, and ActiveX control files) at once.
Integrated online documentation provides easy searches by functional areas though a keyword search or simply though a collapsible table of contents. All sample code can be accessed from this single information source, shared with the Microsoft Developer Network Library viewer. For those who prefer paper-based information retrieval, complete documentation is available separately through Microsoft Press.
Other features of the Developer Studio include an expanded resource editor, with support for ActiveX controls, Windows 95 common controls, multiple-language resources, snap-to guides, and the ability to import forms from Visual Basic. It's easier than ever to design and build complex forms for applications. Multiple-level undo and redo for all of the editors give you a history of editing operations.
As a project becomes more complex, a development tool that can scale to correspond to its degree of complexity is necessary. The system should work well with the existing tools and help teams work together without getting in the way. The Visual C++ Developer Studio helps meet the need for C++ development tools for Windows.
Built into the advanced project-management system of Visual C++ are links to source-code control systems. Microsoft Visual SourceSafe™ (or other version control systems, such as Intersolv PVCS) can work with the Developer Studio to help developers work better in teams by making code sharing and synchronization easier (Figure 10). Hooks are available for other source-code control systems.
Figure 10. Checking project files into Visual SourceSafe
Developer Studio can add your project to a source-code control system or enlist you in an existing project. You can check files in or out, with the source-code control system monitoring changes and coordinating multiple developers. You can even view the history of any project or file, so you can better track the changes you or others have made.
The Component Gallery and Custom AppWizards can help promote code sharing within a development team and throughout a company. By encapsulating code, the Component Gallery makes it easy to package classes for distribution. Custom AppWizards give you the opportunity to create a corporate style sheet for certain kinds of applications, so similar projects don't have to start from scratch. Finally, by building ActiveX controls you can create components that can be used in projects that are written with tools such as Microsoft Access and Microsoft Visual Basic.
Microsoft Visual Test, Microsoft Fortran PowerStation, and the Microsoft Developer Network Library all work together within Developer Studio, so you can use these tools together more effectively. For example, a Microsoft Visual Test scenario can exist in the same environment as C++ source files, making testing faster and easier. The Developer Studio allows combining FORTRAN and C++ source files in the same project. The Microsoft Developer Network Library viewer integrates seamlessly into the environment; the Visual C++ documentation system can be replaced by the Microsoft Developer Network, so CDs don't need to be swapped.
Visual C++ 4.0 provides a more object-centric view of your C++ projects. With the new ClassView and WizardBar, you can concentrate on your classes. These features let you work with class names and member functions instead of having to deal with a list of source and header file names (Figure 11).
Figure 11. Adding a member function with ClassView
ClassView is a tab in the dockable project window that displays the classes and members of your project, making it unnecessary for you to remember which class is in which file and to open them manually. Using an Explorer-like interface, you can jump to, add class members, member functions, and member variables. Since the ClassView is automatically updated without having to build, an accurate view of your project is always available. The old file-based "build view" way of looking at your project remains an option.
The WizardBar is a tool inspired by the convenient drop-down editor toolbar in Visual Basic and Access. The WizardBar lets you quickly jump to the code that responds to commands ranging from a button click to a WM_TIMER message. Message handlers or other virtual functions derived from MFC classes can just as easily be added or removed with the WizardBar.
Windows-based software applications are now rivaling the sophistication and complexity of mainframe applications. Traditionally, as the size of an application increased, so did the build time. Visual C++ 4.0 introduces a host of innovative incremental technologies to practical use in a mainstream development build system, allowing large-scale development projects to build faster.
When developing software, everything in a project is rarely changed at once. A few functions here, a constant declaration there—then building begins. By examining the changes made and only compiling or linking the changed parts, Visual C++ 4.0 can be much more efficient. As a result, build times are proportional to the number of changes made, rather than the size of a project.
Traditionally, if a source file was modified in any way, the entire file would be recompiled during the next build. Incremental compilation means that the compiler will recompile only the changed functions (and functions affected by a change) within an individual source file. Thus, if a source file contained 500 functions, and only one was changed, then only the one function would be recompiled (provided the change to that function had no ramifications outside of that function's scope). Changes to code comments and formatting changes also no longer require a recompile, since the compiler detects that these changes do not affect the final executable.
Visual C++ 4.0 includes a new version of Microsoft's incremental linker. The incremental linker utilizes a technology that permits just those portions of an application that have changed to be relinked, rather than relinking the entire application, resulting in dramatically improved link times. What once took minutes can now be accomplished in seconds.
Building upon a robust, proven technology, the Visual C++ 4.0 team analyzed the most common cases that caused the Visual C++ 2.0 incremental linker to revert to performing a full link. With this data, Microsoft was able to improve the technology to handle these top cases incrementally. This improvement means that with the Visual C++ incremental linker, you'll incrementally link more often, making your build turnaround faster than it's ever been before.
Minimal Rebuild permits the Visual C++ build engine to analyze dependencies within your project and to skip compilation of files that it detects to be unaffected by a change, even if those files include changed headers. This is much more modular than a normal makefile dependency list, which works exclusively on a file's date and not the actual changes made.
For example, adding a member function to a class would typically require that all source files that included that class's header be rebuilt. With minimal rebuild, only the source files that use that member need to be recompiled. Similarly, adding a message handler previously required the recompilation of several files; now only the file with the new message handler must be compiled. Incremental compilation makes this even faster.
Users have told Microsoft that support for the latest additions to the C++ language working papers is important to them. That's why Visual C++ 4.0 is one of the most ANSI X3J16-compliant C++ compilers available for Windows.
Visual C++ now supports run-time type information (RTTI) and namespaces, two of the latest language features in the C++ draft. RTTI is a mechanism that allows the type of an object to be determined during program execution. A name space is a declarative region that attaches an additional identifier to any names declared inside it. By using name spaces, you can eliminate conflicts with names declared elsewhere in the program. This is especially useful when using class libraries from multiple vendors.
Visual C++ 4.0 includes a robust implementation of C++ templates. It can be used with the Hewlett-Packard public-domain implementation of the C++ Standard Template Library (STL), a C++ library of template-based container classes, iterators, and common algorithms, such as searching and sorting. This version of STL is included with Visual C++ 4.0.
C++ Exception handling (as well as C structured exception handling) is also available in the Visual C++ compiler, with many optimizations for high-performance execution. MFC uses C++ exception handling extensively to trap and recover from errors.
But this doesn't mean that C programmers have been forgotten. Microsoft continues to support applications written in ANSI C for Win32, including console applications. The company has tuned the C Run-Time Library to make better use of system memory and cache and to include the source code on the CD. There is also a new debug version of the C Run-Time Library that automatically tracks memory allocations and frees to help find memory leaks in C and C++ applications.
In Visual C++ 4.2, the heap manager has been completely rewritten, providing significant speed improvements over the 4.0 and 4.1 heap managers.
Visual C++ 4.0 makes it easier to reuse your own code and to use code from others. When you write new code, Visual C++ makes the process as fast and efficient as possible.
This list explains several terms used in this and other Visual C++ documents.
Visual C++ glossary
| AppWizard | AppWizard is the tool used to generate a complete suite of source files and resource files based on classes from the MFC Library. By selecting options in AppWizard, you can customize starter files with different kinds of functionality. Once you have completed your selections in AppWizard, Visual C++ builds a framework application for Windows from those starter files, without any further work on your part. You can build your own AppWizard with Visual C++ 4.0. |
| MFC Extension | An extension DLL is a dynamic-link library that provides extensions to MFC. The extensions add capabilities not originally in MFC by deriving new custom classes from existing MFC classes. In effect, you get a custom version of MFC. To use it, you link your extension dynamically to AFXDLL, the shared-library version of MFC, and applications built to use MFC dynamically can call your extension to get the extra capabilities. |
| Component | Reuseable code such as ActiveX controls, your own reusable C++ classes with any associated resources, static libraries, or components created by a third-party vendor. Third-party created components can range from reusable code to useful tools, such as a code-analysis tool. |
| Component Gallery | A central storehouse of reusable code that can be used in projects. Some of the components take the form of wizards, which request information about your project and provide you with choices about the functionality to insert. You can add your own reusable C++ classes with any associated resources to the Component Gallery. If you create ActiveX controls, you can add them to the Component Gallery, ready to add to other applications. You can add components from third-party vendors to the Component Gallery as well. Components created by vendors can range from reusable code segments to ActiveX controls to entire tools, such as a code analysis tool. |
| Minimal Rebuild | A feature that tracks dependencies and rebuilds only affected source files, thereby reducing the number of files that get rebuilt. |
| Incremental Compilation | A feature that allows you to incrementally compile only the functions that have changed within a source file. |
| ClassView | A graphical depiction of all defined classes in your project and their members. ClassView is a computed view, based on the contents of the source files included in the project work space. You can use ClassView to jump directly to the declaration or definition of a class member, as well as to perform other automated processes, such as adding members and setting breakpoints at a member function. |
| Project work space | The Microsoft Developer Studio main document type. The project work space contains one or more projects and tracks information related to those projects, such as which windows were open the last time the user was working, breakpoints that are set, the contents of watch windows, browsing information, and so forth. |
| Project | A project is a named set of files and configurations that, when built, results in a program or code library. When a project work space is created, a project is usually created with the same name and in the same directory. |
| Subproject | A subproject is basically the same as a project, but the term is used to describe any project that is added to a project work space after the project work space is created. A subproject is usually set up as a dependency of some other project in the project work space. This means that when the dependent project is built, the build system will first make sure the subproject is built. This is useful for project work spaces that contain an application project as well as one or more DLL subprojects. Subprojects may also be set up without any dependencies on them. This might be the case for a project work space that contains several separate application projects. |
| Configuration | A configuration is a named set of build tool settings that controls how a project is built. By default, projects have Debug and Release configurations for each platform supported by the project. |
| Platform | A platform describes the target operating system for a configuration. |
| current project | The current project specifies what will be built when the user issues a build command, or what will be debugged if the user starts the debugger. It actually names a project, configuration, and a platform. |
| ClassWizard | ClassWizard automates the creation and editing of classes and creates additional classes based on MFC. It creates the source code for new classes, creates member functions and message maps in those classes, and makes it easy to bind Windows-based messages to code. It also maps dialog-box data to member variables and validates that data. |
| FileView | The portion of the work-space window that displays the project configurations that you have created. Expanding the top-level folders displays the files within the project. |
| ResourceView | The portion of the work-space window that displays the resource files included in the project. Expanding the top-level folders displays the resource types in the files. |
| ClassView | The portion of the work-space window that displays the C++ classes defined in your projects. Expanding the top-level folders displays classes; expanding a class displays its members. |
| InfoView | The portion of the work-space window that displays the table of contents for online help. Expanding the top-level folders displays books and topics. |
Microsoft AnswerPoint offers a wide range of choices and access to high-quality, responsive technical support. Microsoft recognizes that support needs vary from user to user. Microsoft AnswerPoint allows users to choose the type of support that best meets their needs, with options ranging from electronic bulletin boards to annual support programs. Services vary outside the United States and Canada. In other locations, contact a local Microsoft subsidiary for information. Microsoft AnswerPoint is subject to Microsoft's then-current prices, terms and conditions, which are subject to change without notice.
You will find a "Web Favorites" choice on your help menu (as of Visual C++ 4.1). Choosing an item in the favorites list takes you to that site using your favorite browser. You can even add your own favorites to the list.
AnswerPoint Priority Developer provides assistance with development issues for all Microsoft Development tools. Choose from the following options, which include toll-free priority telephone access to support engineers 24 hours a day, 7 days a week:
10 incidents per year
35 incidents per year
Refills of 10 incidents
AnswerPoint Priority Comprehensive provides technical assistance for Microsoft Windows NT operating system, Microsoft SQL Server, Microsoft messaging systems, and other Business Systems products. Priority Comprehensive also covers all other Microsoft products. Choose from the following options, which include toll-free priority telephone access to support engineers 24 hours a day, 7 days a week:
10 incidents per year
35 incidents per year
75 incidents per year
Refills of 10 incidents
AnswerPoint Consulting Line allows you to schedule consultations on supporting and using your Microsoft products. Your call gives you telephone access to technical personnel who can provide assistance when your support consulting requirements exceed the boundaries of your existing Microsoft support (charged per hour). Services include assistance with developing applications using Microsoft applications, implementation assistance, advice on optimizing and tuning your configuration, assistance with internal support structures, reviewing macros and scripts, and mentoring with Internet programming and design. There is a minimum one-hour charge (billed via credit card). Call (800) 936-1565 (U.S.) or (905) 568-0434 (Canada).
Note While the AnswerPoint Consulting Line includes assistance with activities such as design, coding and debugging, Microsoft engineers will not write or debug customer programs.
For additional information or to purchase any of the AnswerPoint fee-based options or the enterprise level Service Advantage services, call Microsoft Support Sales at (800) 936-3500 (U.S.) or at (800) 668-7975 (Canada) from 6:00 A.M. to 6:00 P.M. Pacific time, Monday through Friday, excluding holidays. Please note that technical assistance is not available through this number. Information is also available via the Microsoft World Wide Web site, located at http://www.microsoft.com/support/.
The Microsoft Visual C++ 4.0 development system requirements are as follows: