1. C++ Classes

1.1 Classes

We split the program into two files, a header file (which we give the extension .h) and a program file (which we give the extension .cpp). The header file contains the class declarations for one or more classes, and the program file contains method definitions. The program file includes the header so that it knows about the declarations.

The scope operator :: is used when declaring methods. If I have a class called Foo and it has a method called myMethod, when defining the function in the .cpp file, I would call it Foo::myMethod. The scope operator is needed because a .cpp file could contain method definitions for multiple classes, so we need to know for which class each method is being defined. In the example class below, we add a myMethod member function, and you can see the scope operator in use. A main function is also provided so you can run this program.

class Foo {
public:
    Foo();
    Foo(int a); // second constructor
    ~Foo();
    int myMethod(int a, int b);
};  // note the semicolon after the class declaration!

#include "Foo.h"

Foo::Foo()  // scope operator :: helps define constructor for class Foo
{
    cout << "I am a happy constructor" << endl;
    _num = 5;
}

Foo::Foo(int a)
{
	cout << "Calling the second constructor." << endl;
	_num = a;
}

Foo::~Foo()
{
    cout << "I am a happy destructor that would do cleanup here." << endl;
}

int Foo::myMethod(int a, int b)
{
    return a + b + _num;
}

#include "Foo.h"
int main()
{
	int i;
	Foo foo, foo1(9);
	 
	i = foo.myMethod(10, 11); //call foo's myMethod()
	cout << " i is : " << i << endl;

	i = foo1.myMethod(10, 11); // call foo1's myMethod()
	cout << " i is : " << i << endl;

	return 0;
}

It's crucial that you remember the semicolon at the end of a C++ class declaration. Failure to include the semicolon will cause a compile-time error, but not at the end of the class declaration. Often the error will be reported in a perfectly viable file, such as in a header file that you included.

1.2 Protection

There are 3 levels of protection for class members in C++: public, private, and protected. Protected members are only accessible to subclasses. As you've probably noticed, you put members in sections by their protection level. You can have as many sections of each protection level in a class declarations as you would like. If no modifier is specified, the protection level defaults to private.

C++ also has an additional form of control over protection levels called friendship that allows for a finer grain of protection.  To find out more, consult your text books.

1.3 Inlining

Methods can be declared and defined in the same place by defining methods in the header file. This is known in C++ as inlining. Inlining is typically used only for very short methods such as accessors and mutators. For short routines, C++ can frequently optimize things which are declared inline by inserting the code for the routine directly in the calling function, thus avoiding the large overhead of calling a function. So, it is often to your advantage to inline definitions of accessors, mutators, and other short, frequently called functions that don't require use of an external library.

//Color.h
class Color
{
public:
   Color();
   int getRed() {return _red;}       // inline declaration
   void setRed(int red) {_red=red;}  // inline declaration
   /* same for green and blue */
protected:
   int _red, _green, _blue;
};

Note that medium and large-sized functions should not be inlined, even if they are frequently used. Since the the compiler will insert the code for inlined functions wherever the function is called, inlining large functions will increase the size of your program, possibly slowing it down.

2. Visual Studio C++

The Visual C++ package contains more than a compiler; it also contains all the libraries, examples, and documentation needed to create applications for Windows 95, 98 and Windows NT.

2.1 Creating Your First C++ Program

For your first C++ program, you will build a console mode application that displays a greeting message. This (i.e. a console mode application)is the kind of VC++ programs that you will build for all your lab and class exercises/assignments. 

Console mode programs are often simpler to build than Windows applications, and this example will take you through the steps of creating, building and executing a program in Visual C++. We first assume that you use the built-in code editor in Visual Studio to edit your code; then we will show you how to build and run your C++ programs that you have created with any external editors. 

2.1.1 How to start

Press  on your window desktop, choose Microsoft Visual Studio 6.0 from the popup menu, then choose Microsoft Visual C++.

The following figure shows different areas of a Visual Studio work window.
 

