How to Learn Visual C++ : VC++ Tutorial

Longer Programs

2009-05-26T02:10:00.000-07:00

Even long C++ programs are fairly easy to follow when you use whitespace and break long programs into a series of smaller functions.

The sample program shown earlier is extremely simple. Some Visual C++ programs require several hundred thousand lines of code. Budding authors would not tackle a sequel to War and Peace; likewise, brand-new Visual C++ programmers should stay away from huge programming projects. Most of the programs you write for a while will be relatively small, maybe only 10 to 100 lines of code.

Even a large program usually is not one big program stored in one file on the disk. Programmers often break up large programs into a set of smaller programs. The smaller programs work like building blocks, fitting together as needed to handle some kind of programming application.

Just to give you another early view of a Visual C++ program, here is a program longer than the one you saw earlier. Don't sweat the specifics yet. Glance over the program and start getting used to the variety of special characters that Visual C++ understands.

// Filename: 1STLONG.CPP  // Longer C++ program that demonstrates comments,  // variables, constants, and simple input/output  #include   void main()    {      int i, j;    // These three lines declare four variables      char c;      float x;      i = 4;       // i is assigned an integer literal      j = i + 7;   // j is assigned the result of a computation      c = 'A';     // Enclose all character literals                   // in single quotation marks      x = 9.087;   // x is a floating-point value      x = x * 12.3;// Overwrites what was in x                   // with something else      // Sends the values of the four variables to the screen      cout <<>

The next few lessons discuss the commands in this program in depth. Again, just to give you an idea of the importance of readability, here is the same program as seen by the Visual C++ compiler, but a very different program indeed to someone who must maintain it later:

//Filename: 1STLONG.CPP//Longer C++ program that demonstrates  //comments, variables, constants, and simple input/output  #include   void main(){int i,j;//These three lines declare four variables  char c;float x;i=4;// i is assigned an integer literal  j=i+7;//j is assigned the result of a computation  c='A';//Enclose all character literals//in single quotation marks  x=9.087;//x is a floating-point value  x=x*12.3;//Overwrites what was in x with something else  //Sends the values of the four variables to the screen  cout<

Longer programs don't have to be harder to read than shorter ones.

Uppercase and Lowercase

2009-05-25T02:09:00.000-07:00

C++ is extremely picky about your Caps Lock key. Most of a C++ program appears in lowercase letters.

Although Visual C++ cares little about whitespace, it does know the difference between uppercase and lowercase letters. Most of the time, Visual C++ prefers lowercase letters. Visual C++'s preference for lowercase letters sets it apart from most other programming languages. To many programming languages, the following statements are identical:

if (netpay > grosspay)  If (NetPay > GrossPay)  IF (NETPAY > GROSSPAY)

To Visual C++, the three lines are extremely different. As you learn the C++ language, you will see when to use lowercase and when to use uppercase. Again, most of the time, you will program in lowercase letters.

Visual C++ contains a fixed vocabulary of keyword commands (also referred to as reserved words). Appendix D contains a complete list of Visual C++ commands. A command is part of the limited vocabulary that Visual C++ recognizes. For example, the command that transmits a value from one place in the program to another is return. You must use lowercase letters for return, as well as for all the other commands in Visual C++.

Refer to Appendix D, "Visual C++ Command Reference," often as you learn the commands of Visual C++, especially the specific commands beginning in Lesson 3, "Data Basics."

If you want to print messages to the screen or to your printer, you can use uppercase, lowercase, or a mixture of both for the message itself. For example, recall that the program shown earlier printed this message to the screen:

I will be a C++ expert!

Because this is a message for the user of the program to read, you would want Visual C++ to print it using regular uppercase and lowercase characters. Because the message is not a keyword, it does not have to be all lowercase.

Before you go any further, a short review of the previous sections is warranted. Visual C++ is picky about lowercase commands and about making sure that you type special characters exactly right. Whitespace, however, is another thing entirely. Visual C++ does not care how much whitespace you add to a program for readability.

For and for are two different words to C++. Be sure to maintain consistency with uppercase and lowercase letters. C++'s preference is usually lowercase letters.

VC++ Programm Analysis

2009-05-24T02:25:00.001-07:00

In this lesson, you learned about the fundamental format of all C++ programs. You saw the following:

Visual C++ programs contain a main() function.
Braces determine where the main() function begins and ends.
Preprocessor directives direct the way Visual C++ compiles your program. Preprocessor directives always begin with a pound sign, #. The #include directive includes files needed by library functions.
Visual C++ comments begin with // and end at the end of the line. Comments are for people, not for Visual C++.
The cout command outputs data to your screen.
All characters are important in Visual C++ programs.

Project 2 Listing. Introduction to Visual C++ programs.

1:  // Filename: PROJECT2.CPP  2:  // Introduces the format of Visual C++ programs and demonstrates  3:  // how to write Visual C++ comments, the #include preprocessor  4:  // directive, and the cout command that outputs data to the  5:  // screen.  6:  7:  #include   8:  9:  void main()  10:  {  11:    cout << "I have a ";  12:    cout << "Sleekster";       // Continues the output line  13:    cout << " automobile.";      14:    cout <<>

Description

1: A Visual C++ comment that includes the program's filename.

2: A comment that begins the introduction of the program's description.

3: The program's description continues.

4: The program's description continues.

5: The program's description continues.

6: Extra blanks make your program more readable.

7: The cout command needs information in the IOSTREAM.H header file.

8: Extra blanks make your program more readable.

9: All functions have names and the first function in all Visual C++ programs is main().

10: All functions begin with a left brace.

11: The screen output begins.

12: The car's model name prints. No new line occurs.

13: Finish the output.

14: Move the cursor down two lines.

15: Extra blanks make your program more readable.

16: Another message prints.

17: cout prints all kinds of data. Strings and an integer output here.

18: This cout outputs strings and a character literal.

19: Statements can be more than one line.

20: Extra blanks make your program more readable.

21: The final return; in main() always returns control back to Visual C++'s QuickWin window

22: A closing brace always terminates the main() function.

7: The compiler inserts a helpful file here.

10: void means that main() does not return a value to the operating system.

14: endl sends a new line command to the screen.

Output

I have a Sleekster automobile.  I want to sell my car for $4800 (cheap!).  I have had the car for 5 years.  It's really a grade-A deal!

VC++ Programm Structure

2009-05-24T02:11:00.001-07:00

The starting point for C++ programs is the main() function. The previous units showed you some Visual C++ programs. If you look them over, you will see the word main() in every one of them. Looking further still, you will see an opening brace after main() and a closing brace a little later. You never find an opening brace (a left brace) without a closing brace (a right brace).

Visual C++ programs also share another trait: Almost all of them have one or more lines that begin with the # (pound sign) character, followed by include. Figure 4.1 shows a simple outline of a Visual C++ program.

Figure 4.1. An Outline of a simple C++ program

Notice that there is a closing brace for every opening brace? There is also a closing parenthesis for every opening parenthesis and a closing bracket for every opening bracket that appears in a program. The parentheses, braces, and brackets enclose language elements within the Visual C++ program. As with parentheses in written languages, these Visual C++ symbols enclose pieces of a program, and you must indicate with the closing character where the piece ends. Unlike a written document, the meaning of parentheses, braces and brackets are quite distinct in C++ and each must be used in the correct way.

Before you know it, you will be comfortable with main(), #include, braces, and all the other parts of a Visual C++ program. The next section looks at a longer Visual C++ program and dissects pieces of it to ease you into Visual C++.

Being able to understand main(), #, and braces is your first step in understanding Visual C++.

There is no Stop and Type part here due to the textual nature of this section.

Dissecting a Program

Look at the specific parts of a typical Visual C++ program to acquaint yourself with the code.

The next few pages provide a closer examination of the program in Listing 4.1. The idea is to give you a look at the big picture before getting into the specific language elements starting in Lesson 3.

Listing 4.1. A sample Visual C++ program.

// Filename: DISSECT.CPP  // Simple program for you to analyze  #include   void main()    {      int age, weight;   // These lines define four variables      char initial;      float salary;      age = 13;          // Assigns an integer literal to age      weight = age * 6;  // Assigns a weight based on a formula      initial = 'D';     // All character literals are                         // enclosed in single quotes      salary = 200.50;   // salary requires a floating-point                         // value because it was defined to                         // be a floating-point      salary = salary * 2.5; // Changes what was in salary  // Next line sends the values of the variables to the screen      cout <<>

Keep in mind that this program is simple and does not actually perform a lot of valuable work. Despite its simplicity, you might not fully understand it all even after the explanation that comes next, but it is a good place to begin.

While looking through the program, see whether you can understand any or all of it. If you are new to programming, you should know that the computer reads each line of the program, starting with the first line and working its way down, until it has completed all the instructions (the statements on each line) in the program. (Of course, you first have to compile and link the program, as described in Lesson 1, before seeing the output from the program on your computer.)

Here is the output that results when you run this program:

13, 78, D, 501.25

The Program

After the previous unit, you know all about the first two lines in the program. They contain comments that describe the filename and a little about the program. Comments also are scattered throughout the code to explain what happens along the way.

The next line is called a preprocessor directive. It is repeated here:

#include

This strange-looking statement is not actually a Visual C++ command, but it is a directive to the Visual C++ compiler. The directive directs the compiler (that is easy to remember). #include tells Visual C++ to take the filename located inside the angled brackets and load that file into the Visual C++ program at that point. In principle, the preprocessor first reads all the code looking for any lines beginning with a # symbol and acts upon them before compilation takes place. In the case of an #include, the compiler will view the program as if you had typed the contents of the file directly into the program file. In other words, the program grows to become the size of DISSECT.CPP (the program shown in the preceding section) plus IOSTREAM.H. Most files included with #include end in the .H filename extension because these files are header files.

