VC++ - Visual C++ - Microsoft Visual C++ Interview Questions And Answers

Deadlock can arise if four conditions hold simultaneously. Mutual exclusion: only one process at a time can use a resource. Hold and wait: a process holding at least one resource is waiting to acquire additional resources held by other processes. No preemption: a resource can be released only voluntarily by the process holding it, after that process has completed its task. Circular wait: there exists a set {P0, P1, …, P0} of waiting processes such that P0 is waiting for a resource that is held by P1, P1 is waiting for a resource that is held by P 2, …, Pn–1 is waiting for a resource that is held by Pn, and P0 is waiting for a resource that is held by P0.

This is pretty difficult question to describe shortly. Anyway, apartments were introduced by Microsoft in NT 3.51 and late Windows 95 to isolate the problem of running legacy non-thread safe code into multithreaded environment. Each thread was “encapsulated” into so called single-threaded apartment. The reason to create an object in apartment is thread-safety. COM is responsible synchronize access to the object even if the object inside of the apartment is not thread-safe. Multithreaded apartments (MTA, or free threading apartment) were introduced in NT 4.0. Idea behind MTA is that COM is not responsible to synchronize object calls between threads. In MTA the developer is responsible for that. See “Professional DCOM Programming” of Dr. Grimes et al. or “Essential COM” of Don Box for the further discussion on this topic.

Usually, message is handled in the parent class that means you have to override message handler for each parent. Sometimes it is nice to handle a message in the control itself, without parent invocation. Such handling mechanism is called message reflection. Control "reflects" message to itself and then processes it. Use ON_ _REFLECT macro to create a reflected message.

Originally Posted by MSDN The CArchive class allows you to save a complex network of objects in a permanent binary form (usually disk storage) that persists after those objects are deleted. Later you can load the objects from persistent storage, reconstituting them in memory. This process of making data persistent is called “serialization.”

- public - These members can be accessed any where, inside class outside class in derived class. - protected – can be used within the class and inside derived classes. - private - can be used only inside the class, - mutable – if a const method is declared which ensure that the state of object or member variable will not be modified inside such const method . one can declare the variable as mutable and it modified by const method. Basically used for const ojbects.

class MyString() { MyString() { } ~MyString() { delete m_pText; } void Set( char * pText) { size_t length = strlen(pText); m_pText = new char [length]; } private : m_pText; } int _tmain( int argc, _TCHAR* argv[]) { return 0; } Answers: Class declaration is wrong ended with (). Type for m_pText is not specified. Class declaration closing brace is not ended with semicolon m_pText should be deleted as delete[] and not just delete. you cant take the strlen of pointer as if it is not null terminated one it will give wrong results.

GetWindowRect - It gives the rectangle of window frame including he client area (working area excluding windows framem , menu etc). GetClientRect()- working area excluding windows frame , menu etc Get the handle to the child window by using the item resource id And call GetClientRect() on that.

Windows thread is the basic unit of execution, rather than a process A process can contain one or more threads Each process has its own code and data address space Threads share the process address space Threads are “lightweight” and more efficient than processes Used for servers, asynchronous I/O, ...

In windows operating system Every resource is an “object” identified and referenced by a “handle” of type HANDLE. In 32 bit Windows its a 32 bit value. Kernel objects must be manipulated by WindowsAPIs HANDLE datatype objects include: files pipes processes memory mapping threads events, mutexes, semaphores

Message Maps MFC uses message maps to get around a fundamental problem with virtual functions. Look at the CWnd class in the MFC help file. It contains over 200 member functions, all of which would have to be virtual if message maps were not used. Now look at all of the classes that subclass the CWnd class. For example, go to the contents page of the MFC help file and look at the visual object hierarchy. 30 or so classes in MFC use CWnd as their base class. This set includes all of the visual controls such as buttons, static labels, and lists. Now imagine that MFC used virtual functions, and you created an application that contained 20 controls. Each of the 200 virtual functions in CWnd would require its own virtual function table, and each instance of a control would therefore have a set of 200 virtual function tables associated with it. The program would have roughly 4,000 virtual function tables floating around in memory, and this is a problem on machines that have memory limitation

