Advanced Visual C++

How to create a new static library project in Visual C++

2012-09-27T21:13:00.000+05:30

From the File menu, select New and then Project….
From the Project types pane, under Visual C++, select Win32.
From the Templates pane, select Win32 Console Application.
Choose a name for the project, such as MathFuncsLib, and enter it in the Name field. Choose a name for the solution, such as StaticLibrary, and enter it in the Solution Name field.
Press OK to start the Win32 application wizard. From the Overview page of the Win32 Application Wizard dialog, press Next.
From the Application Settings page of the Win32 Application Wizard, under Application type, select Static library.
From the Application Settings page of the Win32 Application Wizard, under Additional options, deselect Pre-compiled header.
Press Finish to create the project.

Decomposing makes everything easier...

2011-06-09T15:23:00.000+05:30

Time for us to start writing computer games! This first one will be a bit simple, but it's a start. Our task is to write a program that implements a guessing game. Our program generates a random number between 0 and 100. The player must guess the secret number. The program provides hints like "that's too high" or "that's too low" until the player finally guesses the secret number.
We will work on this game in three steps.

Figure out how to generate a random number within a given range of values.
Create a main function that processes one guess from the player, and provides hints.
Add what we need to allow for multiple guesses until the player guesses the number.

This process of development is called decomposition, which means breaking a task into sub-tasks, each of which is easy to do. Starting with step 1, do a Google search to see how to generate a random number using C++. Try searching on "rand C++".

// random.cpp. Maggie Johnson
// Description: Illustrates how to generate a random number in Visual C++

#include <iostream>
#include <time.h>
using namespace std;
int main () {
int random_number;
// Initialize random seed.
srand (time(NULL));
// Generate random number between 1 and 100
random_number = rand() % 100 + 1;
cout << "Your random number:" << random_number << endl;
system("pause");
}

For step 2, we need to receive an integer input from the player (with appropriate error-checking on cin), and check it against the secret number. Try and write this part of the game yourself before checking our solution.

// guess.cpp.  Maggie Johnson
// Description: A guessing game where the player guesses
// the secret number.

#include <iostream>
#include <time.h>
using namespace std;

int main () {
  int random_number, guess;

  // Initialize random seed.
  srand (time(NULL));

  // Generate random number between 1 and 100
  random_number = rand() % 100 + 1;

  cout << "Guess our number (1 to 100) ";
  if (!(cin >> guess)) {
    cout << "Please enter only numbers" << endl;
  } else {
    if (random_number < guess) cout << "The secret number is lower than " << guess << endl;
    else if (random_number > guess) cout << "The secret number is higher than" << guess << endl;
    else cout << "You guessed it: " << random_number << endl;
  }
  cout << "random: " << random_number << endl;
  return 0;
}

Finally, we need to add a loop that keeps collecting guesses from the player until they finally guess the secret number. After completing this part of the program, you can check our solution.

// guess.cpp.  Maggie Johnson
// Description: A guessing game where the player guesses
// the secret number.

#include <iostream>
#include <time.h>
#include <cstdlib.h>
using namespace std;

int main () {
  int random_number, guess;

  // Initialize random seed.
  srand (time(NULL));

  // Generate random number between 1 and 100
  random_number = rand() % 100 + 1;

  cout << "Guess our number (1 to 100) ";
  do {
    if (!(cin >> guess)) {
      cout << "Please enter only numbers" << endl;
    } else {
      if (random_number < guess) cout << "The secret number is lower than " << guess << endl;
      else if (random_number > guess) cout << "The secret number is higher than " << guess << endl;
    }
  } while (random_number != guess);
  cout << "Congratulations!" <<  endl;
  return 0;
}

Decomposition is one of the most important skills for a programmer to learn. Being able to break a task down into manageable pieces, and then complete one at a time is critical, no matter how big or how small the project. Here are some other opportunities for you to practice decomposition.