The header file named IOSTREAM.H comes with your Visual C++ compiler. Header files are a way of telling your program about pieces of code that it needs that are extra to the C++ language. Recall that cout was not part of the C++ language. The header file contains the information that lets the compiler know that cout is a function and not just a made up word. The include files are located in your Visual C++ directory in a subdirectory called INCLUDE. If you want to include a file you wrote (all #include files must be text, such as those created with the Visual C++ editor), you have to put the included filename in quotation marks, like this:

#include "d:\myFiles\mine.h"

You might see other header files included, either in addition to IOSTREAM.H or in place of it. Sometimes, Visual C++ programmers use a C program that includes the header file named STDIO.H instead of IOSTREAM.H. Notice in Appendix D, "Visual C++ Command Reference," that #include is not listed with all the other Visual C++ commands. #include is not a Visual C++ command; it is simply a pre-command (hence its name, preprocessor directive) that directs the compiler to do something before it compiles the actual commands. In this case, #include tells Visual C++ to include a file from disk at that point in the program.

Braces and main()

You see these two lines in all of the Visual C++ programs in this book:

void main()  {

The void always goes with main(). Treat the following text as saying void main(). We'll worry about what void means much later on.

main() does not always appear toward the top of the program, as it does here. Sometimes main() appears farther down into the code. Wherever main() is, however, it begins the most critical section of any Visual C++ program. When you run the program, the program always begins executing at main(). No matter where main() is located in the program, it is the starting point for the program's execution. Therefore, it makes sense to put main() toward the top of a program. Sometimes, however, a lot of other stuff has to go before main(). No matter what appears before main(), main() begins the program's execution when you run the program.

Not all programs written in C++ use main() as the starting point. You will not find a main() in a Windows program. Windows programs use WinMain() because Windows programs work in a way very different from ordinary programs.

main() is called a function. A function is not a command. It is a named section of a program, and its name always ends with a pair of parentheses. A program can have one function or many functions, but every program contains the main() function because the program has to begin somewhere. You can always tell where a function begins because functions always have names that end with parentheses. The parentheses tell Visual C++ that main() is a function and not a command or something else.

None of the commands in Appendix D contain parentheses. Parentheses are part of function names, but they are never part of command names.

Because an opening brace follows main(), you can look for the matching closing brace (they always appear in pairs) and find out where main() ends. Every pair of braces in a Visual C++ program encloses something known as a compound statement. In this case, the compound statement is almost as long as the main() function. The next function—if there were one—could go after main()'s closing brace. You can never define a function inside another one. main() must finish before another function can begin being listed in the program.

A statement ends in a semicolon. A compound statement is made up of a sequence of statements. A compound statement can be used anywhere that a single statement can be used. A compound statement does not need a semicolon following it. A compound statement is often called a block.

Before you get too sidetracked, you are going to become extremely comfortable with the fact that main() is a function and that braces enclose blocks in a program. Read on to learn more about the rest of this sample program named DISSECT.CPP. There are more important aspects to the program at this stage in the game than fully understanding main().

The void before main() is required in simple Visual C++ programs that do not return values to the operating system. You will learn more about void in Lesson 7, "Break it Up With Functions."

Data

Here are the three lines that follow main()'s opening brace:

int age, weight;   // These lines define four variables  char initial;  float salary;

definition

A variable is a named value that holds data that can be changed.

These three lines define four variables. A variable definition tells Visual C++ exactly what variables will be used in the lines that follow. This variable definition tells the compiler to make room in memory for four values, label them with names, and get ready to use them. Later in the program, values will be stored in those variables.

definition

A constant is a value that cannot be changed but can be named.

definition

A literal is an actual constant value stated in the program.

All Visual C++ programs contain both commands and data. The data is always made up of one or more variables, one or more literals, or a combination of both. A literal is sometimes called a constant, but in Visual C++, the word constant actually has another meaning (in most languages, literal and constant are synonymous).

As the name implies, a variable is data that can change (become variable) as the program runs. A constant remains the same. In real life, a variable might be your salary. It increases over time (you hope). A constant is something that does not change, such as the number of days in February or the fact that Pi is 3.14159.

A variable is like a box inside your computer that holds something. That something might be a number or a character, a value of another variable, or the result of a calculation. Every variable within the same block is distinguished from others by its unique name. No two variables within the same block can have the same name. You can have as many variables as needed to hold changing data. After you define a variable and give it a value, the variable keeps its value until you change the value or define the variable with something else by putting some other data value into it. The next lesson more fully explains these concepts.

The three lines of code that follow the opening brace define four variables. The variable definition informs the rest of the program that two integer variables named age and weight, as well as a character variable named initial and a floating-point variable named salary, appear throughout the program. The terms integer, character, and floating-point basically refer to different types of data. Integers are whole numbers, and floating-point numbers contain decimal places.

Just as there are different types of variables, there are different types of constants. The first form of constant you should know is a literal. For now, you simply have to understand that a Visual C++ literal is any number, character, word, or phrase whose value is explicitly written when it is used and does not change as the program runs. The following are all valid Visual C++ literals:

5.6  -34  'W'  "Mary"  18.293345  0.0

As you can see, some literals are numeric and some are character-based. The single and double quotation marks around two of the literals, however, are not part of the actual literals. A single-character literal requires single quotation marks around it, and a string of characters such as "Mary" requires double quotation marks (often called just quotation marks).

The body of the DISSECT.CPP program (repeated next) assigns values to the defined variables.

age = 13;                // Assigns an integer literal to age  weight = age * 6;        // Assigns a weight based on a formula  initial = 'D';           // All character literals are                           // enclosed in single quotes  salary = 200.50;         // salary requires a floating-point                           // value because it was defined to                           // be a floating-point  salary = salary * 2.5;   // Changes what was in salary

The first line puts 13 in the integer variable, age. The second line multiplies 6 by the variable age's value to produce the value 78, which is stored in weight. The multiplication sign (*) in Visual C++ works just as an x does in mathematics. The other primary math operators are shown in Table 4.1.

Table 4.1. The primary math operators.

Operator	Meaning	Example
+	Addition	4 + 5
-	Subtraction	7 - 2
*	Multiplication	12 * 6
/	Division	48 / 12

Use an asterisk (*) for multiplication and not a lowercase x. The computer would confuse the variable name x with the multiplication symbol x if both were allowed.

When mathematical operators appear on the right side of an equal sign, the program completes the math before assigning the result to a variable. In the statement

salary = salary * 2.5;   // Changes what was in salary

the multiplication of salary and 2.5 is performed, and then the result is stored in salary.

Visual C++ follows math rules by calculating multiplication and division before it calculates any addition and subtraction if a combination appears within the same expression. Therefore, the following produces a result of 8, not 10, because C++ multiplies first, even though addition appears to the left. Lesson 4, "Simple Operators," explains math ordering further.
result = 2 + 3 * 2;   // Stores an 8 in result

Assigning Values to Variables

Use an equal sign (=), called the assignment operator, to put values into variables. The statement

age = 13;   // Assigns an integer literal to age

puts the literal 13 into the variable named age.

Think of an equal sign as working exactly as a left-pointing arrow would. The value on the right of the equal sign moves left into the variable on the left of the equal sign. If there is a formula on the right, Visual C++ computes the answer and moves the answer into the variable on the left side of the equal sign.

In Listing 4.1, you find the following variables:

age  weight  initial  salary

Because age is an integer, you should put only integers into it.

A variable must hold a value that matches the variable's type.

Output to the Screen

The line that begins with cout (pronounced "see-out") at first looks very confusing:

cout <<>

When the program reaches this line, it prints the contents of the four variables on-screen.

The output from the line is

13, 78, D, 501.25

Because there are no other output statements in the program, this line is the only line that produces something you can see when you run the program. The rest of the program either sets up the code (such as main() and the braces) or performs internal data manipulations (such as assigning values to variables).

cout is not a Visual C++ command, but it acts a lot like one. You will not see cout in Appendix D. cout has no built-in input or output commands. cout is a C++ class, described in the header file IOSTREAM.H. You will learn about classes much later on, but you'll make use of this class earlier because it is so easy to use. cout sends output to an output device, which is usually the screen. There is a special value you can send to cout called endl, which will send a command to start a new line to the screen.

You can guess at cout's purpose just by looking at the line with cout. The data values are being sent via the double angled brackets (<<)to the cout device. The values following cout go to the screen in the left-to-right order in which they appear. The opposite of cout is cin. cin gets keystrokes from the keyboard. Can you see that the following statement gets a number from the keyboard and stores it in the location called amount?
cin >> amount;

You have seen that there are two parts to a program: the commands that the program executes, and the data that a program works on. Commands come in two forms: the C++ keywords that the compiler understands implicitly, and extra commands that the compiler can be made to understand with the use of header files.

Returning to the Operating System

As soon as your Visual C++ program finishes executing, it should return to the operating system so that another program can be run. The return statement at the end of main() ensures that the program returns to the operating system. return is optional when the function is preceded by void, so you do not have to use it for simple returns from functions such as main().

The closing brace after the return does two things in this program. It signals the end of a block (begun earlier with the opening brace), which is the end of the main() function, and it signals the end of the program.

Figure 4.2 repeats the entire program listing with some callouts that label the various parts of the program.

Figure 4.2. The structure of the simple C++ program.

Familiarize yourself with the overall look and feel of this program. It helps to see an overview before diving straight into the specifics of the commands. Now that you have a general understanding of the format of Visual C++ programs, you are ready to tackle the language elements. Good luck with your venture into the world of the Visual C++ language particulars, beginning in the next lesson, "Data Basics."

Until now, there was no way to present you with an end-of-section Stop and Type analysis because you did not know enough about Visual C++ to see one. From now on, you'll see Stop and Type, Review, Input, Output, and Analysis parts at the end of each section in each unit. You should ignore the line numbers (the numbers followed by colons at the start of the lines). These are not part of the code and are provided simply to allow easy reference to parts of the code.

Listing 4.2 contains another Visual C++ program that you can study in order to find the common elements mentioned in this unit.

All C++ programs have similarities. Their structure is the same even though they often do very different work.

Listing 4.2. A Visual C++ program for review.

1:  // Filename: VARS.CPP  2:  // All programs share common traits  3:  4:  #include   5:  6:  void main()  7:  {  8:    char c;             // Define all variables before  9:    int i;              // you use them  10:    float f;  11:  12:    // The next few lines store literal values  13:    // in the three variables just defined  14:    c = 'W';  15:    i = 64;  16:    f = 12.57;  17:  18:    // Print the values  19:    cout << "c is " <<>

Output

c is W, i is 64, f is 12.57

Analysis

Lines 1 and 2 are comments that describe the program's filename and a one-line statement about the program. Line 4 is a preprocessor directive that includes a file needed by the rest of the program. For the time being, include this file in all your Visual C++ programs. Later lessons will explain it in more detail.

You'll find several blank lines scattered throughout the code, such as lines 3, 5, and 11. Visual C++ ignores the blank lines, but the whitespace helps you read the program.

All programs have a main() function. You can always tell when a word in a C++ program is a function because of the parentheses that follow the name. All functions open with an opening left brace as shown in line 7. The matching right brace, and therefore the main() function, does not end until line 24.

Not all programs in this book will begin with void preceding main(). Until Lesson 7 explains how and when to use void, follow this book's lead: Use it when you see it, and don't use it when you write your own programs until you understand what void is all about.

Lines 8, 9, and 10 define three variables of three data types. The next lesson explains variables and data types in lots of detail. The important thing to note here is that you must define all variables before you use them. When you define the variables as done in lines 8 through 10, you tell C++ that you want those variables created.

Lines 14 through 16 put values in the three variables defined earlier. Until you put values in variables, you should not use those variables. Unlike some other programming languages, C++ does not place zeros in variables before you use them. Therefore, they will contain garbage or random values.

Lines 19 and 20 are actually one single C++ statement that takes two lines. The cout produces the output shown after the program listing.

You will understand all of these program details as you progress in this book. For now, try to get familiar with these concepts and see whether you can learn to spot common elements across C++ programs.

The Syntax of Visual C++ Comments

2009-05-24T02:11:00.000-07:00

Begin all comments with two slashes, //.

In computer lingo, language syntax refers to the spelling of commands, the ordering of special characters, and the placing of the language elements. When you learn the syntax for a Visual C++ command or operation, you learn the exact format required so that Visual C++ knows what you want it to do.

Comments are so important that you are now going to learn the syntax of comments (how to write comments so that Visual C++ knows that they are comments) before you learn any Visual C++ commands. Use comments abundantly so that someone reading your program later has a clear guide to the program's contents. A Visual C++ programmer might be able to trace through your Visual C++ code and figure out what the program does, but comments speed the process. The faster someone understands your code, the faster he or she can make any needed changes and move on to other projects.

A comment begins with two forward slashes, sometimes called a double slash. Comments extend to the end of the line. In other words, you cannot have a command, a comment, and then another command all on the same line. Here is an example of a Visual C++ line with a comment:

return ((a > b)?a:b);  // Grabs the larger of two values

Here is the same line without the comment:

return ((a > b)?a:b);

With a comment, you don't even have to know Visual C++ in order to know what the statement is doing. Without a comment, as you can see, the statement looks like garbage characters that make no sense.

The double slash is vital: without it, Visual C++ would refuse to accept the line. Even though return ((a > b)?a:b); is a valid Visual C++ command, if you left out the double slash comment signal, Visual C++ would see the words Grabs the larger of two values and not know what to do with them. After all, Visual C++ does not know English; it knows only C++. The comment is there not for Visual C++ but for a person looking through your program.

Comments can reside on lines all by themselves. Sometimes you use comments for more than one program statement. Comments are useful for describing a section of several lines in a program and for putting in program notes about the programmer and the program. For example, the following small Visual C++ program contains two lines of comments that extend the entire line length, as well as three additional comments to the right of Visual C++ code.

// Filename: COMAVGE.CPP  // Program to compute the average of three values  #include   void main()    {      float g1, g2, g3;   // Variables to hold student grades      cout << "What grade did the first student get? ";      cin >> g1;      cout << "What grade did the second student get? ";      cin >> g2;      cout << "What grade did the third student get? ";      cin >> g3;      float avg = (g1 + g2 + g3) / 3.0;   // Computes average      cout << "The student average is " <<>

All of the programs on this book's program disk are stored under a separate filename. You must tell your Visual C++ compiler the program's filename before it can load the program into memory and run it. To help you quickly try the examples throughout this book, a comment on the first line of every program contains the name of the program as it is stored on the disk. For instance, you can load the preceding program from the book's program disk by retrieving the file named COMAVGE.CPP.

Many companies require their programmers to put their names in comments at the top of programs they write. If someone later has a question about the program, the original programmer can be traced. If several people make changes to a program, they often put their names too, with a brief comment about the changes they made. Because all these types of lines are commented, Visual C++ skips over them, as it should. Often, they also put a brief description of what the program is supposed to do at the beginning.

Scatter comments throughout a program as well. If you write some tricky code that needs explanation, spend a few lines of comments, if needed, explaining what the next few lines of code do.

Be proud of yourself! You do not yet know one bit of Visual C++ code, yet you understand exactly what the preceding program does. That's the purpose of comments! They document a program so that you don't have to go through tedious code to learn what parts of the program are doing.

A Visual C++ programmer usually can understand what a simple Visual C++ program is supposed to do, even if the program has no comments at all. As soon as you learn the Visual C++ language, you will be able to look through straight Visual C++ code, with no comments, and make changes that need to be made. The comments simply help describe what the program is doing.

Comments begin with // and extend to the end of the line. You can put comments on lines by themselves or at the end of other C++ code.

Comments Are For You, Too

Even if you write programs that you will maintain yourself, you'll need comments.

Suppose that you write programs for your own use and amusement. Nobody but you will ever see the Visual C++ code you write. Can you think of why you should take the time to add comments to your own programs? There are plenty of reasons.

Suppose that you write a Visual C++ program to track your bank records. A year later, your bank allows for automatic transfers of utility bill payments straight from your savings account. Your old program no longer suffices for the new banking system, so you get the Visual C++ code out and begin making changes. However, you can't remember what you did before, and the code is so succinct that it is difficult to follow. Luckily, you put comments in the code, so you read through the program until you get to the place you need to change. As soon as you are there, you know what is going on in the code, and you quickly make the changes.

Get into the habit of commenting as you write programs. Many people write programs without commenting as they go, thinking that they will add comments later. More often than not, the comments never get added. When program maintenance is required, it takes twice as long to change the code as it would if the programmer had added comments during the original programming phase.

As important as comments are, you can over-comment a program. Add comments to lines only when the program's code warrants it. You see many more comments in the first few programs in this book than you see later. As you learn the simple commands, this book attempts to clarify them through extra comments in the program listings.

Nevertheless, redundant comments are as bad as no comments at all. For example, even though you know nothing about Visual C++ commands, you might agree that the following code contains worthless comments:

totalsales = oldsales + newsales;   // Adds the old sales and                                      // the new sales to get                                      // total sales  cout << "Happy Birthday";   // Sends the Happy Birthday                              // message to the cout  return;   // Return

Each of these comments is redundant, and they really do not explain what is going on any more than the Visual C++ code itself. However, consider this statement:

for (int ctr = 10; ctr > 0; ctr) // Prints the numbers    {                              // from 10 to 1      cout <<>

Although you don't know Visual C++ (and even if you did), you can see that the purpose of these two lines of code is hidden in the cryptic Visual C++ language. A Visual C++ programmer could figure out this code, but the comment makes it effortless. As you saw in the previous three code fragments, comments often span more than one line. Continue a comment on the next line (remembering to use a double slash) if it is too long to place on a single line.

It is also useful to describe in your comments why your program is doing something. In the previous snippet, it would be obvious to a C++ programmer that the program was putting the numbers on the screen. If this was part of a graph drawing program, it might be more helpful to comment it like this:

//  //  Display the range of the graph on the screen  //  for (int ctr = 10; ctr > 0; ctr)     {      cout <<>

Now you understand why the program has a piece of code in it.

After writing a program, you'll need comments even if you maintain the program yourself. Use comments only when they help explain what is going on in the code.

C-Style Comments

Visual C++ supports your use of the old C-style comments that begin with /* and end with */.

Visual C++ supports another kind of comment that you might see occasionally. Visual C++ is based on the C language, but Visual C++'s comment syntax differs from C's. The designers of Visual C++ decided to keep the old C-style comment syntax so that C programs would work, with little or no change, with Visual C++ compilers. Nevertheless, the double slash comments are considered superior. You should learn C comments just in case you see them.

A comment in C begins with the characters /* and ends with the characters */. Unlike with Visual C++ comments, you must end a C comment. If you do not put the ending */, C assumes that the next line (or the next hundred lines) is still a comment until it finally finds another */. The following line contains a C-style comment:

char name[25];   /* Reserves space for a 25-character name */

Because a C comment ends only when the */ is reached, the following three lines make up a single comment:

/* The following program calculates stock statistics  using the most modern technical analysis techniques  available. */

Of course, the three lines could also be commented like this:

/* The following program calculates stock statistics */  /* using the most modern technical analysis techniques */  /* available. */

Although you should become familiar with C comments, true Visual C++ programmers tend to avoid using them. The double slash is easier because you don't have to remember to end the comment. The C-style comments can be error-prone as well. If you embed one C-style comment within another, Visual C++ gets confused. Stay with Visual C++ comments as much as possible, and both you and your Visual C++ compiler will lead healthier and more productive lives.

C comments can be dangerous if you accidentally embed one within another. Stick to C++'s // comment style. There might be times, however, when you run across C comments in a C++ program and you should understand their format.

Comments

2009-05-24T02:10:00.000-07:00

Provide readable comments that explain in plain language (non-C++) what's going on.

Suppose that your car breaks down in the middle of nowhere with no other cars in sight. The problem is not tools or parts; they are in the trunk. The problem is that you know absolutely nothing about the car, and when you open the trunk, you have no clue as to where the parts go or how to fix the problem.

Just about to despair, you glance down and see two car repair books in the trunk. You pick up the first one and realize that it is a book written by advanced, expert mechanics for advanced, expert mechanics. The book uses technical jargon you've never heard. You toss the worthless repair book over your shoulder and pick up the next book. The title is Car Repair for the Un-Mechanic. Glancing through the opening pages, you begin to smile. The second book assumes that you don't know a rotor widget #4 from a tactile stem #3B-7. The second book explains, in uncluttered and nonmechanical language and with a friendly style, exactly how to fix your problem.

You find that the second book contains the very same facts that the first one does. Of course, the first book does not help your plight one bit. It teaches you nothing and explains nothing. It assumes that you know enough to write the book yourself. The second book explains every concept in easy-to-understand language, and in 10 minutes, you fix the car just in time to drive to the cafe across the street for dinner. (You thought you were in the middle of a desert or something?)

Which of the following is true of this car story:

It has a point to it.
It mistakenly got mixed in with this book at the printer.
It proves that this book's author cannot focus on one subject for very long.

Obviously, the story has a point (and also hints at number 3). The point is that people react much better to material that is not technically above their heads. Of course, any subject is easy if it is explained well enough. If thermonuclear space transportation were explained in a simple manner, you could understand it.

By their very nature, Visual C++ programs are cryptic, even to established C++ programmers. As the previous lesson explained, programs rarely remain in one form. The life of a programmer includes not only writing new programs, but updating programs written earlier. As you write a Visual C++ program, add whitespace so that the program is easier to read. Even more important, add comments as well.

Comments are not Visual C++ commands. As a matter of fact, Visual C++ ignores any and all comments in your programs. Comments are nothing more than messages that explain what the program does. Comments are for people, not for the computer.

If your Visual C++ programs contain only Visual C++ code and no comments, they will be virtually impossible to figure out later. Remember that Visual C++ is cryptic and extremely difficult to read. Many companies that employ programmers require that their programmers put comments throughout every program they write. Why do you think these companies require comments? It is because people change, jobs change, and companies must ensure that a program written by one person can be understood by the next person.

Freeform Style

2009-05-24T02:09:00.000-07:00

C++'s freeform style lets you insert spacing and blank lines throughout your code to help make the program more readable.

definition

Whitespace consists of the blank lines and indentations you add to code.

Most of the time, you can put lots of spacing in a Visual C++ program and C++ will not complain. You can put whitespace between symbols and the words that make up the C++ language (but you can't split up words with spaces). C++ programmers often put extra spaces and blank lines in programs to make the programs more readable. With whitespace, C++ programmers make C++ programs more readable to people, not to the Visual C++ compiler.

To your Visual C++ compiler, the following program is exactly the same program as the previous one you saw:

//Filename:CFIRST.CPP//Program displays a message on-screen  #include   void main(){cout<<"I will be a C++ expert!";}

definition

Freeform means that C++ lets you insert as many spaces and lines as you want.

Which is easier for you to read, the first or the second version of the program? Obviously, the first version is. Visual C++ is called a freeform compiler. You can indent lines of the program, or leave all the lines flush left.

Because your computer is a machine, it does not require extra whitespace to understand a program. As long as you follow all the coding rules of Visual C++, the compiler will be happy with the code you supply. In spite of the Visual C++ compiler's lack of concern for how nice a program looks, you should be concerned about the program's look. Add extra whitespace to group similar lines of code together and make the program easier to understand for people who read the program.

As you see other programs throughout this book, you will begin to pick up some C++ whitespace conventions and develop some of your own.

Programs Always Change

While you write Visual C++ programs, consider that someday you might have to change those programs or somebody you work with will have to. You could squeeze as much space out of a program as possible, but you will gain nothing from doing so. (You might save a few characters of computer memory, but not enough to make up for a messy program.)

If you add extra whitespace to make the program more readable to people, the program will be easy to modify in the future. In this ever-changing world, programs have to be modified to reflect those changes, and the person who writes more readable code gets hired for programming jobs faster than one who does not care about program readability. Updating and changing programs is called maintaining programs. A maintainable program is a readable program.

If you are confused now, you are right on track! You still do not have to understand any specifics about the two program listings seen so far. This unit is getting you used to the look and feel of Visual C++ programs, not their particulars. If you understand that Visual C++ is picky about the characters you type, and if you realize that a program should be readable to people, you deserve an A+ for the unit so far.

The C++ freeform language allows for as much whitespace as you want to add.

Visual C++ Special Characters

2009-05-24T02:08:00.001-07:00

C++ is a language rich in special characters.

Visual C++ is one of the few programming languages that uses almost every key on your keyboard. Visual C++ is picky about the keys you press. Notice that the program in the preceding section contains a left and a right brace, { and }. If you were to use parentheses, ( and ), or square brackets, [ and ], in place of the braces, Visual C++ would complain. Make sure that you also distinguish between left and right angled brackets, <>, as well as the forward slash, /, and the backslash, \.

Be extremely careful to use the characters you are supposed to use. Computers are precise machines without as much tolerance for typing ambiguities as people have. Throughout Visual C++ Programming in 12 Easy Lessons, you will learn when to use each of the characters and what they mean. Until then, be very careful to type the correct characters.

Visual C++ distinguishes between a capital letter O and a number 0 (zero). Also, a lowercase letter l will not substitute for a number 1. Because you're dealing with a machine, you should type numbers when C++ wants numbers, letters when C++ wants letters, and exact special characters (characters that are neither letters nor numbers, such as brackets and the plus sign) when C++ wants them.

Simple Visual C++ Program

2009-05-24T02:08:00.000-07:00

Enter and run a simple Visual C++ program and discuss the code and results.

Here is a Visual C++ program. Although it is extremely simple, it contains all the elements necessary to be a valid Visual C++ program.

// Filename: CFIRST.CPP  // Program displays a message on-screen  #include   void main()    {      cout << "I will be a C++ expert!";    }

Even a simple Visual C++ program might intimidate a beginning programmer. Do not let it intimidate you! C++ has a bark that is often worse than its bite. If you were to type this program into your Visual C++ compiler's editor, compile it, and run it, you would see the following output on your screen:

I will be a C++ expert!

At this point, do not concern yourself with the specifics of the code in this program. The rest of this book explains things like that. Only one line in the entire seven-line program does anything noticeable (the one that begins with cout), and the rest of the program is simply there because C++ needs it to be there. You will find out why as you work through the unit.

The preceding program contains a total of seven lines, and only one really produces something you can see. More advanced Visual C++ programs might consist of 500 lines or more. That 7-to-1 setup-to-work ratio does not exist for every Visual C++ program. That would cause too much work on your part! The amount of code that sets up the program diminishes as a program grows.

C++ programs sometimes look cryptic, but when you learn the fundamentals of the language, you'll see that program formats are often similar. A simple program might contain several lines of code.

There are no Stop and Type parts in this unit due to the textual nature of the material.

Programming with Visual C++

2009-05-24T02:06:00.000-07:00

the fundamentals of the Visual C++ compiler and how to enter and edit programs using Visual C++'s workbench. You saw the following:

Introduction to programming concepts
How C++ compares to other languages
Starting Visual C++
Using Visual C++'s menus
How to enter and edit Visual C++ programs
How to compile Visual C++ programs
Stopping Visual C++

This project reviews entering and editing a Visual C++ program using the workbench. You are not expected to understand how the program works. The format of future projects will concentrate much more on Visual C++'s language specifics using a different project format.

Step 1: Start Visual C++.

Before using Visual C++, you must start the workbench. Follow these steps:

Turn on your computer.
Start Windows by typing WIN (if it does not automatically start Windows).
For Windows 3.1, choose the program group Microsoft Visual C++. Double-click on the icon titled Visual C++.

For Windows 95, click on the Open button, choose Programs from the popup menu, and select Microsoft Visual C++. Click on Visual C++.

Step 2: Open a program window.

The Visual C++ workbench is known as an MDI application. You enter and edit programs in one or more windows that appear in the workbench. Before typing a new program, you must open a new file in a new window. Type Alt+F,N (File New) to open a new file in an editing window.

Although I describe keystrokes to issue the commands, feel free to use the mouse to select menu options. Neither is a better way to use Windows; just use the way that is easiest for you.
Type the following program. When typing the program, be sure to press Enter at the end of each line (including the very last line). Type as accurately as possible so that no mistakes appear later. The program takes more lines than will fit in the workbench editing window, so you'll see the workbench scroll downward when you fill the open window.

Project 1 Listing. The Visual C++ project program.
```
// Filename: PROJECT1.CPP  // Prints the first 20 odd, then even, numbers.  // Once done, it prints them in reverse order.  #include   void main()    {      int num;   // The for loop control variable      cout << "The first 20 odd numbers:\n";      for (num = 1; num < num =" 2;" num =" 39;">= 1; num -= 2)        { cout << num =" 40;">= 2; num -= 2)        { cout <<>
```
When you finish typing the complete program, you can use PageUp, PageDown, and the arrow keys to scroll the top of the program back into view.

Step 3: Compile and run the program.

Before running the program, you must compile it. Choose Project | Build, (Shift+F8) which is an alternative to Project | Execute when you know the program needs to be made.
If errors appear, the status bar will display an error count. Pressing F4 guides you through the code and leaves you near where the errors are. You can fix any errors that might appear. Recompile the program when you type it exactly as the listing shows.

If no errors appear, the error count will be zero and you can then press Ctrl+F5 to execute the program. Here is what you'll see in the QuickWin window:

The first 20 odd numbers:  1 3 5 7 9 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39  The first 20 even numbers:  2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40  The first 20 odd numbers in reverse:  39 37 35 33 31 29 27 25 23 21 19 17 15 13 11 9 7 5 3 1  The first 20 even numbers in reverse:  40 38 36 34 32 30 28 26 24 22 20 18 16 14 12 10 8 6 4 2

Close the output window and return to the workbench's editing window (use Alt+Tab or click on the workbench window if you do not directly return to the workbench).

Step 4: Save your work.

If you exit Visual C++ without saving your program, you'll lose the program and have to reenter it in order to see the results again. Therefore, you'll want to save your programs to a disk file.

All of the programs in this book, including the one shown in Listing 1, are stored on the enclosed program disk. You don't have to save this listing unless you want the practice, because it is already on the disk.

To save a program, select Alt+F,S (for File Save). You'll see the File Save dialog box appear on the screen.
Type a program name along with a path name if you want to store the program in a subdirectory. All Visual C++ programs should end with the .CPP filename extension.

Step 5: Exit Visual C++.

Select Alt+F4 (for File Exit) to close Visual C++. If you did not save your program, Visual C++ tells you with a final dialog box that gives you one last chance to save the program.
After saving the program, you can exit Visual C++ and switch off your PC. You should always return to DOS with Windows 3.1 or shut down your PC under Windows 95 before powering off your computer.

ATL Server Project

2009-04-01T03:59:00.000-07:00

This project shows how to access a database from web, A online store is used as an example. On executing the application, a Web page comes up and asks you for a username and password. You can create a new account or enter a username and password for an existing customer in the database, in first case the application will write the new username and password to the database.

Building and Running the Sample
To build and run this sample
Open the solution file, Tutorial.sln, in the Visual Studio development environment.

Build the solution. This will also deploy the solution to the local Web server.

Configure the data link to connect to the Tutorial.mdb database. In the sample's Tutorial\Tutorial\bin directory, double-click Tutorial.udl.

The Data Link Properties dialog box appears.

On the Provider tab, select Microsoft Jet 4.0 OLE DB Provider.

On the Connection tab, click the Ellipsis (...) button to specify the Tutorial.mdb file in the Tutorial\Tutorial\bin directory. Leave the username and password blank.

Ensure that Tutorial.mdb is not read-only. Right-click the file and select Properties. On the General tab, ensure that the Read-only check box is cleared.

Change the NTFS security settings on the Tutorial.mdb file to allow read-write access by the Internet Guest Account, IUSR_Machine. To do this:

Right-click the Tutorial.mdb file and select Properties on the shortcut menu.

In the Properties dialog box, select the Security tab and click Add.

The Select Users or Groups dialog box appears; in that dialog box, set the following:

Object Types to Users.

Locations to the local machine.

Check Names to IUSR_Machine.

Select the Internet Guest Account that you just created. In the Permissions box, select the Read and Write boxes if they are not already selected.

Note
See ATL Server Security for information about the accounts used by a typical ATL Server application running in IIS.

Change the NTFS security settings on the folder containing Tutorial.mdb to allow only write access by IUSR_Machine, using the procedure described in Step 7.

Change the NTFS security settings on the Tutorial.udl file to allow read access by the IUSR_Machine account, using the procedure described in Step 7.

Use a Web browser to view http://localhost/tutorial/login.srf.

for source file - > http://www.technicalcontents.com/visualc

Visual C++ Audio turorial on MFC, COM, Win32

2009-02-24T22:51:00.000-08:00

Click here to access audio files....

Guide to Using the Visual C++ Debugger

2008-12-11T23:25:00.000-08:00

1. Write your program, and make sure it compiles

2. Set a breakpoint in your code. Do this by clicking the cursor on the line that you want to set the breakpoint and then press the "set breakpoint" button. (You can also set a breakpoint using the right mouse button)

You may want to set the breakpoint at an early place in your code so that you can step through the whole program, or there may be a specific place where you want to start stepping through your program.

Note that it is possible to choose a line of code where Visual C++ can not stop. If this is the case it will automatically be moved down to the next valid line of code. (One place where Visual C++ does not seem to be able to stop is a declaration where you do not initialize the variable)

3. Now under the build menu choose "Rebuild All". This is necessary to force Visual C++ to recompile your code and add debugging information.

4. Now click the "go" button. The program will run until your first breakpoint.

Now that you've started the debugger what can you do?

The "step over" button allows you to execute the statement that the arrow is pointing at

The "step into" button executes the "sub-steps" that the statement the arrow is pointing at represents. If you are pointing at a function call, you will enter the function. This can be very confusing if you are pointing at a cin command and you go into the code for cin. To get back out of the function, push the "step out" button.

The "step out" button completes the running of the function you are in and takes you back to the next line of code after the function call

The "restart" button will start running your code again from the beginning

The "run to cursor" button runs your program up to the line where the cursor is flashing

The "stop debugging" button stops the debugger and puts you back into editing mode

The "quick watch" button allows you to check the value of a variable.

You can also force the system to let you watch the value of a variable as it changes by clicking under the word "name" in the bottom right hand corner of the screen and entering a variable name

Removing a program from your project

2008-12-11T23:23:00.000-08:00

When you want to write a new program, you must first remove the old one from the project

Click on the File View Tab

(It may just have a picture of

a piece of paper)

First:

Click once on the + sign next to

Next:

CSandPTextProject files

Removing a program from your project Page 2 of 3

Click once on the + next to

Source Files

Removing a program from your project Page 3 of 3

Click once on the name of your

current program (to highlight

it) and then push the delete

key

This DOES NOT delete your

program, it simply removes

it from the project

At this point you may click

on the X to close the window

showing you your program

file. (Be sure your program

file has been saved before

doing so!) (You can save the

program by clicking on the

program window and then

selecting File -> save

Compiling and Running Your Visual C++ 6.0 Project

2008-12-11T23:22:00.001-08:00

Compiling and linking your project:

. Click on Build/Rebuild All

If it compiles and links

successfully, the window at the

bottom of your screen will

display 0 error(s), 0

warning(s)

Compiling & Running your VC6.0 Project Page 2 of 3

To run your program:

Click on Build/Execute HelloWorld.exe.

The following output window should be displayed. When I press any key, the

window will be taken down and the program will stop.

Saving the project:

Click on File/Save All.

Closing the project:

Click on File/Close Workspace.

Compiling & Running your VC6.0 Project Page 3 of 3

What if I have compiler errors?

If you have compiler errors, click the mouse in the window at the bottom of your screen.

If necessary scroll to the top of this window to see your first error message. Click on the

error message. It will be highlighted. Double Click on the message. The statement

corresponding to the error message will be preceded by a blue arrow in the coding

window. In this case I simply typed ct instead of cout. Return to the coding window and

correct the error. Recompile the program.

Creating a new program in an existing visual C++ project

2008-12-11T23:20:00.000-08:00

We now want to code the C++ program. To do this we have to create a new file.

Choose File/New

Creating a new program in an existing visual C++ project Page 2 of 2

When you are finished writing your

code, choose: File/Save.

Choose C++ Source

File

Be sure the project

name is the name of

the current project.

Enter the name of

your source file

(HelloWorld.cpp)

Be sure the saving

location is correct

Click on OK

Enter your C++ source

code into this window.

Starting up visual C++ 6.0 after you have used it before (i.e. how to get your old "desk" back)

2008-12-11T23:17:00.000-08:00

1) Start visual C++ 6.0
2) From the File Menu, click on "open workspace"

IMPORTANT NOTE: in the file menu, there are two commands that have the word open in them, you want "open workspace" not just "open"

3) Find your old workspace. In my class that means selecting your "H" drive from the pull down menu, and then navigating to your "intro" folder, then into your "intro_text_project" folder, and then double clicking on the "intro_text_project.dsw" file.

Now your project is open and you're ready to continue.

Visual C++ Tutorial & Basic Concepts

2008-12-11T23:12:00.000-08:00

Background

You will be writing programs, and then compiling and running them. To compile a program (think of compilation as turning C++ code into a different language that your PC can run), it must be a part of a Visual C++ "project".

Think of it this way. A program is a lot like a piece of paper with words on it, and a project is a lot like a big wooden desk. When you create a new Visual C++ Project, you are building a new desk to work on. This desk has a special area where it holds the papers that are most important to you, but there is also lots of space to hold other papers.

Every time you write a new program, you get out a blank piece of paper and write on it. You can also, of course, take an old program (a piece of paper you've already written on) and run it, or modify it and then run it.

When you want to compile and run your program, you have to tell the computer to remove any other papers from the special space on the desk, and put your program in the special space. Then you have to tell it to put your new program in the special space. Finally, you tell it to compile and run what's in the special space.

This document gives you an outline of how to do different common tasks, and has links to the following files:

Creating a New Visual C++ 6.0 Project: Think of this as building a new desk. You should only have to do this once for the entire semester. (Under certain circumstances Visual C++ will mess up your desk and you'll have to build a new one, if things don't seem to be working, this may be the problem. BUT, it's fairly uncommon, probably happens to 5-10% of students over the course of the semester, so don't worry about it too much.)
NEW! Opening a workspace you created earlier: If you built a desk previously, this lets you retrieve that desk rather than building a whole new one each time.
Creating a New Program in an Existing Visual C++ Project: Think of this as getting a brand new sheet of blank paper and putting it on the special space in your desk.
Compiling and Running your Visual C++ 6.0 Project: This is the final step in using your setup. You are telling the computer to compile and then run what's in the special space on your desk.
Removing a program from your project: Think of this as removing something from the special space on your desk that you don't need to use for now. It doesn't mean that you're erasing everything that's on that piece of paper, but you are moving it away from the special space on your desk.
Opening an existing program in your Visual C++ 6.0 Workspace: You use this when you started writing on a piece of paper earlier, maybe even made it into a working program, but at some point you took it off of the special space on your desk. This technique will enable you to put that old piece of paper back on the special space on your desk.

Before you start to use Visual C++ for the first time

Set up your Computer Science & Programming Folder:

Make a folder on your H drive called CSP
Inside of that folder, make another folder called lab1
(Each week, you'll make a new folder -- lab2, lab3, and so on)

The first time you use Visual C++

Follow the directions in the Creating a New Visual C++ 6.0 Project handout to make a new project.
Follow the directions in the Creating a New Program in an Existing Visual C++ Project handout to write a new program.
Follow the directions in the Compiling and Running your Visual C++ 6.0 Project handout to compile and run your program.

Using Visual C++ again to write a new program

NEW Opening up your workspace again (necessary only when you just start up Visual C++).
Remove your old program from the project as described in the Removing a program from your project handout.
Follow the directions in the Creating a New Program in an Existing Visual C++ Project handout to write a new program.
Follow the directions in the Compiling and Running your Visual C++ 6.0 Project handout to compile and run your program.

Using Visual C++ to look at / run a program you've already written

NEW Opening up your workspace again (necessary only when you start up Visual C++).
Remove your old program from the project as described in the Removing a program from your project handout.

Follow the directions in the Opening an existing program in your Visual C++ 6.0 Workspace handout to open your program

Follow the directions in the Compiling and Running your Visual C++ 6.0 Project handout to compile and run your program.

Creating a C++ Program in Microsoft Visual Studio 2005

2008-12-11T23:07:00.000-08:00

Microsoft Visual Studio 2005 is a sophisticated environment designed for developing complex

Windows applications. A complete “Project” consists of a “source program” (which you write)

and all the linked header, library, and other resource files. We will be using very few of the

features of this environment to run the relatively simple programs in this course, but we will

need to link to external header files and libraries to use the National Instruments programs to

control the PCI-6024E A/D card. Below is a step-by-step description of how to create a Project,

add your C++ source program, and link to external header and library files.

1. Open MS Visual C/C++. On the computers in the “High-Tech Tools and Toys Lab” You

will find this program under the Start button by following the links: Programs>>

Microsoft Visual Studio 2005 >> MS Visual Studio 2005

2. Under the File menu choose New >> Project and then, in the Visual C++ >> Win 32

Project Type, select Win-32 Console Application. Give the project a name

(suggestion “Lab7_xyz” where “xyz” are your initials). Under “Location,” use your

memory stick if possible. Any files stored on the computer are likely to be erased or

corrupted. Click Next, check the box for Empty Application, and press Finish.

3. You will now have created a folder called Lab7_xyz in your personal directory. This is

your “Project Workspace.” If you look in this folder you will find three files

Lab7_xyz.ncb, Lab7_xyz.sln, and Lab7_xyz.suo and a folder

Lab7_xyz. These files and folder contain information about your project.

4. To create a C++ program in your project you have to add a C++ source file to the Project.

From the Project Menu, select Add New Item >> Visual C++ >> C++ File. Give

your source file the same name as your project (“Lab7_xyz”). The Project and

Location will be your Lab7_xyz Project and your Workspace on your memory stick.

Click OK and you will be transferred to a text editor with an open file Lab7_xyz.cpp.

5. Write your C++ source code for your program. After the customary few lines of

comments and before your int main(void) or void main(void) routine, insert

the following:

#include // input/output to console

#include //NI-DAQ routines for the PCI-6024E

Note: You will need to either add the NI-DAQ header directory to your path by using the Tools

>> Options >> Projects and Solutions >> VC++ menu (as described in 8 below) or use the

entire path to nidaq.h:

#include

6. To use the NI functions, you will also need to the library file nidaq32.lib to your

Project. Under the Project menu, choose Add Exiting Item and mouse to the files in

C:\Program Files\National Instruments\NI-DAQ\lib. You will need to specify the default

file type as All Files or else you will see only the .h files. Highlight the nidaq32.lib

library (it may appear as just nidaq32 if Windows suppresses file extensions) and press

OK.

7. Under the Build menu, choose Rebuild All and hope for no compile or link errors. If

OK, choose Debug >> Start Without Debugging and watch the program run.

Debug, debug, debug.

8. If you set a path to C:\Program Files\National Instruments\NI-DAQ\Include, you will not

need to put the entire path for nidaq.h into your #include statement. To do this, go

to the Tools >> Options >> Projects and Solutions >> VC++ Directories menu,

choose “Include Files” in the pull-down box, and then click in the “Directories” area

until you get an open box. Click in the box until you get a gray button with three dots

(…). Click on this and you will be able to click to the C:\Program Files\National

Instruments\NI-DAQ\Include directory. This procedure allows the linker to find the

header files in the National Instruments directory and Visual C will remember this setting

henceforth.

9. Some other header files and library files that you might need for some NI-DAQ functions

are:

nidaqcns.h

nidaqerr.h

nidaqex.h

Olderror.h

nidex32.lib

There is also a dynamic link library nidex32.dll that may have to be in a directory

that is in the path MS Visual C++ searches for execution-time libraries. Don’t worry

about any of these files unless you are using a NI-DAQ program that indicates you need

them.

10. When you finish your work for the day, copy your Workspace folder to your memory

stick if it is not already there. Make sure you have a copy of your source file at least. To

restart your program when you come back to the lab, reconnect your memory stick with

your files and Workspace folder. You can then restart MS Visual C++ and, from the File

menu, open the Workspace or the Project and you should be ready to go.

CObject Class

2008-12-10T22:50:00.000-08:00

CRACK THE INTERVIEW

The principal base class for the Microsoft Foundation Class Library.

class AFX_NOVTABLE CObject

Remarks

It serves as the root not only for library classes such as CFile and CObList, but also for the classes that you write. CObject provides basic services, including

Serialization support
Run-time class information
Object diagnostic output
Compatibility with collection classes

Note that CObject does not support multiple inheritance. Your derived classes can have only one CObject base class, and that CObject must be leftmost in the hierarchy. It is permissible, however, to have structures and non-CObject-derived classes in right-hand multiple-inheritance branches.

You will realize major benefits from CObject derivation if you use some of the optional macros in your class implementation and declarations.

The first-level macros, DECLARE_DYNAMIC and IMPLEMENT_DYNAMIC, permit run-time access to the class name and its position in the hierarchy. This, in turn, allows meaningful diagnostic dumping.

The second-level macros, DECLARE_SERIAL and IMPLEMENT_SERIAL, include all the functionality of the first-level macros, and they enable an object to be "serialized" to and from an "archive."

For information about deriving Microsoft Foundation classes and C++ classes in general and using CObject, see Using CObject and Serialization.

Using CObject

CObject is the root base class for most of the Microsoft Foundation Class Library (MFC). The CObject class contains many useful features that you may want to incorporate into your own program objects, including serialization support, run-time class information, and object diagnostic output. If you derive your class from CObject, your class can exploit these CObject features.

CObject Members

Construction

CObject	Default constructor.
CObject	Copy constructor.
operator delete	Special delete operator.
operator new	Special new operator.

Diagnostics

AssertValid	Validates this object's integrity.
Dump	Produces a diagnostic dump of this object.

Serialization

IsSerializable	Tests to see whether this object can be serialized.
Serialize	Loads or stores an object from/to an archive.

Miscellaneous

GetRuntimeClass	Returns the CRuntimeClass structure corresponding to this object's class.
IsKindOf	Tests this object's relationship to a given class.

CObject::AssertValid

Validates this object's integrity.

virtual void AssertValid( ) const;

Remarks

AssertValid performs a validity check on this object by checking its internal state. In the Debug version of the library, AssertValid may assert and thus terminate the program with a message that lists the line number and filename where the assertion failed.

When you write your own class, you should override the AssertValid function to provide diagnostic services for yourself and other users of your class. The overridden AssertValid usually calls the AssertValid function of its base class before checking data members unique to the derived class.

Because AssertValid is a const function, you are not permitted to change the object state during the test. Your own derived class AssertValid functions should not throw exceptions but rather should assert whether they detect invalid object data.

The definition of "validity" depends on the object's class. As a rule, the function should perform a "shallow check." That is, if an object contains pointers to other objects, it should check to see whether the pointers are not null, but it should not perform validity testing on the objects referred to by the pointers.

Example

See CObList::CObList for a listing of the CAge class used in all CObject examples.

Copy Code

// example for CObject::AssertValid

void CAge::AssertValid() const

{

CObject::AssertValid();

ASSERT( m_years > 0 );

ASSERT( m_years <>

}

CObject::CObject

These functions are the standard CObject constructors.

CObject( );

CObject( const CObject& objectSrc );

Parameters

objectSrc

A reference to another CObject

Remarks

The default version is automatically called by the constructor of your derived class.

If your class is serializable (it incorporates the IMPLEMENT_SERIAL macro), then you must have a default constructor (a constructor with no arguments) in your class declaration. If you do not need a default constructor, declare a private or protected "empty" constructor. For more information, see Using CObject.

The standard C++ default class copy constructor does a member-by-member copy. The presence of the private CObject copy constructor guarantees a compiler error message if the copy constructor of your class is needed but not available. You must therefore provide a copy constructor if your class requires this capability.

Example

See CObList::CObList for a listing of the CAge class used in the CObject examples.

Copy Code

// Create a CAge object using the default constructor.

CAge age1;

// Create a CAge object using the copy constructor.

CAge age2( age1 );

CObject::Dump

Dumps the contents of your object to a CDumpContext object.

virtual void Dump(

   CDumpContext& dc

) const;

Parameters

The diagnostic dump context for dumping, usually afxDump.

Remarks

When you write your own class, you should override the Dump function to provide diagnostic services for yourself and other users of your class. The overridden Dump usually calls the Dump function of its base class before printing data members unique to the derived class. CObject::Dump prints the class name if your class uses the IMPLEMENT_DYNAMIC or IMPLEMENT_SERIAL macro.

Note

Your Dump function should not print a newline character at the end of its output.

Dump calls make sense only in the Debug version of the Microsoft Foundation Class Library. You should bracket calls, function declarations, and function implementations with #ifdef _DEBUG/#endif statements for conditional compilation.

Since Dump is a const function, you are not permitted to change the object state during the dump.

The CDumpContext insertion (<<) operator calls Dump when a CObject pointer is inserted.

Dump permits only "acyclic" dumping of objects. You can dump a list of objects, for example, but if one of the objects is the list itself, you will eventually overflow the stack.

Example

See CObList::CObList for a listing of the CAge class used in all CObject examples.

Copy Code

// example for CObject::Dump

void CAge::Dump( CDumpContext &dc ) const

 CObject::Dump( dc );

 dc << "Age = " <<> }

CObject::GetRuntimeClass

Returns the CRuntimeClass structure corresponding to this object's class.

virtual CRuntimeClass* GetRuntimeClass( ) const;

Return Value

A pointer to the CRuntimeClass structure corresponding to this object's class; never NULL.

Remarks

There is one CRuntimeClass structure for each CObject-derived class. The structure members are as follows:

LPCSTR m_lpszClassName A null-terminated string containing the ASCII class name.
int m_nObjectSize The size of the object, in bytes. If the object has data members that point to allocated memory, the size of that memory is not included.
UINT m_wSchema The schema number ( – 1 for nonserializable classes). See the IMPLEMENT_SERIAL macro for a description of schema number.
CObject* ( PASCAL* m_pfnCreateObject )( ) A function pointer to the default constructor that creates an object of your class (valid only if the class supports dynamic creation; otherwise, returns NULL).
CRuntimeClass* ( PASCAL* m_pfn_GetBaseClass )( ) If your application is dynamically linked to the AFXDLL version of MFC, a pointer to a function that returns the CRuntimeClass structure of the base class.
CRuntimeClass* m_pBaseClass If your application is statically linked to MFC, a pointer to the CRuntimeClass structure of the base class.

This function requires use of the IMPLEMENT_DYNAMIC, IMPLEMENT_DYNCREATE, or IMPLEMENT_SERIAL macro in the class implementation. You will get incorrect results otherwise.

Example

See CObList::CObList for a listing of the CAge class used in all CObject examples.

Copy Code

// example for CObject::GetRuntimeClass

CAge a(21);

CRuntimeClass* prt = a.GetRuntimeClass();

ASSERT( strcmp( prt->m_lpszClassName, "CAge" ) == 0 );

CObject::IsKindOf

Tests this object's relationship to a given class.

BOOL IsKindOf(

   const CRuntimeClass* pClass

) const;

Parameters

pClass

A pointer to a CRuntimeClass structure associated with your CObject-derived class.

Return Value

Nonzero if the object corresponds to the class; otherwise 0.

Remarks

This function tests pClass to see if (1) it is an object of the specified class or (2) it is an object of a class derived from the specified class. This function works only for classes declared with the DECLARE_DYNAMIC, DECLARE_DYNCREATE, or DECLARE_SERIAL macro.

Do not use this function extensively because it defeats the C++ polymorphism feature. Use virtual functions instead.

Example

See CObList::CObList for a listing of the CAge class used in all CObject examples.

Copy Code

// example for CObject::IsKindOf

CAge a(21);  // Must use IMPLEMENT_DYNAMIC, IMPLEMENT _DYNCREATE, or

             // IMPLEMENT_SERIAL

ASSERT( a.IsKindOf( RUNTIME_CLASS( CAge ) ) );

ASSERT( a.IsKindOf( RUNTIME_CLASS( CObject ) ) );

CObject::IsSerializable

Tests whether this object is eligible for serialization.

BOOL IsSerializable( ) const;

Return Value

Nonzero if this object can be serialized; otherwise 0.

Remarks

For a class to be serializable, its declaration must contain the DECLARE_SERIAL macro, and the implementation must contain the IMPLEMENT_SERIAL macro.

Note

Do not override this function.

Example

See CObList::CObList for a listing of the CAge class used in all CObject examples.

Copy Code

// example for CObject::IsSerializable

CAge a(21);

ASSERT( a.IsSerializable() );

CObject::Serialize

Reads or writes this object from or to an archive.

virtual void Serialize(

   CArchive& ar

);

Parameters

A CArchive object to serialize to or from.

Remarks

You must override Serialize for each class that you intend to serialize. The overridden Serialize must first call the Serialize function of its base class.

You must also use the DECLARE_SERIAL macro in your class declaration, and you must use the IMPLEMENT_SERIAL macro in the implementation.

Use CArchive::IsLoading or CArchive::IsStoring to determine whether the archive is loading or storing.

Serialize is called by CArchive::ReadObject and CArchive::WriteObject. These functions are associated with the CArchive insertion operator (<<) and extraction operator (>>).

For serialization examples, see the article Serialization: Serializing an Object.

Example

See CObList::CObList for a listing of the CAge class used in all CObject examples.

Copy Code

// example for CObject::Serialize

void CAge::Serialize( CArchive& ar )

 CObject::Serialize( ar );

     if( ar.IsStoring() )

     ar <<>     else
     ar >> m_years;
 }

DECLARE_DYNAMIC

Adds the ability to access run-time information about an object's class when deriving a class from CObject.

DECLARE_DYNAMIC(class_name )

Parameters

class_name

The actual name of the class.

Remarks

Add the DECLARE_DYNAMIC macro to the header (.h) module for the class, then include that module in all .cpp modules that need access to objects of this class.

If you use the DECLARE_DYNAMIC and IMPLEMENT_DYNAMIC macros as described, you can then use the RUNTIME_CLASS macro and the CObject::IsKindOf function to determine the class of your objects at run time.

If DECLARE_DYNAMIC is included in the class declaration, then IMPLEMENT_DYNAMIC must be included in the class implementation.

IMPLEMENT_DYNAMIC

IMPLEMENT_DYNAMIC( class_name, base_class_name )

Parameters

class_name

The actual name of the class (not enclosed in quotation marks).

base_class_name

The name of the base class (not enclosed in quotation marks).

Remarks

Generates the C++ code necessary for a dynamic CObject-derived class with run-time access to the class name and position within the hierarchy. Use the IMPLEMENT_DYNAMIC macro in a .CPP module, then link the resulting object code only once.

For more information, see in Visual C++ Programmer’s Guide.

Example

// CAge.h

class CAge : public CObject

     int num;

public:

     DECLARE_DYNAMIC(CAge)

};

//==============

// CAge.cpp

#include "stdafx.h"

#include "CAge.h"

IMPLEMENT_DYNAMIC(CAge, CObject)

DECLARE_SERIAL

DECLARE_SERIAL( class_name )

Parameters

class_name

The actual name of the class (not enclosed in quotation marks).

Remarks

DECLARE_SERIAL generates the C++ header code necessary for a CObject-derived class that can be serialized. Serialization is the process of writing or reading the contents of an object to and from a file.

Use the DECLARE_SERIAL macro in a .H module, then include that module in all .CPP modules that need access to objects of this class.

If DECLARE_SERIAL is included in the class declaration, then IMPLEMENT_SERIAL must be included in the class implementation.

The DECLARE_SERIAL macro includes all the functionality of DECLARE_DYNAMIC and DECLARE_DYNCREATE.

You can use the AFX_API macro to automatically export the CArchive extraction operator for classes that use the DECLARE_SERIAL and IMPLEMENT_SERIAL macros. Bracket the class declarations (located in the .H file) with the following code:

#undef AFX_API

#define AFX_API AFX_EXT_CLASS

#undef AFX_API

#define AFX_API

For more information on the DECLARE_SERIAL macro, see in Visual C++ Programmer’s Guide.

Example

class CMyClass: public CObject

public:

   CMyClass();

   void Serialize( CArchive& archive );

   DECLARE_SERIAL(CMyClass)

};