There are two types of pipes for two-way communication: anonymous pipes named pipes. Anonymous pipes enable related processes to transfer information to each other. An anonymous pipe is used for redirecting the standard input or output of a child process so that it can exchange data with its parent process. To exchange data in both directions (duplex operation), you must create two anonymous pipes. The parent process writes data to one pipe using its write handle, while the child process reads the data from that pipe using its read handle. Similarly, the child process writes data to the other pipe and the parent process reads from it. Anonymous pipes cannot be used over a network, nor can they be used between unrelated processes. Named pipes are used to transfer data between processes that are not related processes and between processes on different computers. A named-pipe server process creates a named pipe with a well-known name or a name that is to be communicated to its clien

RPC enables applications to call functions remotely. Therefore, RPC makes IPC as easy as calling a function. RPC operates between processes on a single computer or on different computers on a network. The RPC provided by Windows is compliant with the Open Software Foundation (OSF) Distributed Computing Environment (DCE). This means that applications that use RPC are able to communicate with applications running with other operating systems that support DCE. RPC automatically supports data conversion to account for different hardware architectures and for byte-ordering between dissimilar environments. RPC clients and servers are tightly coupled but still maintain high performance. The system makes extensive use of RPC to facilitate a client-server relationship between different parts of the operating system. Key Point: RPC is a function-level interface, with support for automatic data conversion and for communications with other operating systems. Using RPC, you can create high-perform

Windows Sockets is an protocol-independent interface. It takes advantage of the communication capabilities of the underlying protocols. In Windows Sockets 2, a socket handle can optionally be used as a file handle with the standard file I/O functions. Windows Sockets are based on the sockets first popularized by Berkeley Software Distribution (BSD). An application that uses Windows Sockets can communicate with other socket implementation on other types of systems. However, not all transport service providers support all available options. Windows Sockets is a protocol-independent interface capable of supporting current and emerging networking capabilities.

Mailslots provide one-way communication. Any process that creates a mailslot is a mailslot server. Other processes, called mailslot clients, send messages to the mailslot server by writing a message to its mailslot. Incoming messages are always appended to the mailslot. The mailslot saves the messages until the mailslot server has read them. A process can be both a mailslot server and a mailslot client, so two-way communication is possible using multiple mailslots. A mailslot client can send a message to a mailslot on its local computer, to a mailslot on another computer, or to all mailslots with the same name on all computers in a specified network domain. Messages broadcast to all mailslots on a domain can be no longer than 400 bytes, whereas messages sent to a single mailslot are limited only by the maximum message size specified by the mailslot server when it created the mailslot. Mailslots offer an easy way for applications to send and receive short messages. They also provide t

File mapping enables a process to treat the contents of a file as if they were a block of memory in the process's address space. The process can use simple pointer operations to examine and modify the contents of the file. When two or more processes access the same file mapping, each process receives a pointer to memory in its own address space that it can use to read or modify the contents of the file. The processes must use a synchronization object, such as a semaphore, to prevent data corruption in a multitasking environment. You can use a special case of file mapping to provide named shared memory between processes. If you specify the system swapping file when creating a file-mapping object, the file-mapping object is treated as a shared memory block. Other processes can access the same block of memory by opening the same file-mapping object. File mapping is quite efficient and also provides operating-system–supported security attributes that can help prevent unauthorized data

DDE is a protocol that enables applications to exchange data in a variety of formats. Applications can use DDE for one-time data exchanges or for ongoing exchanges in which the applications update one another as new data becomes available. The data formats used by DDE are the same as those used by the clipboard. DDE can be thought of as an extension of the clipboard mechanism. The clipboard is almost always used for a one-time response to a user command, such as choosing the Paste command from a menu. DDE is also usually initiated by a user command, but it often continues to function without further user interaction. You can also define custom DDE data formats for special-purpose IPC between applications with more tightly coupled communications requirements. DDE exchanges can occur between applications running on the same computer or on different computers on a network. DDE is not as efficient as newer technologies. However, you can still use DDE if other IPC mechanisms are not suitabl