2.1.2 Starting Your First Program

Before you create your program in C++, you need to create a work space for it.  This work space will hold all the files that are parts of your program, including the C++ source code, the header files, etc.  To create a new work space, click on File from the Microsoft Visual C++ window (see above figure) and select New.  Choose from the project list.  Type in a project name and select a directory for this project:

After this, click on OK to go to the next screen.  Do not worry about the options in the next screen; simple click Finish and then OK and a work space for your first VC++ project is created.  

Next, you would type in your C++ source code.

Select File-->New from the main menu, and select C++ Source File from the New dialog box under the Files tab.  Type in the file name: hello.cpp under the "File name".  This file will be added to the hello work space that we have just created, and a blank document will be opened for editing

Exercise:

Type in the following program in the source code editor:

// FILE:     hello.cpp
// PURPOSE:  An example for simple I/O steam 

#include <iostream.h>
main()
{
	char name[50];
	cout << "Please enter your name:" << endl;
	
	cin >> name;
	cout << "Hello, " << name << endl;
	return 0;
}

Save your file after you have finished editing it.

2.1.3 Building the hello Project

In order to compile any code in Visual C++, you have to create a project. A project holds three different types of information:

1) It remembers all of the source code files that combine together to create one executable. In this simple example, the file hello.cpp will  be the only source file, but in larger applications you often break the code up into several different files to make it easier to understand (and  also to make it possible for several people to work on it  simultaneously). The project maintains a list of the different source files and compiles all of them as necessary each time you want to create a  new executable. 

2) It remembers compiler and linker options particular to this specific application. For example, it remembers which libraries to link into the executable, whether or not you want to use pre-compiled headers, and so on.

3) It remembers what type of project you wish to build: a console application, a windows application, etc.

If you are familiar with makefiles, then it is easy to think of a project as a machine-generated makefile that has a very easy-to-understand user interface to manipulate it. For now we will create a very simple project file and use it to compile hello.cpp.

Exercise:

1. Compile the hello project by selecting Build --> Compile hello.cpp from the main menu.
It simply compiles the source file and forms the object file (hello.obj) for it. It does not perform a link, so it is useful only for quickly compiling a file to check for errors.

2. Select Build -->Build hello.exe from the menu bar to link the program.
It compiles all of the source files in the project that have been modified since the last build, and then links them to create an executable.

3. Choose Build --> to run the program. A DOS window will popup.

If errors or warnings are displayed in the Build status window, there is probably an error in the source file. Check your source file again for missing semicolons, quotes, or braces.

2.2 How to compile, link and execute a program with multiple files?

The above section shows the procedure of creating a C++ program with only one file component: hello.cpp, and we used the build-in VC++ source code editor to edit the file.  However, when you are working on a large program, you would break your program into smaller, more manageable parts.  In other words, your project would contain more than one C++ source files.  Moreover, you might not have used the VC++ source code editor to edit your files.

The following section demonstrates how to create, compile, and execute  a VC++ project with more than one file.

Exercise:

2.2.1 Ftp multiple files from pub/class/170/ftp/cpp to C:\workarea.

Double click the icon on the windows desktop then click OK on the resultant window:
Next, double click the green up arrrow in the window similar to the following:
Then double click on the following folder icons  ( 170 folder / ftp folder / cpp folder).
Make sure your local system is C:\Workarea and ASCII is being selected.
While holding down the Ctrl key, select date.h (header file), date.cpp and main.cpp,  then press .

Once the files are transferred to the local System, click exit to quit the ftp program.

2.2.2 Creating a  Microsoft visual C++ work space

Step 1.   Select File --> New.
Step 2.   Select Win32 Console Application.
Step 3.   Set the project location to C:\Workarea.
Step 4.   Set the project name to lab1.
Step 5.   Select OK to create the project.
Step 6.   Select an empty project, click finish and click OK.

Once the project is created, you add files to the project, as follows:

1.Select Project --> Add to Project --> Files.
2.Choose C:\Workarea, highlight the .h and .cpp files in the project: date.cpp, date.h and main.cpp
3.Select OK to add the files to the project.

2.2.3 Compile, build and execute your progam

1. Select Build  --> Build lab1.exe (This will compile and link the files).
2. Select Build --> Execute lab1.exe.

3. Debugging C++ Programs

"To err is human...", so Alexander Pope said.  And if he were living at the present time, Pope might as well be commenting on the process of programming. If you are like most of the people, your program will not work as you expect the first time you build them.  This is true even with the simplest programs.  Therefore, debugging is a very important process in programming; sometimes it is even more time-consuming than writing the program.

Visual Studio comes with a very powerful debugging utility which helps you locating programming errors.  It is very important to keep in mind that in order to use the debugger in VC++, your program should compile with no errors.  In other words, debugger can only help you spot runtime errors. 

In the following, we briefly introduce some common commands in the debugger, and then take you through the debugging of a sample program.

To start the debugger, a project must be open in the development environment. Once you have opened the project you wish to debug, the debugger is invoked by choosing any of the debug commands. The debug commands are located in the "Build" menu under the sub-heading "Start Debug." You can access several other debug commands, in addition to those in the menu, from the debug toolbar, which is displayed by selecting "customize" from the "Tools" menu. This toolbar is displayed automatically when you invoke the debugger. Some of the more common commands are listed below:

3.1 Useful commands

3.2 Debugging a sample program

4. Recursive Function Shown via the Debugger

The point is, that you keep going until you get to some predefined base condition.

Consider the following example of a simple recursive function:

//    Filename: 170Power.cpp
//
//    Purpose: To illustrate a recursive function.
//             Call the function with a value and a power.
//             Base condition is when power value = 1.

#include <iostream>
using namespace std;

int PowerFunction(int, int);

int main()
{
    int Value;
    int PowerValue;

    cout << endl << "This program raises a number to a given power."
         << endl << "Enter number value, and power: ";
    cin >> Value >> PowerValue;

    cout << endl << "The result is: "
         << PowerFunction(Value, PowerValue)
		 << endl;
    return 0;
}


int PowerFunction(int p_Value, int p_PowerValue)

{
    if (p_PowerValue == 1)      // Base condition

        return p_Value;
    else
        return p_Value * PowerFunction(p_Value, p_PowerValue -1);
}

Let's go through the steps you'd need to use in the Visual C++ environment to create that program and run it under the debugger.

1. Start Visual Studio C++.

2. Select File -> New.
   • Win32 Console Application.
   • Project Name: 170Power
   • Location: C:\Workarea\170Power
   • OK
   • Finish
   • OK.

3. Select File -> New.
   • C++ Source File
   • Filename: 170Power.cpp

4. Use your mouse to select the source code from this web page and paste it into the Visual C++ Edit area.

5. Save the file in Visual C++.

6. Build -> Compile to compile the program.

7. Build -> Build 170Power.exe to run the program.
   Run the program with the values 2 and 3, and you should get a result of 8.

8. Now, run the program with the debugger so you can see what's happening.
   Set a breakpoint on the Base Condition in the recursive function. i.e. if (p_PowerValue == 1)
   Remember, to set a breakpoint, click on the line of code, and then click on the little hand. A red dot should appear beside the line of code you've just selected.

9. Build -> Start Debug -> Go to run with the debugger.

10. After you enter the values 2 and 3, you should observe the values of p_PowerValue and p_Value as you execute the function by continually clicking on the Step Into button.

11. Note: If you click on the StepInto button too many times, you get into some strange looking code in the Edit area. Just double-click 170Power.cpp in the FileView window at the left to get back to your program.

The original text for this page was created by Qiang Hu.

This page last modified: Friday, 21-Aug-2020 15:23:39 CST

Accessed     times.

CS Dept Home Page

CS Dept Class Files

CS170 Class Files