IMPLEMENT_SERIAL

IMPLEMENT_SERIAL( class_name, base_class_name, wSchema )

Parameters

class_name

The actual name of the class (not enclosed in quotation marks).

base_class_name

The name of the base class (not enclosed in quotation marks).

wSchema

A UINT “version number” that will be encoded in the archive to enable a deserializing program to identify and handle data created by earlier program versions. The class schema number must not be –1.

Remarks

Generates the C++ code necessary for a dynamic CObject-derived class with run-time access to the class name and position within the hierarchy. Use the IMPLEMENT_SERIAL macro in a .CPP module; then link the resulting object code only once.

#undef AFX_API

#define AFX_API AFX_EXT_CLASS

#undef AFX_API

#define AFX_API

For more information, see the in Visual C++ Programmer’s Guide.

Example

// MyClass.cpp

#include "stdafx.h"

#include "MyClass.h"

IMPLEMENT_SERIAL( CMyClass, CObject, VERSIONABLE_SCHEMA | 2 )

CObject::IsKindOf

BOOL IsKindOf( const CRuntimeClass* pClass ) const;

Return Value

Nonzero if the object corresponds to the class; otherwise 0.

Parameters

pClass

A pointer to a CRuntimeClass structure associated with your CObject-derived class.

Remarks