Many everyday tasks provide opportunities to build skills in decomposition. It might surprise you to discover that your mind just works this way! For example, if I have to clean up a really messy kitchen (perhaps some little girls just baked a cake), I break the tasks down to provide a plan, and to make sure I don't have to re-do work later. I don't want to wash the floor first if there's all kinds of stuff on the counters to clean up - I'll probably have to do the floor again later. So, maybe I put all the ingredients away first; move all the dishes into the sink; clean off the counters; wash the dishes; and finally, clean up the floor. There are other ways to perform this task, but by thinking it through first, it helps me define a plan that will not require re-work.
Use everyday tasks as examples for developing your decomposition skills. Who knows - it might even make you more efficient around the house!
The greatest common divisor of two integers is the largest number that divides them both evenly. For example, gcd(12, 18) = 6, gcd(−4, 14) = 2. The most efficient way to compute gcd is with the Euclidean algorithm. Write a program with a function to compute gcd for two integers. Try doing the function without recursion first - it will help you understand how the algorithm works. Explicitly define your sub-tasks, for example, find the code for the Euclidean algorithm; create a non-recursive function for the algorithm; etc. Here is our solution.

// gcd.cpp, Maggie Johnson
// Description: An implementation of Euclid's algorithm for computing gcd.
// Fundamental idea of Euclid's algorithm (one of the oldest known algorithms)
// for finding the greatest common divisor of two integers:
// gcd(a, 0) = a
// gcd(a, b) = gcd(b, a % b)  // % means modulo, that is, the remainder of a/b.
// For example, gcd(6, 4) = 2; gcd(12, 18) = 6.

#include <iostream>
using namespace std;

// A non-recursive version of Euclid's algorithm
int gcd (int a, int b) {
  int temp;
  while (b != 0) {
    temp = a % b;
    a = b;
    b = temp;
  }
  return(a);
}

int main () {
  int x, y;
  cout << "Enter two integers: ";
  if (!(cin >> x >> y)) {
    cout << "Please enter only integers" << endl;
  } else {
    cout << "gcd(" << x << ", " << y << ") = " << gcd(x,y) << endl;
  }
  return(0);
}

Get some input

2011-06-09T15:12:00.000+05:30

// get_input.cpp: Maggie Johnson
// Description: Illustrate the use of cin to get input.

#include <iostream>
using namespace std;
int main()
{
int input_var = 0;
// Enter the do while loop and stay there until either
// a non-numeric is entered, or -1 is entered. Note that
// cin will accept any integer, 4, 40, 400, etc.

do
{
    cout << "Enter a number (-1 = quit): ";
// The following line accepts input from the keyboard into
// variable input_var.
// cin returns false if an input operation fails, that is, if
// something other than an int (the type of input_var) is entered.

    if (!(cin >> input_var))
{
      cout << "Please enter numbers only!" << endl;
   cin.clear();
   cin.ignore(10000,'\n');
// break;
    }
    else if (input_var != -1)
{
      cout << "You entered " << input_var << endl;
}
} while (input_var != -1);

cout << "All done." << endl;
system("pause");
return 0;
}

An experiment:

When an input error is made, the stream "breaks," cin returns false, and the program stops. It's very important to guard against such errors as we did in the program above. But what if we want to recover from the error, rather than have the program stop? There are two steps to recovering from an error:
1. Clear the error with cin.clear().
2. Remove the incorrect characters from the stream. One way to do this is with cin.ignore().

Hello World

2011-06-09T15:10:00.000+05:30

One of the best ways to learn how to program in a new language is by looking at lots and lots of example programs. The best thing to do is to copy and paste each program below into a text file and compile it. Then, try the experiments. By extending these example programs, you will gain familiarity with different aspects fo C++, and you will feel more confident when it comes time to write programs from scratch.

// hello.cpp: Maggie Johnson
// Description: a program that prints the immortal saying "hello world"

#include <iostream>
using namespace std;

int main() {
 cout << "Hello World!" << endl;
 return 0;
}

Some experiments to try:

The most important thing is to make sure you can compile and run this program.

Converting a Resource Identifier

2011-06-01T16:54:00.002+05:30

An identifier is a constant integer whose name usually starts with ID. Although in Win32 programming you usually can use the name of a resource as a string, in MFC applications, resources are usually referred to by their identifier. To make an identifier name (considered a string) recognizable to an MFC (or Win32) function, you use a macro called MAKEINTRESOURCE. Its syntax is:

LPTSTR MAKEINTRESOURCE(WORD IDentifier);