Data copy enables an application to send information to another application using the WM_COPYDATA message. This method requires cooperation between the sending application and the receiving application. The receiving application must know the format of the information and be able to identify the sender. The sending application cannot modify the memory referenced by any pointers. Data copy can be used to quickly send information to another application using Windows messaging. For more information, see Data Copy.

Applications that use OLE manage compound documents— that is, documents made up of data from a variety of different applications. OLE provides services that make it easy for applications to call on other applications for data editing. For example, a word processor that uses OLE could embed a graph from a spreadsheet. The user could start the spreadsheet automatically from within the word processor by choosing the embedded chart for editing. OLE takes care of starting the spreadsheet and presenting the graph for editing. When the user quit the spreadsheet, the graph would be updated in the original word processor document. The spreadsheet appears to be an extension of the word processor. The foundation of OLE is the Component Object Model (COM). A software component that uses COM can communicate with a wide variety of other components, even those that have not yet been written. The components interact as objects and clients. Distributed COM extends the COM programming model so that it w

Using the Clipboard for IPC The clipboard acts as a central depository for data sharing among applications. When a user performs a cut or copy operation in an application, the application puts the selected data on the clipboard in one or more standard or application-defined formats. Any other application can then retrieve the data from the clipboard, choosing from the available formats that it understands. The clipboard is a very loosely coupled exchange medium, where applications need only agree on the data format. The applications can reside on the same computer or on different computers on a network. Key Point: All applications should support the clipboard for those data formats that they understand. For example, a text editor or word processor should at least be able to produce and accept clipboard data in pure text format. For more information, see Clipboard.

The communications and data sharing between applications( different processes) are called as interprocess communications (IPC). Some IPC allows the communications and data sharing among several specialized processes. Other IPC communications and data sharing among computers on a network. Applications can use IPC categorized as clients or servers. A client is an application or a process that requests a service from some other application or process. A server is an application or a process that responds to a client request. Many applications act as both a client and a server, depending on the situation. For example, a word processing application might act as a client in requesting a summary table of manufacturing costs from a spreadsheet application acting as a server. The spreadsheet application, in turn, might act as a client in requesting the latest inventory levels from an automated inventory control application. an application can use several IPC mechanisms. Based on applications ru

1. Global Variable are created. 2. Program execution starts at Winmain() 3. Create WndProc (switch cases for different messages) 4. Creates WndClass by specify window styles, properties and WndProc. 5. Registered WndClass created previously. 6. Create Window for this win32 application and display it. 7. Start the application message loop. 8. A message queue is associated with win32 application. 8. Loop seeks for messages from messages queues associated. 9. retrieves the messages and enter into WndProc. 10. executes appropriate Message handler.

#define new DEBUG_NEW Within each module of your application before you use the new operator to get more precise information. This step will cause your program to use DEBUG_NEW, a special version of the MFC new operator, which will also record line number and file name information for each allocation as it occurs. With this #define in place, any memory leak dumps will also include line number and source module name information for the allocation that caused the leak, thus helping you to pinpoint problems in your code. In the release build, DEBUG_NEW reverts back to the normal new operator. Also note that, as of MFC 4.0, it uses the heap management from the C run-time library. This means that you can use the same debugging features in non-MFC applications.

property The data associated with an object. property page A grouping of properties presented as a tabbed page of a property sheet. property sheet A type of dialog box that is generally used to modify the attributes of an external object, such as the current selection in a view. A property sheet has three main elements: the containing dialog box, one or more property pages shown one at a time, and a tab at the top of each page that the user clicks to select that page. An example of a property sheet is the Project Settings dialog box in Visual C++

dialog data exchange (DDX) In MFC , a method for transferring data between the controls of a dialog box and their associated variables. DDX is an easy way to initialize dialog box controls and gather user data input. dialog data validation (DDV) In MFC , a method for checking data as it is transferred from the controls in a dialog box. DDV is an easy way to validate data entry in a dialog box.

assertion A Boolean statement in a program's debug version that tests a condition that should evaluate as true, provided the program is operating correctly. If the condition is false, an error has occurred; thus, the program will typically issue an error message that gives a user the option to abort the program, activate the debugger, or ignore the error.