Tests pClass to see if (1) it is an object of the specified class or (2) it is an object of a class derived from the specified class. This function works only for classes declared with the DECLARE_DYNAMIC or DECLARE_SERIAL macro.

Do not use this function extensively because it defeats the C++ polymorphism feature. Use virtual functions instead.

Example

See CObList::CObList for a listing of the CAge class used in all CObject examples.

// example for CObject::IsKindOf

CAge a(21); // Must use IMPLEMENT_DYNAMIC or IMPLEMENT_SERIAL

ASSERT( a.IsKindOf( RUNTIME_CLASS( CAge ) ) );

ASSERT( a.IsKindOf( RUNTIME_CLASS( CObject ) ) );

CObject::GetRuntimeClass

virtual CRuntimeClass* GetRuntimeClass( ) const;

Return Value

A pointer to the CRuntimeClass structure corresponding to this object’s class; never NULL.

Remarks

There is one CRuntimeClass structure for each CObject-derived class. The structure members are as follows:

LPCSTR m_lpszClassName A null-terminated string containing the ASCII class name.
int m_nObjectSize The size of the object, in bytes. If the object has data members that point to allocated memory, the size of that memory is not included.
UINT m_wSchema The schema number ( – 1 for nonserializable classes). See the IMPLEMENT_SERIAL macro for a description of schema number.
CObject* ( PASCAL* m_pfnCreateObject )( ) A function pointer to the default constructor that creates an object of your class (valid only if the class supports dynamic creation; otherwise, returns NULL).
CRuntimeClass* ( PASCAL* m_pfn_GetBaseClass )( ) If your application is dynamically linked to the AFXDLL version of MFC, a pointer to a function that returns the CRuntimeClass structure of the base class.
CRuntimeClass* m_pBaseClass If your application is statically linked to MFC, a pointer to the CRuntimeClass structure of the base class.