This macro takes the identifier of the resource and returns a string that is given to the function that called it. In the strict sense, after creating the resource file, it must be compiled to create a new file that has the extension .res. Fortunately, Microsoft Visual C++ automatically compiles the file and links it to the application.

Creating a Resource

2011-06-01T16:53:00.002+05:30

Although an application can use various resources that behave independently of each other, these resources are grouped into a text file that has the .rc extension. You can create this file manually and fill out all necessary parts but it is advantageous to let Microsoft Visual C++ create it for you. To start creating the resources:

On the main menu, you can click Project -> Add Resource...
In the Solution Explorer, you can right-click the name of the project, position the mouse on Add, and click Resource...

Any of these actions would display the Add Resource dialog box. From this dialog box, you would select the type of resource you want and click New (or Import...). You will then be expected to design or customize the resources. Throughout our lessons, we will see various examples. After creating or designing a resource, you must save it. In most cases, you can try closing the resource. In this case, Microsoft Visual C++ would prompt you to save the resource. If you agree to do this (which you mostly should), Microsoft Visual Studio would create a new file with the extension .rc.

To make your resource recognizable to the other files of the program, you must also create a header file, usually called resource.h. This header file must provide a constant integer that identifies each resource and makes it available to any part that needs it. This also means that most, if not all, of your resources will be represented by an identifier.

Because resources are different entities, they are created one at a time. They can also be imported from existing files.

The Add Resource dialog box provides an extensive list of resources to accommodate almost any need. Still, if you do not see a resource you need and know you can use it, you can add it manually to the .rc file before executing the program.

If the Resource View is not visible, on the main menu, click View -> Other Windows -> Resource View.
In the Reource View, right-click Exercise1 -> Add -> Resource...
In the Add Resource dialog box, click String Table
Click New
Under the Type column header, click IDS_STRING101 and edit it to display IDS_ANNOUNCE and press Enter
To save, on the Standard toolbar, click the Save button
Close that window by clicking the Close button
In the Resource View, expand the Exercise1 node et notice the Exercise1.rc node

Overview

2011-06-01T16:52:00.002+05:30

In an MFC application, a resource is a text file that allows the compiler to manage such objects as pictures, sounds, mouse cursors, dialog boxes, etc. Microsoft Visual C++ makes creating a resource file particularly easy by providing the necessary tools in the same environment used to program. This means you usually do not have to use an external application to create or configure a resource file (as done in other programming environments).

The Command Line

2011-06-01T16:51:00.005+05:30

To execute a program, you must communicate its path and possibly some additional parameters to the compiler. This information is called the command line information and it is supplied as a string. You need to keep that in mind although all programs of our lessons will be compiled inside of Visual C++. The command line information is supplied to the compiler as the lpCmdLine argument of the WinMain() function. Internally, Visual C++ creates the path and communicates it to the compiler when you execute the program. If you want to find out what command line was used to execute your program, you can call the Win32's GetCommandLine() function. Its syntax is:

LPTSTR GetCommandLine(VOID);

This function takes no argument but returns the command line of an application as a null-terminated string.

A Window's Instance

2011-06-01T16:51:00.002+05:30

When you start an application such as Notepad, you are said to have created an instance of the application. In the same way, when you declare a variable of a class, an instance of the class is created and made available to the project. The WinMain() function also allows you to create an instance of an application, referred to as the hInstance argument of the WinMain() function. The instance is created as an HINSTANCE. The CWinApp class provides a corresponding instance variable called m_hInstance. This variable can let you get a handle to the instance of your application. Alternatively, to get a handle to the instance of your application, you can call the AfxGetInstanceHandle() global function. Its syntax is:

HINSTANCE AfxGetInstanceHandle();

Even more, to get a handle to your application, you can call the Win32 API's GetWindowLong() function. Suppose you have opened Notepad to view the source code of an HTML document. This is said that you have an instance of Notepad. Imagine that you want to open a text document using Notepad without closing the first instance of Notepad. To do this, you must open another copy of Notepad. This second copy of Notepad is another instance. In this case, the first instance is referred to as a previous instance. For a Win32 application, the previous instance would be the hPrevInstance argument of the WinMain() function. For a Win32 application, the hPrevInstance argument always has the NULL value. If you want to find out whether a previous instance of an application already exists, you can call the CWnd::FindWindow() method. Its syntax is:

static CWnd* PASCAL FindWindow(LPCTSTR lpszClassName, LPCTSTR lpszWindowName);

If you created the window or if it is a window you know for sure, in which case it could be a WNDCLASS or WNDCLASSEX object, specify it as the lpszClassName argument. If you do not know its name with certainty, set this argument as NULL. The lpszWindowName argument is the possible caption of the window you are looking for. Imagine you position a button on a dialog box and you want the user to launch Notepad with that button and imagine that, if Notepad is already opened, there would be no reason to create another instance of it.

The CWinApp class provides all the basic functionality that an application needs. It is equipped with a method called InitInstance(). Its syntax is:

virtual BOOL InitInstance();

When creating an application, you must override this method in your own class. This method is used to create an application. If it succeeds, it returns TRUE or a non-zero value. If the application could not be created, the method returns FALSE or 0. Here is an example of implementing it:

class CSimpleApp : public CWinApp
{
    BOOL InitInstance() { return TRUE; }
};

Based on your knowledge of C++, keep in mind that the method could also have been implemented as:

struct CSimpleApp : public CWinApp
{
    BOOL InitInstance()
    {
 return TRUE;
    }
};

or:

struct CSimpleApp : public CWinApp
{
    BOOL InitInstance();
};

BOOL CSimpleApp::InitInstance()
{
    return TRUE;
}

A Global Application Object

2011-06-01T16:50:00.003+05:30

To make your application class available and accessible to the objects of your application, you must declare a global variable from it and there must be only one variable of your application. This variable is of the type of the class derived from CWinApp. Here is an example:

class CSimpleApp : public CWinApp
{
};

CSimpleApp MyApplication;

As you can see, you can name this global variable anything you want. By tradition, in Microsoft Visual C++, this variable is named theApp. Here is an example:

CSimpleApp theApp;

To get a pointer to this variable from anywhere in your application, call the AfxGetApp() framework function. Its syntax is:

CWinApp* AfxGetApp();

To implement the role of the Win32's WinMain() function, the framework uses its own implementation of this function and the MFC provides it as AfxWinInit(). It is declared as follows:

BOOL AFXAPI AfxWinInit(HINSTANCE hInstance,
         HINSTANCE hPrevInstance,
                       LPTSTR lpCmdLine,
         int nCmdShow);

As you can see, the Win32's WinMain() and the MFC's AfxWinInit() functions use the same arguments.

The Framework

2011-06-01T16:50:00.000+05:30

Instead of creating an application using "raw" Win32 classes and functions, the MFC library simplifies this process by providing a mechanism called the framework. The framework is a set of classes, functions, and techniques used to create an application as complete as possible with as few lines of code as possible. To provide all this functionality, the framework works behind the scenes with the CWinApp class to gather the necessary MFC classes and functions, to recognize and reconcile the Win32 classes that the application needs. This reconciliation is also made possible by a set of global functions. These functions have names that start with Afx... Some of these functions are:

AfxFormatString1
AfxFormatString2
AfxMessageBox
AfxFreeLibrary
AfxGetApp
AfxGetAppName
AfxGetInstanceHandle
AfxGetMainWnd
AfxGetResourceHandle
AfxInitRichEdit
AfxLoadLibrary
AfxMessageBox
AfxRegisterWndClass
AfxSocketInit
AfxSetResourceHandle
AfxRegisterClass
AfxBeginThread
AfxEndThread
AfxGetThread
AfxWinInit

We will come back to some of these functions and we will see many other MFC macros in later lessons.

A Basic Application

2011-06-01T16:48:00.002+05:30

CObject, the Ancestor of All/Most MFC Classes

2011-06-01T16:47:00.000+05:30

To implement its functionality, the MFC is organized as a hierarchical tree of classes, the ancestor of which is CObject:

Although you can create C++ classes for your applications, most of the classes you will use throughout our lessons descend directly or indirectly from CObject.

The CObject class lays a valuable foundation that other classes can build on. Using the rules of inheritance, the functionality of CObject can be transparently applied to other classes as we will learn little by little. Some of the features that CObject provides are:

Performing value streaming for saving or opening the contents of files
Controlling dynamic creation and destruction of its inherited classes
Checking the validity of variables of classes, etc

You will hardly use CObject directly in your program. Instead, you may create your own classes that are based on CObject. Here is an example:

class CCar : public CObject
{
public:
    CCar();
    char *Make;
    char *Model;
    int Year;
    long Mileage;
    int Doors;
    double Price;
};

To make sure that this application uses MFC, on the main menu, click Project -> Properties...
In the left list, click Configuration Properties
In the right list, click User of MFC, click the arrow of its combo box and select Use MFC In A Shared DLL
Click OK

Introduction to MFC

2011-06-01T16:45:00.000+05:30

The Microsoft Foundation Class (MFC) library provides a set of functions, constants, data types, and classes to simplify creating applications for the Microsoft Windows family of operating systems.

On the main menu, click File -> New Project...
In the Project Types, click Visual C++
In the Templates list, click Win32 Project
Set the Name to Exercise1
Click OK
On the first page of the wizard, click Next
On the second page, accept Windows Application and click Empty Project
Click Finish

Introduction to Win32

2011-06-01T16:43:00.002+05:30

Win32 is a library made of data types, variables, constants, functions, and classes (mostly structures) that can be used to create applications for the Microsoft Windows family of operating systems. A typical application is made of at least two objects: a control and a host object on which the control is positioned.

To create a Win32 application using Microsoft Visual C++:

On the Start Page, you can click New Project
On the main menu, you can click File -> New Project...
On the Standard toolbar, you can click the New Project button
You can press Ctrl + N

Any of these actions would display the New Project dialog box. From there, select Win32 Project item.

Just like a C++ program always has a main() function, a Win32 program uses a central function called WinMain. The syntax of that function is:

INT WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    LPSTR lpCmdLine, int nCmdShow );

To support international characters, Microsoft Windows provides another version of this function named _tWinMain. This version uses the same syntax (same arguments) as the first.

Unlike the C++'s main() function, the arguments of the WinMain() function are not optional. Your program will need them to communicate with the operating system. Here is an example of starting a program with the WinMain() function:

#include <windows.h>

INT WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
                   LPSTR lpCmdLine, int nCmdShow )
{ 
    return 0;
}

Adding Classes

2011-05-31T16:40:00.001+05:30

To add a class to your project, you have various options. You can separately create a header file then create a source file. You can also import an existing header file and a source file from any valid path. Microsoft Visual C++ makes it easy to create a C++ class. When doing this, a header and a source files are prepared. A (default) constructor and a destructor are added. You can delete or completely change the supplied constructor and/or the destructor. Also, Microsoft Visual C++ includes the name of the header file in the source file so you would not have forgotten to do this. Most classes in Microsoft Visual C++ have their names starting with the letter C. Although this is only a suggestion, and any valid class name would work fine, to keep some harmony, in our lessons, we will follow this convention.

To create a new class and add it to your project:

On the main menu, click Insert -> Add Class...
In the Class View, right-click the name of the project, position the mouse on Add, and click Class...

Any of these actions would open the New Class dialog box. From there, you can specify the type of class you want to create and click Open. You will then be asked to provide a name for the class.

Adding Existing Files to a Project

2011-05-31T16:39:00.002+05:30

If a file had already been created and exists on a separate folder, drive, directory or project, you can import it and add it to your application. When you decide to add an existing file to a project, because Microsoft Visual Studio allows you a great level of flexibility on the types of files you can add, it is your responsibility to check that the file is valid.

If you copy a file from somewhere and paste it in the folder that contains your project, the file is still not considered as part of the project. You must explicitly add it. Before adding an existing file to your project:

On the main menu, you can click File -> Add Existing Itemﾃδ｢ﾃ｢窶堋ｬﾃつｦ
On the main menu, you can also click Project -> Add Existing Itemﾃδ｢ﾃ｢窶堋ｬﾃつｦ
In the Solution Explorer, you can right-click the name of the project, position your mouse on Add and click Add Existing Itemﾃδ｢ﾃ｢窶堋ｬﾃつｦ

Any of these actions would open the Add Existing Item dialog box. This requires you to locate the item and select it. Once the item is ready, to add it to the project, click the Open button. If you want to open it first, click the arrow of the Open button and specify how you want to open the file.