application framework Or framework. A group of C ++ classes in the MFC Library that provides the essential components of a Windows application. The application framework defines the basic operational structure of an application, and supplies standard user-interface implementations that can be incorporated into the application.

ActiveX control An embeddable, reusable COM object that supports, at a minimum, the IOleControl interface. ActiveX controls are typically created for the user interface, but they also support communication with a control container. Multiple clients can reuse these controls, depending upon licensing restrictions.

Zero Administration for Windows (ZAW) is a Microsoft initiative designed to reduce the cost and labor associated with administering a Windows-based network.

An ActiveX control should be small in size, and if it requires large blocks of data, be able to load the data asynchronously. Asynchronous loading allows the control to interact with the user as quickly as possible while buffering downloaded data in the background.

as well? Why or why not? Yes, you should provide a copy of the license along with the product itself. ActiveX controls are sold to other developers, who in turn use them to create applications or Web pages designed for users. Licensing code prevents a developer from using an ActiveX control except in the presence of a valid license. When a developer adds an ActiveX control to an application project, the control confirms the existence of the license; only upon confirmation that the license exists can the control then be used.

Licensing schemes can take many innovative forms, but generally rely on the presence of either a specific file or a particular entry in the system registry.

The main advantage ATL offers ActiveX development is that ATL can create controls that have no dependencies. Properly written, an ActiveX control created from ATL requires neither MFC nor the C run-time library, ensuring that only the control's executable file needs to be downloaded from a Web page. ActiveX controls created usinng MFC can execute only when MFC42.dll and MSVCRT.dll are present on a system.

Applications can be deployed on media such as disks and CD-ROMs, and over a network or the Internet.

ActiveX controls must be registered on a system before they can be used. Usually, this process is hidden from the user because it is performed automatically by a Web browser or by installation programs. The registry information must include the control's class identifier and its location on the system's hard disk.

Given a Visual C++ project, InstallShield creates an installation package consisting of a Setup program, cabinet files, and miscellaneous information files. When run on another computer, the installation package installs the application and automatically configures the computer to run it.

Recognizable by their .cab extensions, cabinet files contain collections of files in compressed form. Registry or .reg files hold scripts that can be merged into system registries using the RegSvr32 utility.

The first stage of deployment is the transfer of all necessary files to the user's hard disk. The second stage involves configuring the host system so that it recognizes and correctly runs the installed application.

In regression testing, an application is re-submitted to the same battery of tests it has already gone through. Regression testing is applied after changes are made to an application, and ensures that the changes do not introduce new bugs or unexpected behavior.

Spy++ can display views of current windows, processes, and threads. It can also display a log of messages that a window sends or receives.

A dependency is an executable module, usually a DLL or an ActiveX control, that an application requires to execute. Dependencies can themselves have dependencies, forming a hierarchy of modules. For example, an MFC application might make no direct use of the C run-time library; nevertheless, the application is dependent on the library because MFC itself requires the C run-time library.

Visual C++ provides the ActiveX Control Test Container, a generalpurpose container program that can embed any ActiveX control. The Test Container can call methods, set and read properties, activate the control's property sheet, and monitor events.

You can place debug breakpoints at designated locations in the program. When the program you are debugging encounters a breakpoint, execution freezes and the debugger gains control. Two types of breakpoints exist: location and data. Visual C++ also provides conditional and message breakpoints, but these are simply special cases of location breakpoints.

ASSERT and VERIFY are very similar, differing in only one respect. Both macros take an expression as a parameter and cause an exception if the expression evaluates to FALSE. The only difference is that ASSERT does nothing in release builds, whereas VERIFY works in both debug and release code. DEBUG_NEW replaces calls to the new operator, performing the same service but also recording the file name and line number where each new statement occurs. This can help locate the cause of memory leaks resulting from a failure to match a new statement with a delete statement.

Debug and release builds differ in two main characteristics. First, a program's debug build contains symbol information placed in the object code by the compiler, whereas the release code does not. Second, code in a debug build is not optimized, ensuring that the generated object code closely matches the original source code. Release code is almost always optimized.

A COM server can indicate an error has occurred by returning an HRESULT code or by firing the Error event.