Feature Only in Professional and Enterprise Editions Static linking to MFC is supported only in Visual C++ Professional and Enterprise Editions. For more information, see .

This function requires use of the IMPLEMENT_DYNAMIC or IMPLEMENT_SERIAL macro in the class implementation. You will get incorrect results otherwise.

Example

See CObList::CObList for a listing of the CAge class used in all CObject examples.

// example for CObject::GetRuntimeClass

CAge a(21);

CRuntimeClass* prt = a.GetRuntimeClass();

ASSERT( strcmp( prt->m_lpszClassName, "CAge" ) == 0 );

RUNTIME_CLASS

RUNTIME_CLASS( class_name )

Parameters

class_name

The actual name of the class (not enclosed in quotation marks).

Remarks

Use this macro to get the run-time class structure from the name of a C++ class.

RUNTIME_CLASS returns a pointer to a CRuntimeClass structure for the class specified by class_name. Only CObject-derived classes declared with DECLARE_DYNAMIC, DECLARE_DYNCREATE, or DECLARE_SERIAL will return pointers to a CRuntimeClass structure.

For more information, see in Visual C++ Programmer’s Guide.

Example

// example for RUNTIME_CLASS

CRuntimeClass* prt = RUNTIME_CLASS( CAge );

ASSERT( lstrcmp( prt->m_lpszClassName, "CAge" )  == 0 );