Creating a File

2011-05-31T16:39:00.000+05:30

Although the most popular files used in Microsoft Visual C++ are header and source files, this IDE allows you to create various other types of files that are not natively C++ types.

To create a file, if a project is currently opened:

On the main menu, click Project -> Add New Item... This would open the New dialog box from where you can select the desired type of file and click Open. By default, the new file would open in the Source Code Editor. If you want to open the file otherwise, after selecting it in the New dialog box, click the arrow of the Open As combo box.
In the Solution Explorer or the Class View, right- click the name of the project, position the mouse of Add, and click the option you want

Practical Learning: Creating a Microsoft Visual C++ Project

2011-05-31T16:37:00.002+05:30

Start Microsoft Visual Studio
On the main menu, click File -> New Project...
In the New Project dialog box, in the left list, click Visual C++.
In the right list, click Win32 Console Application
In the Name edit box, type IntroductionToMFC1
Click OK
In the Win32 Application Wizard, click Finish

Creating a New Project

2011-05-31T16:37:00.000+05:30

Introduction to Microsoft Visual C++/MFC

2011-05-31T16:33:00.000+05:30

Microsoft Visual C++ is a programming environment used to create applications for the Microsoft Windows family of operating systems. To use these lessons, you must have installed either Microsoft Visual Studio 2010. Although Microsoft Visual Studio 2010 Professional provides many programming environments for the price of one, in our lessons, we will use it but we will cover only the Microsoft Foundation Class (MFC) library side.

After installing it, to use the programming environment, you must first open it. To do that, you would click Start -> (All) Programs -> Microsoft Visual Studio 2010 -> Microsoft Visual Studio 2010.
In our lessons, unless used in code, the -> arrow means an action that should follow another. Based on this:
Edit -> Copy means click Edit, then click Copy
View -> Toolbars -> Custom means click View position the mouse on Toolbars, and then click Custom

To start Microsoft Visual C++ or Visual Studio, on the Taskbar, click Start (All) Programs -> Microsoft Visual Studio 2010 -> Microsoft Visual Studio 2010

After Microsoft Visual Studio has been opened, the screen you get is called an Integrated Development Environment or IDE. The IDE is the set of tools you use to create a program.

The title bar is made of three section. The left section shows the system icon. The system icon is used to identify the application that you are using. Almost every application has its own system icon. The system icon holds its own list of actions; for example, it can be used to move, minimize, maximize or close (when double-clicked) a window.

The middle section of the title bar displays Microsoft Visual Studio. This starting title displays in the beginning until you decide to create a particular type of application, then the title changes. You will experience it once we start some programming assignments. The middle section of the title bar can be also used to move, minimize, maximize the top section of the IDE, or to close Visual Studio. You can perform these actions by right-clicking the title bar and selecting from the menu.

The right section of the title bar shows three system buttons:

Button			Role
			Minimizes the window
			Maximizes the window
			Restores the window
			Closes the window

The main menu under the title bar is used to perform all types of actions on the IDE. In our lessons:

The expression "main menu" refers to the menu in the top section of the IDE
MSVC means Microsoft Visual C++.

A toolbar is an object made of buttons. These buttons provide the same features you would get from the main menu. Under the main menu, the IDE is equipped with a Standard toolbar used to create a new project, open a file, save a project, etc

Besides designing applications, one of your most regular jobs will consist of writing code that directs the computer as to what to do, when, and how to do it. This is done in an appropriate window called the Code Editor.

The Code Editor is a feature-rich text editor programmed to recognize the parts of a program that belong to C++ or not. The Code Editor manages your jobs by organizing its files into labels or tabs. If your project contains more than one file, you can click the desired tab to access one of the files.

The basic building block of a program is called a C++ file. Whenever you create a new project, the Microsoft Visual Studio programming environment creates various files, such as header files and source files. To display a header file, you can double-click its name in the Class View. Since the source and the header file go in pair (when using classes), they hold the same name but have different extensions.

A toolbar is an object made of buttons. These buttons provide the same features you would get from the (main) menu, only faster. Under the main menu, the Integrated Development Environment (IDE) is equipped with the Standard toolbar.