In COM programming, an HRESULT is a defined type for a 32-bit-long integer containing an error code. COM components such as ActiveX controls export functions (or methods) that return HRESULT codes. An HRESULT integer contains bit fields that specify severity, facility, and a code descriptor. HRESULTs are signed integers; zero or a positive value indicates success, whereas a negative HRESULT indicates failure and usually causes an exception to occur.

Structured Exception Handling is a service of the Windows operating system responsible for locating and calling handler code in an application when an error occurs. The application encloses code within a __try block and identifies its error handler code by placing it within an __except block.

Though both ISAPI server extensions and filters are implemented as DLLs, ISAPI server extension DLLs are loaded into the IIS process when a client first requests them, and stay loaded until the WWW service is stopped. ISAPI filters are loaded when the WWW service is started.

Specify the default function for an ISAPI server extension by using the DEFAULT_PARSE COMMAND macro in the PARSE MAP of your ISAPI extension class.

ActiveX document container when it loads an ActiveX document? When an ActiveX document container loads an ActiveX document, it displays the menu commands defined on the IDR_SRVR_INPLACE menu of the ActiveX document server. Edit the IDR_SRVR_INPLACE menu (and toolbar) to make the appropriate items appear.

You can save changes you make to an ActiveX document by using the Save As option from the File menu to create a new version on your own hard disk. An ActiveX document server won't let you save any changes you make to the document back to the Internet host.

The Scriptlet Component routes all custom scriptlet events through a single event named onscriptletevent. This event is fired with two parameters. The first parameter specifies the name of the event; the second parameter can be used to pass data associated with the event.

In an ATL HTML control, you define methods to be accessible to the HTML source code of the document displayed by the control by adding the methods to the UI dispatch interface that is created for your ATL HTML control project. This UI dispatch interface is used to communicate between the C++ code and the HTML UI. Script in the HTML page displayed by your control can access properties and methods defined for this interface via the DHTML window.external object.

The preferred method of creating a Web browser–style application is using the MFC AppWizard, and specifying CHtmlView as the view class.

MFC greatly simplifies the process of creating an ActiveX control. Using the MFC ActiveX ControlWizard, you can quickly and easily create a fully featured ActiveX control. ActiveX controls written in ATL are smaller than their MFC counterparts, and if written properly will perform better. Use MFC where ease and speed of development are more important to you than the size and performance of the control.

A CComControl-class object handles Windows messages by implementing a message map.

A connection point is an interface that helps to manage the connection of source interfaces to a corresponding client object, or sink. Through the connection point mechanism, a pointer to the sink interface is passed to the source object. This pointer provides the source with access to the sink's implementation of its interface methods.

The purpose of the DDP functions is to transfer data between property pages and control properties. These functions are used within the DoDataExchange() function of the property page class.

To implement property persistence for an MFC ActiveX control, you use the property exchange functions provided by MFC, which allow you to serialize properties of different types. The names of these functions begin with the prefix PX_. PX_ functions are placed within the control class's DoPropExchange() function.

An advantage of COM containment is that the interface on the containing (outer) object can control access to the contained (inner) object, and can control the way in which the inner object's services are used. A disadvantage of containment is that some overhead is incurred by the forwarding of method calls.

When an outer object creates an aggregated inner object, it uses the second argument of the CoCreateInstance() function to pass the address of its IUnknown pointer (the controlling unknown) to the inner object's class factory. If this address is not NULL, the inner object knows that it is being aggregated, and delegates IUnknown method calls from external clients to the controlling unknown.

A _com_ptr_t object helps manage the lifetime of your COM server object by calling the IUnknown::AddRef() and IUnknown::Release() methods of the encapsulated interface on your behalf. AddRef() is called automatically when a _com_ptr_t object is created as a copy from an existing interface pointer, and Release() is called automatically when a _com_ptr_t object goes out of scope.

COM interfaces are represented in C++ code by abstract classes.

In an IDL file each COM object definition is identified by a separate coclass section, and each interface definition by a separate interface section. The server's type library is defined within the library section. The coclass definitions that are to be exposed through the type library are nested within the library definition.