What do you want to do?

Deriving a Class from CObject

This article describes the minimum steps necessary to derive a class from CObject. Other CObject class articles describe the steps needed to take advantage of specific CObject features, such as serialization and diagnostic debugging support.

In the discussions of CObject, the terms "interface file" and "implementation file" are used frequently. The interface file (often called the header file, or .H file) contains the class declaration and any other information needed to use the class. The implementation file (or .CPP file) contains the class definition as well as the code that implements the class member functions. For example, for a class named CPerson, you would typically create an interface file named PERSON.H and an implementation file named PERSON.CPP. However, for some small classes that will not be shared among applications, it is sometimes easier to combine the interface and implementation into a single .CPP file.

You can choose from four levels of functionality when deriving a class from CObject:

· Basic functionality: No support for run-time class information or serialization but includes diagnostic memory management.

· Basic functionality plus support for run-time class information.

· Basic functionality plus support for run-time class information and dynamic creation.

· Basic functionality plus support for run-time class information, dynamic creation, and serialization.

Classes designed for reuse (those that will later serve as base classes) should at least include run-time class support and serialization support, if any future serialization need is anticipated.

You choose the level of functionality by using specific declaration and implementation macros in the declaration and implementation of the classes you derive from CObject.

The following table shows the relationship among the macros used to support serialization and run-time information.