By default, when you start Microsoft Visual Studio, it is equipped with one toolbar: Standard. To get more toolbars, on the main menu, you can click View -> Toolbars and click the toolbar of your choice. You can also right-click any available toolbar or the main menu. This displays a list of all the available toolbars. Those that are currently opened have a check mark next to them.

A toolbar is equipped with buttons. To know what a button is used for, you can position the mouse on top of it. A tool tip will come up and display for a few seconds. In our lessons, each button on any toolbar will be named after its tool tip. This means that, if a tool tip displays "New", its button will be called the New button.

Microsoft Visual Studio's menus and toolbars can be customized. You can customize a menu category on the main menu by adding a menu item to it. You can customize a toolbar by adding a button to it. To start, right-click anything on the main menu or on any toolbar and click Customize... For example, imagine you want to add an item named Start Without Debugging so that it would let you easily execute your projects and you want to add its button to the Standard toolbar, and imagine you want to position it on the left side of the Start button:

To proceed:

You can right-click any button on any toolbar or right-click the main menu and click Customize
On the Customize dialog box, click the Commands tab
Click the Toolbars radio button
In the right combo box, select the toolbar to which you want to add a button. In this case, that would be Standard
In the Controls list, click the button that will succeed the one you want to add. In this case, this would be Start / Continue:
In the right list, click Add Command
In the Add Command dialog box, in the Categories list, select the category that has the button you want
In the Commands list, click the button or menu item you want. For our example, that would be Start Without Debugging

i) After makiing the selection, click OK

On the Customize dialog box, click Close:

In the same way, you can customize any toolbar and any menu category.

While working on your projects, you will usually need to figure out how something can be done and sometimes why it is done like that. There are three primary types of help you can use: online, MSDN, and others.

When Microsoft Visual Studio gets installed, it asks you whether you want to install the MSDN library. This is because it ships with a DVD that contains online help files. If you decide to install the MSDN library, it would be installed as an independent program but would be internally linked to Microsoft Visual Studio.

To get help while you are working on a project, click the item, keyword, or class, etc and press F1. The browser Help window would display help on the topic:

Links

2011-05-31T16:29:00.001+05:30

Official resources
MSDN
Visual C++ Home
microsoft.public.vc.language

The Top
CodeGuru
CodeProject
DeveloperFusion.com
C/C++ Users Journal
RSDN (RU)
First Steps (RU)
Sources.ru (RU)

Tricks, Tips, FAQs
Bjarne Stroustrup's C++ Style and Technique FAQ
CodeGuru FAQ
C++ FAQ Lite by Marshall Cline
CodeProject Forum FAQ
Boob Moore's page (Win32, NT, MFC)
Edelmiro Fuentes's page
http://www.sources.ru/cpp/cpp_vcpp_faq.shtml (RU)
Akzhan Site (RU)

Forums, newsgroups
CodeGuru Forum
microsoft.public.vc.language
comp.lang.c++
RSDN Forum (RU)

Libraries, Components, Add-ons, Add-ins
Boost Libraries #1 for C++!
TinyXML - light yet powerful XML library. Forget about MSXML! :)
Whole Tomato Software: Code syntax highlighting
Compuware corporation: BoundsChecker, SoftICE etc.
Xtreme ToolkitPro - Industry leading Visual C++ MFC UI controls.
STL Error Decryptor
UCanCode: XD++ MFC Class Library for Diagrams
Regular Expression Library

Disk File Systems
NTFS (RU)

Serial Communication
Serial Communications in Win32, MSDN
CSerialPort - Serial Port Wrapper
COM port monitor
COM ports in Win32 (RU)

File formats
WOT IS IT

Win32 and HTML Help Development
Microsoft HTML Help Workshop
HTML Help Center
Web Design Group (HTMLHelp.com)

Books and Tutorials
Thinking in C++ 2nd Edition by Bruce Eckel
C++ programming
Resources on the Web
W3Schools
SoftCraft (RU)
Free books to download (RU)

Application Development Articles
IBM Rational Library

OTHER TOPICS

WIN NT/2K Registry Tips
JSI Inc.

Installers
Inno Installer
Nullsoft Scriptable Install System

Data Recovery
Data Recovery. Montreal, QC, Canada

Link to Links
Google Directory links
ScriptSearch.com