An object map is a table that maintains information used by the framework to instantiate objects through a class factory, establish communication between a client and the root object in the component, perform lifetime management of class objects, and enter and remove object descriptions in the system registry. You can add an entry to the object map by using the OBJECT_ENTRY macro.

A COM map is an element of your class declaration that contains a list of the interfaces that your COM object supports. Add an entry to the COM map by using the COM_INTERFACE_ENTRY macro. Whenever a client application executes QueryInterface(), the object searches this map for a matching interface GUID. If a match is found, the corresponding interface pointer is returned to the client.

The templated base class CComCoClass provides a default implementation of a class factory, which creates an instance of your server class.

The templated base class CComObjectRootEx provides a default implementation for the IUnknown interface methods QueryInterface(), AddRef(), and Release(). When you derive from this class, your client can use QueryInterface() to acquire an interface pointer to any interface that your COM object supports. CComObjectRootEx also provides implementations of the IUnknown methods AddRef() and Release() to perform reference counting for your object.

When implementing an ActiveX control, you must take into consideration that, although the definition of ActiveX controls requires only that the control support the IUnknown interface, different containers have different requirements. Some containers require certain interfaces for a control to work, while others do not. If you want your control to work with a particular container, your control must implement the interfaces required by the container.

COM objects that are created to support the free-threading model must be thread safe, and must provide their own synchronization code. By removing the bottleneck that is created by marshaling, free-threaded objects provide the highest performance and throughput on the server side.

A type library is a binary description that includes interface properties and methods, and method arguments. Type libraries are used in situations when high-performance development languages, such as Visual Basic 6.0, need to be able to access interface methods directly, through the vtable. To make this possible, type libraries provide the Visual Basic client with information on which data types are required by the interface methods.

You implement standard marshaling by specifying your interfaces using IDL and allowing the MIDL compiler to create marshaling code for you.

In-process servers, implemented as DLLs, execute within the same process as the object's client application. Local (or out-of-process) servers, implemented as .exe files, reside on the same computer as the client application, but execute in a different process. Remote servers execute on a computer remote from the clients that they are serving.

A GUID, or globally unique identifier, is a 128-bit numeric identifier that is guaranteed to be universally unique, and to remain unique until approximately 3400 A.D.

A COM interface is a logical grouping of related methods identified by a GUID, known as an Interface Identifier (IID).

The RecordSource property specifies an SQL command to retrieve records from the data source.

The Errors collection is associated with the C onnection object, and contains specific information on provider errors.

This function specifies the data source to be used by the recordset.

Because you need to make only a single pass through the recordset to list the records to the printer, you should supply CRecordset::forwardonly as the first argument to the Open() function. You should always use the fastest and least memory-consumptive cursor for a given task.