Macros Used for Serialization and Run-Time Information

Macro used	CObject::IsKindOf	CRuntimeClass:: CreateObject	CArchive::operator>> CArchive::operator<<
Basic CObject functionality	No	No	No
DECLARE_DYNAMIC	Yes	No	No
DECLARE_DYNCREATE	Yes	Yes	No
DECLARE_SERIAL	Yes	Yes	Yes

To use basic CObject functionality

· Use the normal C++ syntax to derive your class from CObject (or from a class derived from CObject).

The following example shows the simplest case, the derivation of a class from CObject:

Copy Code

class CPerson : public CObject

    // add CPerson-specific members and functions...

Normally, however, you may want to override some of CObject's member functions to handle the specifics of your new class. For example, you may usually want to override the Dump function of CObject to provide debugging output for the contents of your class. For details on how to override Dump, see the article Diagnostics: Dumping Object Contents. You may also want to override the AssertValid function of CObject to provide customized testing to validate the consistency of the data members of class objects. For a description of how to override AssertValid, see MFC ASSERT_VALID and CObject::AssertValid.

The article Specifying Levels of Functionality describes how to specify other levels of functionality, including run-time class information, dynamic object creation, and serialization.

Specifying Levels of Functionality

This article describes how to add the following levels of functionality to your CObject-derived class:

· Run-time class information

· Dynamic creation support

· Serialization support

For a general description of CObject functionality, see the article Deriving a Class from CObject.

To add run-time class information

1. Derive your class from CObject, as described in the Deriving a Class from CObject article.

2. Use the DECLARE_DYNAMIC macro in your class declaration, as shown here:

Copy Code

class CPerson : public CObject

    DECLARE_DYNAMIC( CPerson )

    // rest of class declaration follows...

};

3. Use the IMPLEMENT_DYNAMIC macro in the implementation file (.CPP) of your class. This macro takes as arguments the name of the class and its base class, as follows:

Copy Code
IMPLEMENT_DYNAMIC( CPerson, CObject )
Note
Always put IMPLEMENT_DYNAMIC in the implementation file (.CPP) for your class. The IMPLEMENT_DYNAMIC macro should be evaluated only once during a compilation and therefore should not be used in an interface file (.H) that could potentially be included in more than one file.

To add dynamic creation support

1. Derive your class from CObject.

2. Use the DECLARE_DYNCREATE macro in the class declaration.

3. Define a constructor with no arguments (a default constructor).

4. Use the IMPLEMENT_DYNCREATE macro in the class implementation file.

To add serialization support

1. Derive your class from CObject.

2. Override the Serialize member function.

Note

If you call Serialize directly, that is, you do not want to serialize the object through a polymorphic pointer, omit steps 3 through 5.

3. Use the DECLARE_SERIAL macro in the class declaration.

4. Define a constructor with no arguments (a default constructor).

5. Use the IMPLEMENT_SERIAL macro in the class implementation file.

Note

A "polymorphic pointer" points to an object of a class (call it A) or to an object of any class derived from A (say, B). To serialize through a polymorphic pointer, the framework must determine the run-time class of the object it is serializing (B), since it might be an object of any class derived from some base class (A).

Accessing Run-Time Class Information

This article explains how to access information about the class of an object at run time.

Note

MFC does not use the Run-Time Type Information (RTTI) support introduced in Visual C++ 4.0.

If you have derived your class from CObject and used the DECLARE_DYNAMIC and IMPLEMENT_DYNAMIC, the DECLARE_DYNCREATE and IMPLEMENT_DYNCREATE, or the DECLARE_SERIAL and IMPLEMENT_SERIAL macros explained in the article Deriving a Class from CObject, the CObject class has the ability to determine the exact class of an object at run time.

This ability is most useful when extra type checking of function arguments is needed and when you must write special-purpose code based on the class of an object. However, this practice is not usually recommended because it duplicates the functionality of virtual functions.

The CObject member function IsKindOf can be used to determine if a particular object belongs to a specified class or if it is derived from a specific class. The argument to IsKindOf is a CRuntimeClass object, which you can get using the RUNTIME_CLASS macro with the name of the class.

To use the RUNTIME_CLASS macro

· Use RUNTIME_CLASS with the name of the class, as shown here for the class CObject:

Copy Code

CRuntimeClass* pClass = RUNTIME_CLASS( CObject );

You will rarely need to access the run-time class object directly. A more common use is to pass the run-time class object to the IsKindOf function, as shown in the next procedure. The IsKindOf function tests an object to see if it belongs to a particular class.

To use the IsKindOf function

1. Make sure the class has run-time class support. That is, the class must have been derived directly or indirectly from CObject and used the DECLARE_DYNAMIC and IMPLEMENT_DYNAMIC, the DECLARE_DYNCREATE and IMPLEMENT_DYNCREATE, or the DECLARE_SERIAL and IMPLEMENT_SERIAL macros explained in the article Deriving a Class from CObject.

2. Call the IsKindOf member function for objects of that class, using the RUNTIME_CLASS macro to generate the CRuntimeClass argument, as shown here:

Copy Code
// in .H file class CPerson : public CObject { DECLARE_DYNAMIC( CPerson ) public: CPerson(){}; // other declaration }; // in .CPP file IMPLEMENT_DYNAMIC( CPerson, CObject ) void SomeFunction(void) { CObject* pMyObject = new CPerson; if(pMyObject->IsKindOf( RUNTIME_CLASS( CPerson ) ) ) { //if IsKindOf is true, then cast is all right CPerson* pmyPerson = (CPerson*) pMyObject ; ... delete pmyPerson; } ... delete [MyObject]; }
Note
IsKindOf returns TRUE if the object is a member of the specified class or of a class derived from the specified class. IsKindOf does not support multiple inheritance or virtual base classes, although you can use multiple inheritance for your derived Microsoft Foundation classes if necessary.

One use of run-time class information is in the dynamic creation of objects. This process is discussed in the article Dynamic Object Creation.

For more detailed information on serialization and run-time class information, see the articles Files in MFC and Serialization.

Dynamic Object Creation

This article explains how to create an object dynamically at run time. The procedure uses run-time class information, as discussed in the article Accessing Run-Time Class Information.

To dynamically create an object given its run-time class

· Use the following code to dynamically create an object by using the CreateObject function of the CRuntimeClass. Note that on failure, CreateObject returns NULL instead of raising an exception:

Copy Code

CRuntimeClass* pRuntimeClass = RUNTIME_CLASS( CMyClass );

CObject* pObject = pRuntimeClass->CreateObject();

ASSERT( pObject->IsKindOf( RUNTIME_CLASS( CMyClass ) ) );

Object Dump Customization

This topic applies to:

Visual Studio Edition	Visual Basic	C#	C++	J#
Express	No	No	Native	No
Standard	No	No	Native	No
Pro/Team	No	No	Native	No

When you derive a class from CObject, you can override the Dump member function to provide additional information when you use DumpAllObjectsSince to dump objects to the Output window.

The Dump function writes a textual representation of the object's member variables to a dump context (CDumpContext). The dump context is similar to an I/O stream. You can use the append operator (<<) to send data to a CDumpContext.

When you override the Dump function, you should first call the base class version of Dump to dump the contents of the base class object. Then output a textual description and value for each member variable of your derived class.

The declaration of the Dump function looks like this:

Copy Code

class CPerson : public CObject

{

public:

#ifdef _DEBUG

virtual void Dump( CDumpContext& dc ) const;

#endif

CString m_firstName;

CString m_lastName;

// And so on...

};

Because object dumping only makes sense when you are debugging your program, the declaration of the Dump function is bracketed with an #ifdef _DEBUG / #endif block.

In the following example, the Dump function first calls the Dump function for its base class. It then writes a short description of each member variable along with the member's value to the diagnostic stream.

Copy Code

#ifdef _DEBUG

void CPerson::Dump( CDumpContext& dc ) const

{

// Call the base class function first.

CObject::Dump( dc );

// Now do the stuff for our specific class.

dc << "last name: " <<>

<< "first name: " <<>

}

#endif

You must supply a CDumpContext argument to specify where the dump output will go. The Debug version of MFC supplies a predefined CDumpContext object named afxDump that sends output to the debugger.

Copy Code

CPerson* pMyPerson = new CPerson;

// Set some fields of the CPerson object.

//...

// Now dump the contents.

#ifdef _DEBUG

pMyPerson->Dump( afxDump );

#endif

Transperent Edit Box

2008-11-11T22:12:00.000-08:00

Creating a transparent edit box

Background of a window is not always white. Sometimes it may be green or gray. When we create a control like combo box or edit box the color of these controls turn out to be same as the background color of the window. This article seir background by default is white. White colored controls on green or gray background do not look very impressive. So instead of letting the edit box or the list box getting created in white color we can create them as controls with transparent background. When we do so the background knows how to create a transparent edit box so that it will get displayed in the color which is same as its parent window. You can use similar logic for other controls as well. An edit box is created using the object of CEdit class. The CWnd::OnCtlColor( ) function has been overridden in the view class CChildview. In this function a NULL brush has been created and returned. The OnCtlColor( ) function is called whenever the child control is to be drawn. Since a NULL brush is returned from the function the control is redrawn using the NULL brush thereby creating a transparent edit box.

Download

Owner Drawn Combo Box

2008-11-11T22:10:00.000-08:00

Creating ownerdrawn combo box

By default, items in a combo box consist of strings of text. Should you need a combo box that displays graphical images instead of text, you can create an owner-drawn combo box. To create the owner-drawn combo box a class is derived from CComboBox. An object of the derived class is created and CComboBox::Create( ) is called to create the combo box. CComboBox::MeasureItem( ) and CComboBox::DrawItem( ) are overridden. When an item in an owner-drawn combo box needs to be drawn (or redrawn), Windows sends the combo box's parent a WM_DRAWITEM message with a pointer to a DRAWITEMSTRUCT structure containing all the information required to do the drawing, including a device context handle and a 0-based index identifying the item to be drawn. Before the first WM_DRAWITEM message arrives, the combo box's parent receives one or more WM_MEASUREITEM messages requesting the height of the items in the combo box. In this program an array of colors is created which is used to draw the combo box items when the window receives WM_DRAWITEM message. The DeflateRect( ) function decides the gap between two items. A rectangle is drawn around the item on which the cursor is placed. The color for highlighted item is retrieved using ::GetSysColor( ) function.

Download

Creatin Directory Tree Control With Check Boxes

2008-11-11T22:09:00.000-08:00

This program displays entire directory structure of all the drives in a tree control. The tree control also displays check boxes in front of each directory which can be used to select or deselect the directory. We have created round check boxes instead of traditional square check boxes. User can check or uncheck the directory by clicking on the check box. Whether all of the sub-directories are checked can be known by the grayed bitmap displayed in front of the parent directory.

Generally directory tree with check boxes is needed while creating an anti-viral software in which user can check or uncheck the directories depending upon whether he wants to scan the directory or not.
Check boxes actually are bitmaps using which image list is created and images are loaded depending on the status (Checked/Unchecked) of the directory.

In this program, firstly only the drives are displayed with checked status. When user double clicks on the label or clicks on the plus sign the tree is expanded and directories of that drive are displayed in. Since the drive is checked all the directories also are displayed with checked sign. Now if the drive is unchecked all the directories also become unchecked.
This control only displays directories. You can anytime modify this program to display files of the selected directory.

Download