xiaobin_hlj80

https://www.functionx.com/visualc/Lesson02.htm

OS: Windwos 10 1809(LTSC)

Any of these actions would display the New Project dialog box from where you can select the type of project you want.

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

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

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???￠?￠a€??????|
• On the main menu, you can also click Project -> Add Existing Item???￠?￠a€??????|
• In the Solution Explorer, you can right-click the name of the project, position your mouse on Add and click Add Existing Item???￠?￠a€??????|

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.

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.

To open a file:

• On the main menu, click File -> Open File...
• Press Ctrl + O

If you had previously created or opened a file, Microsoft Visual C++ keeps a list of the most recently used (MRU) files under the File menu. To control the maximum number of files that can be listed, on the mein menu, click Tools -> Options. In the left list of the Options dialog box, click Environment and click General:

After specifying the desired value, click OK.

A project is made of various files and subject to the environment in which it was created. A project itself is a file but it is used to "connect"???? all the other files that compose its particular application.

There is a limit on the types of projects you can open in Microsoft Visual Studio. This is not an anomaly. Every computer-programming project is created using a particular environment and each environment configures and arranges its project as its judges it necessary. Any attempt to open an unrecognizable project would produce an error.

Microsoft Visual Studio is configured to easily open various types of projects. To open a project:

• If you have just used one of a certain number of projects
  • On the Start Page of Microsoft Visual Studio, click its name
  • On the main menu, click File, position the mouse on Recent Projects and Solutions, and click the name of the project
• On the main menu, click File -> Open Project... Locate the folder that contains the project, select it and click Open

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;
}

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.

1. On the main menu, click File -> New Project...
2. In the Project Types, click Visual C++
3. In the Templates list, click Win32 Project
4. Set the Name to Exercise1

1. Click OK
2. On the first page of the wizard, click Next

On the second page, accept Windows Application and click Empty Project

1. Click Finish

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;
};

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

• Give a name to the file
• To create a source file, click C++ File (.cpp)

• Give a name to the file

After naming the file, click Add.

After generating the files, you can use them following rules and suggestions of the C++ language. For example, you can create the layout of a class in the header file and define it in the source file.

As you know from your knowledge of C++, you can create a stand-alone class or derive one from another existing class. Microsoft Visual Studio provides all the necessary tools to visually create or derive a class. To create a class:

• On the main menu, click Project -> Add Class...
• In the Solution Explorer, the Class View, or the Resource View, right-click the name of the project -> Add -> Class...

Any of these actions would open the Add Class dialog box:

Make sure C++ Class is selected and click Add. This would open the Generic C++ Class Wizard. The wizard presents many options:

• In the Class Name text box, enter the name of the intended class. By convention (or pure habits), the names of classes in the MFC library and/or MFC-based applications start with C (this is not a rule or an obligation; just a valuable suggestion):

• Since the new class will use a destructor, if you want that destructor to be virtual, click the Virtual Destructor check box
• By default, the wizard will create a header file (.h) and a source file (.cpp). If you want the whole class to be created in only one file, click the Inline check box

Once you are ready, click Finish. If you specified that you are deriving a class, when you click Finish, the wizard would look for the base class, first in the current project, then in the libraries (if any) referenced in the project. If the wizard doesn't find the parent class, it would display a message box. Here is an example:

If know for sure that the class exists or you will create it later, click Yes. If you click, you will be given the opportunity of rectifying.

Here is an example of deriving a class from CWinApp:

class CSimpleApp : public CWinApp
{
};

Because the CWinApp class is defined in the AFXWIN.H header file, make sure you include that file where CWinApp is being used.

1. In the Solution Explorer, right-click Source Files, position the mouse on Add, and click New Item...
2. In the Templates lists click C++ File (.cpp)
3. Set the Name to Exercise

1. Click Add
2. In the empty document, type the following:
   

   #include <afxwin.h>
   
   class CExerciseApp : public CWinApp
   {
   };

After creating a class, you can manage it. Microsoft Visual C++ provides various tools to assist you. Managing a class consists of accessing its file(s), adding member variables, and adding methods.

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.

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.

• Declare a global variable as follows:
  

  #include <afxwin.h>
  
  class CExerciseApp : public CWinApp
  {
  };
  
  CExerciseApp theApp;

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;
}

1. In the class, implement the InitInstance method as follows:
   

   #include <afxwin.h>
   
   class CExerciseApp : public CWinApp
   {
       BOOL InitInstance()
       {
   	return TRUE;
       }
   };
   
   CExerciseApp theApp;

2. Save the file

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.

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).

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.

1. 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...
2. In the Add Resource dialog box, click String Table

LPTSTR MAKEINTRESOURCE(WORD IDentifier);