Chapter 2
BASIC ELEMENTS IN C++
Programming Fundamentals 1
Chapter 2
n Program structures
n Data types and operators
n Variables and declaration statements
n Integer quantifiers
n Some sample programs
Programming Fundamentals 2
Modular programs
n A large program should be organized as several
interrelated segments: The segments are called
modules.
n A program which consists of such modules is called
a modular program.
n In C++, modules can be classes or functions.
n A function is a program segment that transforms the
data it receives into a finished result.
Programming Fundamentals 3
Function
n Each function must have a name.
n Names or identifiers in C++ can made up of any
combination of letters, digits, or underscores selected
according to the following rules:
- Identifiers must begin within an uppercase or lowercase ASCII
letter or an underscore (_).
- You can use digits in an identifier, but not as the first character.
You are not allowed to use special characters such as $, &, * or %.
- Reserved words cannot be used for variable names.
n Example:
DegToRad intersect addNums
FindMax1 _density slope
Programming Fundamentals 4
The main() function
n The main() function is a special function that runs automatically
when a program first executes.
n All C++ programs must include one main() function. All other
functions in a C++ program are executed from the main().
n The first line of the function, in this case int main() is called a
function header line.
n The function header line contains three pieces of information:
1. What type of data, if any, is returned from the function.
2.The name of the function
3. What type of data, if any, is sent into the function.
Programming Fundamentals 5
The main() function (cont.)
int main()
{
program statements in here
return 0.
}
The line
return 0;
is included at the end of every main function. C++ keyword
return is one of several means we will use to exit a
function. When the return statement is used at the end of
main(), the value 0 indicates that the program has
terminates successfully.
Programming Fundamentals 6
The cout Object
n The cout object is an output object that sends data
given to it to the standard output display device.
n To send a message to the cout object, you use the
following pattern:
cout << “text”;
n The insertion operator, <<, is used for sending text
to an output device.
n The text portion of cout statement is called a text
string.
Programming Fundamentals 7
A simple program
Example 2.1.1
#include <iostream.h> header file
int main()
{
cout << "Hello world!";
return 0;
}
§ A header file is a file with an extension of .h that is
included as part of a program. It notifies the
compiler that a program uses run-time libraries.
§ All statements in C++ must end with a semicolon.
Programming Fundamentals 8
The iostream classes
n The iostream classes are used for giving C++
programs input capabilities and output capabilities.
n The header file for the iostream class is iostream.h.
n The #include statement is one of the several
preprocessor directives that are used with C++.
Example: To include the iostream.h file you use the
following preprocessor directives:
#include <iostream.h>
Programming Fundamentals 9
Preprocessor directives
n The preprocessor is a program that runs before the
compiler.
n When the preprocessor encounters an #include
statement, it places the entire contents of the
designated file into the current file.
n Preprocessor directives and include statements
allow the current file to use any of the classes,
functions, variables, and other code contained within
the included file.
Programming Fundamentals 10
i/o manipulator
n An i/o manipulator is a special function that can be
used with an i/o statement.
n The endl i/o manipulator is part of iostream classes
and represents a new line character.
n Example:
cout << “Program type: console application” << endl;
cout << “Create with: Visual C++ “<< endl;
cout << “Programmer: Don Gesselin” << endl;
Programming Fundamentals 11
Comments
n Comments are lines that you place in your code to
contain various type of remarks.
n C++ line comments are created by adding two
slashes (// ) before the text you want to use as a
comment.
n Block comments span multiple lines. Such
comments begin with /* and end with the symbols */.
Programming Fundamentals 12
Example:
int main()
{
/*
This line is part of the block comment.
This line is also part of the block
comment.
*/
cout << “Line comment 1 “;
cout << “Line comment 2 “;
// This line comment takes up an entire line.
return 0;
}
Programming Fundamentals 13
DATA TYPES AND OPERATORS
Data Types
n A data type is the specific category of information
that a variable contains.
n There are three basic data types used in C++:
integers, floating point numbers and characters.
Programming Fundamentals 14
Integer data type
n An integer is a positive or negative number with no
decimal places.
n Examples:
- 259 -13 0 200
Programming Fundamentals 15
Floating Point Numbers
n A floating point number contains decimal places or
is written using exponential notations.
-6.16 -4.4 2.7541 10.5
n Exponential notation, or scientific notation is a way
of writing a very large numbers or numbers with
many decimal places using a shortened format.
2.0e11 means 2*1011
Programming Fundamentals 16
The Character Data Type
n To store text, you use the character data type. To store one
character in a variable, you use the char keyword and place the
character in single quotation marks.
n Example:
char cLetter = ‘A’;
n Escape Sequence
The combination of a backlash (\) and a special character is
called an escape sequence.
n Example:
\n move to the next line
\t move to the next tab
Programming Fundamentals 17
Arithmetic Operators
n Arithmetic operators are used to perform mathematical
calculations, such as addition, subtraction, multiplication, and
division.
Operator Description
----------------------------------------------------------------------
+ Add two operands
- Subtracts one operand from another operand
* Multiplies one operand by another operand
/ Divides one operand by another operand
% Divides two operands and returns the remainder
n A simple arithmetic expression consists of an arithmetic
operator connecting two operands in the form:
operand operator operand
Programming Fundamentals 18
Examples:
3+7
18 – 3
12.62 + 9.8
12.6/2.0
Example 2.2.1
#include <iostream.h>
int main()
{
cout << "15.0 plus 2.0 equals " << (15.0 + 2.0) << '\n'
<< "15.0 minus 2.0 equals " << (15.0 - 2.0) << '\n'
<< "15.0 times 2.0 equals " << (15.0 * 2.0) << '\n'
<< "15.0 divided by 2.0 equals " << (15.0 / 2.0) << '\n';
return 0;
}
Programming Fundamentals 19
Integer Division
n The division of two integers yields integer result.
Thus the value of 15/2 is 7.
n Modulus % operator produces the remainder of an
integer division.
n Example:
9%4 is 1
17%3 is 2
14%2 is 0
Programming Fundamentals 20
Operator Precedence and Associativity
n Expressions containing multiple operators are evaluated by the
priority, or precedence, of the operators.
Operator Associativity
--------------------------------------------
unary - Right to left
*/% Left to right
+- Left to right
§ Example:
8 + 5*7%2*4
¯ ¯¯ ¯
4 1 2 3
Programming Fundamentals 21
VARIABLES
n One of the most important aspects of programming
is storing and manipulating the values stored in
variables.
n Variable names are also selected according to the
rules of identifiers:
- Identifiers must begin with an uppercase or
lowercase ASCII letter or an underscore (_).
- You can use digits in an identifier, but not as the first
character. You are not allowed to use special characters
such as $, &, * or %.
- Reserved words cannot be used for variable
names.
Programming Fundamentals 22
Identifiers
n Example: Some valid identifiers
my_variable
Temperature
x1
x2
_my_variable
n Some invalid identifiers are as follows:
%x1 %my_var @x2
Programming Fundamentals 23
Declaration Statements
n In C++ you can declare the data types of variables using the
syntax:
type name;
The type portion refers to the data type of the variable.
n The data type determines the type of information that can be
stored in the variable.
n Example:
int sum;
long datenem;
double secnum;
Programming Fundamentals 24
Rules of variable declaration
n Rules:
1. A variable must be declared before it can be
used.
2. Declaration statements can also be used to store
an initial value into declared variables.
Example:
int num = 15;
float grade1 = 87.0;
n Note: Declaration statement gives information to the
compiler
q rather than a step in the algorithm.
Programming Fundamentals 25
Example 2.2.1
#include <iostream.h>
int main()
{
float grade1 = 85.5;
float grade2 = 97.0;
float total, average;
total = grade1 + grade2;
average = total/2.0; // divide the total by 2.0
cout << "The average grade is " << average << endl;
return 0;
}
The output of the above program:
The average grade is 91.25
Programming Fundamentals 26
Assignment statement
n Let notice the two statements in the above program:
total = grade1 + grade2;
average = total/2.0;
n Each of these statement is called an assignment
statement because it tells the computer to assign
(store) a value into a variable.
n Assignment statements always have an equal (=)
sign and one variable name on the left of this sign.
n The value on the right of the equal sign is assigned
to the variable on the left of the equal sign.
Programming Fundamentals 27
Display a Variable’s Address
n Every variable has three major items associated with
it:
- its data type
- value
- the address of the variable.
n To see the address of a variable, we can use address
operator, &, which means “the address of “.
n For example, &num means the address of num.
Programming Fundamentals 28
Example 2.2.2
#include <iostream.h>
int main()
{
int num;
num = 22;
cout << "The value stored in num is " << num << endl;
cout << "The address of num = " << &num << endl;
return 0;
}
The output of the above program:
The value stored in num is 22
The address of num = 0x8f5afff4
The display of addresses is in hexadecimal notation.
Programming Fundamentals 29
INTEGER QUANTIFIERS
n C++ provides long integer, short integer, and
unsigned integer data types.
n These three additional integer data types are
obtained by adding the quantifier long, short or
unsigned to the integer declaration statements.
n Example:
long integer days;
unsigned int num_of_days;
Programming Fundamentals 30
Unsigned integers
n The reserved words unsigned int are used to specify
an integer that can only store nonnegative numbers.
Data type Storage Number Range
-------------------------------------------------------------------
short int 2 bytes -32768 to 32767
unsigned int 2 bytes 0 to 65535
Programming Fundamentals 31
Data Type Conversions
n An expression that contains only integer operands is called an
integer expression, and the result of the expression is an
integer value.
n An expression that contains only floating point operands
(single and double precision) is called a floating point
expression, and the result of such an expression is a floating
point value.
n An expression containing both integer and floating point
operands is called a mixed mode expression.
n Example:
int a;
float x = 2.5;
a = x + 6; // x + 6 is a mixed mode expression
Programming Fundamentals 32
Data Type Conversion Rules
The general rules for converting integer and floating point
operands in mixed mode expressions were as follows:
1. If both operands are either character or integer operands:
• when both operands are character, short or integer data types,
the result of the expression is an integer value.
• when one of the operand is a long integer, the result is a long
integer, unless one of the operand is an unsigned integer. In the
later case, the other operand is converted to an unsigned integer
value and the resulting value of the expression is an unsigned value.
2. If any one operand is a floating point value:
• when one or both operands are floats, the result of the
operation is a float value;
• when one or both operands are doubles, the result of the
operation is a double value;
• when one or both operands are long doubles, the result of the
operation is a long double value;
Programming Fundamentals 33
n Note: Converting values to lower types can result in incorrect
values. For example, the floating point value 4.5 gives the value
4 when it is converted to an integer value.
Data types
--------------
long double ¬ highest type
double
float
unsigned long
long int
unsigned int
int
short in
char ¬ lowest type
Programming Fundamentals 34
Determining Storage Size
n C++ provides an operator for determining the
amount of storage your compiler allocates for each
data type. This operator is the sizeof() operator.
n Example:
sizeof(num1)
sizeof(int)
sizeof(float)
The item in parentheses can be a variable or a data
type.
Programming Fundamentals 35
Example 2.4.1
#include <iostream.h>
int main()
{
char c;
short s;
int i;
long l;
float f;
double d;
long double ld;
cout << "sizeof c = " << sizeof(c)
<< "\tsizeof(char) = " << sizeof( char )
Programming Fundamentals 36
<< "\nsizeof s = " << sizeof(s)
<< "\tsizeof(short) = " << sizeof( short )
<< "\nsizeof i = " << sizeof (i)
<< "\tsizeof(int) = " << sizeof( int )
<< "\nsizeof l = " << sizeof(l)
<< "\tsizeof(long) = " << sizeof( long )
<< "\nsizeof f = " << sizeof (f)
<< "\tsizeof(float) = " << sizeof(float)
<< "\nsizeof d = " << sizeof (d)
<< "\tsizeof(double) = " << sizeof(double)
<< endl;
return 0;
}
Programming Fundamentals 37
The output of the above program:
sizeof c = 1 sizeof(char) = 1
sizeof s = 2 sizeof(short) = 2
sizeof i = 4 sizeof(int) = 4
sizeof l = 4 sizeof(long) = 4
sizeof f = 4 sizeof(float) = 4
sizeof d = 8 sizeof(double) = 8
Programming Fundamentals 38
