Visual C++ Programming Concepts

1. Development Software 2 – DOS200S
Compiled By WH. Olivier ©2013
Cape Peninsula University of Technology
Window Form Applications Using Visual C++
Variables, Constants and Calculations
Objectives and Learning Areas:
For this lesson you will learn how to do the follow:
1. Knowing the different data types
2. How to define constant and variable identifiers
3. The scope of identifiers and where to declare identifiers
4. How to convert data from one type to another.
Introduction
For any program that you will be developing in Visual C++, or any other computer language for that matter, has
three fundamental components to it. It is:
INPUT: what will be the input values that will be fed into the program by the user?
PROCESS: what are the operations to be performed by the program?
OUTPUT: what are the results that will be produced by the program as feedback to the user?
When designing an application program, the requirements for the application would state what the Inputs are, what
process must be performed on the input data, and what would be the output produced.
The components explained above are shown with the use of an application.
Storing and retrieving data
Data in the application above is stored in the Text property of the textBox object (control) on screen. For every
application that you develop, there must be a way to store and retrieve data. There are various ways in which to
store data and this is dependent on how you would want to use the data in the application. Here some way:
1. Constants. These are data types that are declared with a set value and cannot be changed throughout the
running of the application. A good example would be the number of months or number of days in a week.
const int WEEKDAYS = 7;
INPUTS
PROCESS
OUTPUT
INPUTS

2. Development Software 2 – DOS200S
Compiled By WH. Olivier ©2013
Cape Peninsula University of Technology
2. Variables. These identifiers are there to store data that are expected to change throughout the program.
When the user inputs different values, a calculation will produce different results for each input. Variables in
this case are best suited. An example would be a different price for a different item record.
double itemPrice;
3. Arrays. When you want to store a list or collection of related information, you can declare and array and
store the collection in it. Each individual item can them be reference via an index and using the same
identifier name. An example would be if you want to store a list of names or test scores.
int testScores[5];
4. Structures. This identifier is a user-defined data type which comprises of other data types and is designed to
suite the programmer needs. With this identifier, related variables are grouped into a single variable where
by each individual data member will be referenced using a access operator. An example would be related
student information like student number, name, subjects and scores.
struct StudDetail
{
int studNum;
string name;
string subjects[5];
};
Data Types and Usage
The table below shows the various data types that can be used in Visual C++. Also indicated are the managed and
unmanaged uses.
C++ Data
Type
Common Language
Runtime
(CLR) Data Types
(managed)
Primitive data
types
(unmanaged)
Use For Storage
Size in
Bytes
Sample data
Boolean Boolean bool True or False values 2 flag
Byte Byte - 0 – 255, binary data 1 singleNumber
Char - char Single Unicode character 2 Gender (M/F)
Date DateTime 1/1/0001 – 12/31/9999 8 currentDate
Decimal Decimal float Decimal fractions 16 Rand
Double Double double Double-precision floating-
point numbers
8 PI
Single Single Single-precision floating-
point numbers
4 Length
Short Int16 short Small integers 2 Age
Integer Int32 int Whole numbers 4 NumGoals
Long Int64 long Large whole numbers 8 IDnumber
String String^ string Alphanumeric data
(characters)
Varies Name
Object Object (class / struct) Any type of data 4

3. Development Software 2 – DOS200S
Compiled By WH. Olivier ©2013
Cape Peninsula University of Technology
Data declarations and scope of identifiers
Depending on where you declare an identifier, it can either be local or global. This means that if a variable is
declared within a function or procedure, it is local to that procedure or function. If, however, you would want that
identifier to be global, you would declare it outside of any function block.
Let’s look at the following example to illustrate local and global identifiers. A windows form application calculates
the gross salary by adding the basic salary to the bonus amounts. The calculation is done on the press of a button.
Local Variable Declarations
private: System::Void btnCalc_Click(System::Object^ sender, System::EventArgs^ e)
{
double basic = 0;
double bonus = 0;
basic = Double::Parse(txtBSalary->Text);
bonus = Double::Parse(txtBonus->Text);
double salary = basic + bonus;
txtGSalary->Text = "R " + salary.ToString("F");
}
Local variables can only be used within the function or procedure where it is declared in. This relates to the scope of
the identifier.
Global Variable Declarations
Global identifiers are not declared in any function or procedure. Their scope is global and therefore can be used in
any other function within the current form. There are two places in the code editor where global variables can be
declared.
The first area is in the ‘Required designer variable’ section. As shown below, it is just before the area where code for
all the controls on screen are generated.
/// <summary>
/// Required designer variable.
/// </summary>
Int32 intClickCounter;
Int32 intTimerCounter;
DateTime myTime;
#pragma region Windows Form Designer generated code
As the comment indicates, you can only declare variables in this area. Here you can use any data type which suites
the requirements.
The second area is just before the class definition of the current form as shown here below.
/// <summary>
/// Summary for Form1
/// </summary>
int globalNumber = 0;
public ref class Form1 : public System::Windows::Forms::Form
{...
Global variable declared in the ‘Require designer variable’ section cannot be initialized there. The best place to
initialize these variables is when the form is loaded as shown below.
private: System::Void Form1_Load(System::Object^ sender, System::EventArgs^ e)
{
intClickCounter = 0;
intTimerCounter = 30;
}
Local Variable declarations.
The variables are initialized to 0
Conversion from String to double.
The values on in the Text property
of the textbox control is converted
to double and assigned to the
double variables
Global Variable declarations. These
variables are declared in the
‘Required designer variable’ section.
Global Variable declarations.
Declared just before the Form1 class
definition. It is also initialized here.
Global Variables Initialized.
Variables are initialized to 0
and 30 respectably.

4. Development Software 2 – DOS200S
Compiled By WH. Olivier ©2013
Cape Peninsula University of Technology
Constant declarations
Constants can either be global or local. When they are declared locally, they are declared with in a procedure or
function. There are two ways in which to define constants.
- Using the const reserve word.
-
- Using the #define preprocessor
#pragma once
const int MONTHS = 12;
#define LENGTH 10
#define WIDTH 5
namespace SalaryCalc1 {...
Take note of where constants are being declared above. These are declared as global constants.
Converting values from one data type to another.
When working with values where by the user must enter data in a textbox and that data must be used in some
calculation, these values must be converted to an equivalent type which would allow the calculation to be done.
Consider the following screen layout of Salary Calculation Application;
In this example the user is requested to enter the Basic Salary and Bonus
amounts. On pressing the ‘Calculate Salary’ button, the application will take
the values in the textboxes as entered by the user and use that in a
calculation to produce the ‘Gross Salary’. Note that values entered in on
screen are all regarded as Strings and can therefore not be used within a
calculation. For this reason, these values must first be converted to an
appropriate format which would allow the calculation to be done. Here is
the code that would accomplish this.
private: System::Void btnCalc_Click(System::Object^ sender, System::EventArgs^ e)
{
double basic = Double::Parse(txtBSalary->Text);
double bonus = Double::Parse(txtBonus->Text);
double salary = basic + bonus;
txtGSalary->Text = "R " + salary.ToString("F");
}
Constant named MOUNT defined using const
reserve word
Constants named LENGTH and WIDTH defined
using #define preprocessor.
Converting from
String to double
Converting from
double to String