In the code provided, single apostrophes (') need to enclose M% so that the code reads 'M%'. Note that apostrophes are always used when the value in the WHERE clause is a string value, but not used when the WHERE clause value is a numeral.

The default SerializeElements() implementation performs a bitwise copy of data contained in an MFC collection to or from an archive.

The MFC profile management classes WriteProfileString() and WriteProfileInt() store profile settings to the registry key specified by the CWinApp::SetRegistryKey() function.

The registry key that should be used to store application settings common to all users of the computer on which an application is installed is HKEY_LOCAL_MACHINE\SOFTWARE.

You can connect an ADO application to an ODBC data source by using the OLE DB provider for ODBC.

 Derive the class from CObject or a class that was derived from CObject.  Provide a default constructor for your class.  Add the MFC macro DECLARE_SERIAL to the class definition.  Add the IMPLEMENT_SERIAL macro to your class implementation file.  Provide an override of the C Object::Serialize() function for your class.

The CFile::Open() function throws a CFileException.

To open a file in text mode, create a CStdioFile object and associate it with the text file, and then supply the CFile::typeText flag to the Open() function.

To create a hyperlink in a Help project .rtf file, you would format the links as double-underlined text and follow the links immediately by the link destinations formatted as hidden text. A pound (#) footnote mark signifies the link destinations. The footnote text contains the context name, which can either be a name internal to the Help file, or one of the Help context IDs specified in the Help project's .hm file.

Help context IDs are stored in files with the .hm extension as part of the Help project.

Though both objects are synchronization classes, CCriticalSection allows only one thread from within the current process to access an object, while CMutex allows only one thread from any process to access an object.

You should always use the CWinThread class to create threads that use MFC functionality, because the CWinThread class uses thread-local storage to manage information specific to the thread context in the MFC environment.

The CDC::SelectObject() function associates a drawing tool object with a device context.

The two functions used to specify coordinate mapping for an unconstrained mapping mode are the CDC functions SetWindowExt() and SetViewportExt().

To make controls unavailable in a dialog box, you would use the CWnd::EnableWindow() function with the argument FALSE.

The DoDataExchange() function is called by the CWnd::UpdateData() function. The DoDataExchange() function passes data between the dialog box controls and the application; the CDataExchange class member variable m_bSaveAndValidate indicates the direction of the data exchange.

To display a modal dialog box based on a template created using the dialog editor, you would first use ClassWizard to create a dialog class based on the template. You would then create an instance of the dialog class in your code, and call the base class method CDialog::DoModal() to display the dialog box.

To make an edit control in a dialog box read-only, select the Read Only check box on the Styles tab of the Edit Properties dialog box. A read-only edit control can be used to convey dynamically changing text to a user.

The recommended method for updating a status bar indicator is to set up an array of status bar indicators associated with string IDs in the application's string table. The recommended way to update text in a status bar pane is to use an ON_UPDATE_COMMAND_UI entry in a message map to associate a user-interface update handler function with an indicator's string ID.

To dynamically change the text of a menu command from within your application code, you would use the SetText member function of the CCmdUI MFC class.

To implement ToolTip text for your toolbar buttons, add the \n escape sequence, followed by the ToolTip text, to the end of the Prompt string in the Toolbar Button Properties dialog box.

To ensure that the client area of your application's main window always displays an up-to-date picture of the application data, you should call the document's UpdateAllViews() member function whenever a document's data changes in a way that will affect its visual representation.

The MFC CDC class encapsulates GDI drawing functions.

A document template object associates a document class with a group of resources (such as menus and icons), a frame window, and a view.

Four categories of Windows messages that can be handled by message maps are Windows messages, command messages, user interface update command messages, and control notification messages

Classes derived from the CCmdTarget class can implement message maps.

The Run() member function of the CWinApp MFC class implements the application message loop.

Because MFC extension DLLs implement reusable classes derived from existing MFC classes, you would use an MFC extension DLL to provide an "extended" version of MFC. Also can export Classes from which objects can be created and used.

The CObject class provides serialization (loading and saving data objects to a agnostic and debugging support (validations and dumps), and compatibility with collection classes. Runtime class identification and dynamic object creation.

When developing an MFC application, you might need to call the Win32 API directly when you need to access system functionality at a fairly low level. For example, if you were developing a utility to modify user accounts on a network, you would be required to use the Win32 networking functions because no MFC classes that provide access to Windows NT network management functions exist.

From the C/C++ page of the Project Settings dialog box, you can set compiler settings and language features such as calling conventions, processor-dependent settings, optimizations, and preprocessor definitions.

AppWizard automatically creates the Debug and Release configurations.

OLE DB is capable of dealing with any type of data regardless of its format or storage method. For instance, OLE DB can access data that resides in an Excel spreadsheet, in text files, or even on a mail server such as Exchange.

You should install the MFC libraries for Unicode (either shared or static, according to how the application will be distributed). Internal strings used by Windows NT, such as user account names and device names, are Unicode strings, so you will need to install the Unicode libraries if you are planning to write programs that retrieve and manipulate these strings directly.

Some such benefits include the ability for developers to quickly and easily generate applications, libraries, and software components. MFC enables rapid development in all aspects of Windows programming including user interface, Internet, component technology, and database access development—all without sacrificing programming freedom and flexibility. In addition, MFC provides the AppWizard, a step-by-step visual tool that allows developers to quickly and easily generate frameworks to set up a basic application structure, and to generate code to implement fundamental application behaviors.

Enclosed inside _T() macro for unicoade for ansi normal one (Without) _UNICODE defined TCHAR.H

he manifest that contains the event definitions is compiled by the Message Compiler (MC.exe) tool. The Message Compiler is run before the source files compiler because it produces files required to compile the source files that raise events. It also generates the template and message resources to be added to the binary at link time. The Message Compiler is included in the Windows SDK The Message Compiler accepts a message file (.mc) as input and generates the following files: a C/C++ header file that contains definitions for the symbolic names, one binary resource file per supported language (Msg00001.bin, Msg00002.bin, and so on), and a resource file (.rc) that contains the appropriate statements to include each .bin file as a resource. Most manifests will use standard Windows-defined constants and the path to Winmeta.xml file that contains the definitions of these constants must be included. In many cases, this invocation is sufficient. Commonly, -h and –r switches are used to direct

Implicit linking – this is loads automatically at the application startup itself and loaded throughout life of program. Consuming the memory which can be made available to other applications while not in use. Explicit – Explicitely loading dlls into memory by calling fuctions such as loadlibrary. Then user can take the fuction pointers of exported funcions calls the funcitons and afte use and unload library, freeing memmory consumed by dll , so that it can be available to other use.

XP Supported: Clipboard COM Data Copy DDE File Mapping Mailslots Pipes RPC Windows Sockets CE Supported: 1. Sockets 2. Memory Mapped Files 3. Windows Messages 4. Point to Point Message Queues 5. MSMQ 6 Out-of-proc COM 7. Named Events + registry 8. Directly Share memory

Represents a globally unique identifier (GUID). A GUID is a 128-bit integer (16 bytes) that can be used across all computers and networks wherever a unique identifier is required. Such an identifier has a very low probability of being duplicated. he GUID data type is a text string representing a Class identifier (ID). COM must be able to convert the string to a valid Class ID. All GUIDs must be authored in uppercase. The valid format for a GUID is {XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX} where X is a hex digit (0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F). Note that utilities such as GUIDGEN can generate GUIDs containing lowercase letters. These must all be changed to uppercase letters before the GUID can be used by the installer as a valid product code, package code, or component code.

If apliation is using C run-time library (CRT) .

Afxbeginthread – for worker thread only global fuction passed as parameter For ui thread , a class derived from CWinThread passed as parameter CreateThread() -beginthread()

GetStockObjct() Parameters are provided to take a perticaulaa type of object such as pen, brush Font Ex DC_PEN, DC_BRUSH, DC_FONT Can store original object for restoring later. SelectObject()

ASSERT and VERIFY are very similar, differing in only one respect. Both macros take an expression as a parameter and cause an exception if the expression evaluates to FALSE. The only difference is that ASSERT does nothing in release builds, whereas VERIFY works in both debug and release code. DEBUG_NEW replaces calls to the new operator, performing the same service but also recording the file name and line number where each new statement occurs. This can help locate the cause of memory leaks resulting from a failure to match a new statement with a delete statement.

In COM programming, an HRESULT is a defined type for a 32-bit-long integer containing an error code. COM components such as ActiveX controls export functions (or methods) that return HRESULT codes. An HRESULT integer contains bit fields that specify severity, facility, and a code descriptor. HRESULTs are signed integers; zero or a positive value indicates success, whereas a negative HRESULT indicates failure and usually causes an exception to occur

Structured Exception Handling is a service of the Windows operating system responsible for locating and calling handler code in an application when an error occurs. The application encloses code within a __try block and identifies its error handler code by placing it within an __except block.

In regression testing, an application is re-submitted to the same battery of tests it has already gone through. Regression testing is applied after changes are made to an application, and ensures that the changes do not introduce new bugs or unexpected behavior.

The main advantage ATL offers ActiveX development is that ATL can create controls that have no dependencies. Properly written, an ActiveX control created from ATL requires neither MFC nor the C run-time library, ensuring that only the control's executable file needs to be downloaded from a Web page. ActiveX controls created using MFC can execute only when MFC42.dll and MSVCRT.dll are present on a system.

An ActiveX control should be small in size, and if it requires large blocks of data, be able to load the data asynchronously. Asynchronous loading allows the control to interact with the user as quickly as possible while buffering downloaded data in the background.