CSE 5311 Fundamentals of Computer

Science

C++ Programming

C++ Profile C++ was developed by Bjarne Stroustrup in the early

80’s at Bell Labs. C++ is a high-level language hybrid language.

It supports both object-oriented programming and procedural-based (structured) programming.

C++ grew out of C, which contributed to its rapid growth in popularity.

C++ is a compiled language (as opposed to an interpreted language such as visual basic or Java).

C is a subset of C++. A C++ compiler can compile any C program.

The C++ Compilation

Process

C++ Source Code

C++ Compiler Object file

Linker

Executable

C Library

C++ Library

ProgrammerLibrary

C/C++ Primitive Data Types

Primitive data types have a predefined meaning. The compiler has an intuitive understanding

of the attributes of each primitive type. Primitive data types can be broadly

categorized as either character or numeric. Numeric data types can be categorized as

either integer or floating point.

C/C++ Primitive Data Types Integer data types

unsigned long int long int unsigned int int unsigned short int short int

Signed integer values are stored in 2’s complement format

C/C++ Primitive Data Types Floating point data types

long double double float

Floating point values are usually stored in IEEE format

IEEE Floating Point Formats

The sign is represented by a single bit. A 1 bit represents a negative number and a 0 bit represents a positive numberIEEE Short Real exponents are stored as a 8-bit unsigned integer with a bias of 127 decimal (01111111 binary)

2’s Complement Representation Most modern computers use 2’s complement representation

to store signed integers. The high-order bit of an integer stored in 2’s complement

representation will contain a 0 if the number is positive and a 1 if the number is negative.

By taking the 2’s complement of an integer you are effectively multiplying the number by -1.

The 2’s complement of a positive integer results in its negative representation.

The 2’s complement of a negative integer results in its absolute value.

2’s Complement Representation Taking the 2’s complement of an integer is a 2-step

process. Step 1 - Flip all the bits in the number (0’s become 1’s

and 1’s become 0’s). This is also known as taking the 1’s complement of the number.

Step 2 - Add 1 to the 1’s complement representation of the number).

• In the process of adding 1, any carry out of the high-order position is lost. This is normal and not a problem in the world of computer arithmetic.

2’s Complement Representation Assume we are storing a positive 9 in a one-byte (8-bit

field) using 2’s complement representation. In binary it would appear as 00001001.

Now, take the 2’s complement of the number. Step 1 - flip the bits. 11110110 Step 2 - add 1. + 1 11110111

The result, 11110111, is the 2’s complement representation of -9.

If we were to take the 2’s complement of 11110111 (-9), we would get 00001001 (+9).

2’s Complement Arithmetic To confirm that 11110111 really does represent -9, we

should be able to add it to +9 and get a result of 0. Remember we are doing binary addition: 1 + 1 = 10.

11110111 (-9) + 00001001 (+9)

00000000 (0) As pointed out earlier, a carry out of the high-order position

is lost.

C/C++ Primitive Data Types

Character data types char Note: Neither C or C++ has a primitive

string type. Character values are stored in ASCII

C/C++ Primitive Data Types One of the frustrating things about the C/C++ primitive

data types is that the number of bytes allocated to each type may vary from platform to platform.

This can be a major hindrance to portability. Use the sizeof operator to find out the storage

allocation for a particular platform. For example

• cout << sizeof(int);• cout << sizeof(float);• cout << sizeof(double);

C++ OperatorsOperator Associativity Type( ) [ ] left to right (highest pres.)++ -- + - ! & * right to left unary* / % left to right multiplicative+ - left to right additive<< >> left to right shift = = != left to right equality&& || left to right logical and/or?: right to left conditional= += -= *= /= %= right to left assignment, left to right comma

Program Structure

A C program is made up of a main function and optionally one more additional functions that work together to carry out some task.

A C++ program is made up of a main function and optionally one or more additional functions and/or classes that work together to carry out some task.

Function Structure

returnType functionName (parameter list) { // function body } Neither C or C++ allow function definitions to be

nested within other function definitions. However, blocks { } may be nested within other blocks.

Every C/C++ statement must be terminated by a semicolon.

Our First C++ Program#include <iostream.h> //This program prompts the user for two integers and then//displays the sum of the two integers.void main( ) { int value1, value2; cout << “Input an integer and press return: “; cin >> value1; cout << “Input another integer and press return: “; cin >> value2; cout << “The sum of “ << value1 << “ and “ << value2 << “ is “ << value1 + value2 << endl;}

Our First C++ Program Program components:

iostream.h - header file main - function name value1 and value2 - user defined variables.

• Variables are symbolic names that refer to areas of memory reserved for holding data.

cout - output stream object. << - stream insertion member function defined in cout. cin - input stream object. >> - stream extraction member function defined in cin. ; (semicolon) - statement terminator. Value1 + value2 - arithmetic expression. { } - block delimiters.

Control Structures Control structures determine the flow of control

through a program. Flow of control refers the the order that

instructions within a program are executed. Control structures may be categorized as

either sequential structures, selection structures or repetition structures.

Control Structures Sequential structures

Represented by the absence of any specific selection or repetition structure.

Selection structures if if/else switch ?: (conditional operator - same as if/else)

Repetition structures while do/while for

Selection Structures if if (conditional test) { statement(s) } if/else if (conditional test) { statement(s) } else { statement(s) }

Repetition Structures

while while (conditional test) { statement(s) } do/while do { statement(s) while (conditional test); Note: braces { } may be omitted from around the body

of a selection or repetition structure if the body only contains a single statement.

The For Loop Of the repetition structures, the for loop is the most

complex.Initialize control variables Modify control variables

Conditional test

for (expression1; expression2; expression3) statement; The for and while loops test for entry to the loop body

at the top of the loop. The do/while tests for re-entry at the bottom of the loop.

Conditional Expressions

Conditional expressions are primarily composed of relational and logical operators. For example:

if (a < b && c != j) { statement(s) } while (c = = k) { statement(s) } do { statement(s) } while (b >= (j+n)); for (int i = 0; i < 100; i++) { statement(s) }

Conditional ExpressionsWatch out!!! - A common mistake is to use the assignment

operator (=) where where the equality operator (= =) was intended. For example:

if (j = 100) { } This is syntactically correct but logically wrong.

100 will be assigned to j then the value in j will be used to determine if the condition is true or false. A value of 0 means false; a non-zero value means true.

Pass By Value#include <iostream.h>int cubeByValue(int); //function prototype

void main() {int number = 5;cout << ”Number equals "

<< number << endl;number = cubeByValue(number);cout << ”Number now equals "

<< number << endl;}int cubeByValue(int n)

{ return n * n * n; }

5

5

number

n

Pass By Reference

#include <iostream.h>void cubeByReference(int &); void main() {

int number = 5;cout << ”Number equals "

<< number << endl;cubeByReference(number);cout << ”Number now equals "

<< number << endl;}void cubeByReference(int &n)

{ n = n * n * n; }

5number

n(n is a constant pointer)

Pass By Reference with Pointer#include <iostream.h>void cubeByPointer(int *);

//function prototypemain() {

int number = 5;cout << ”Number equals "

<< number << endl;cubeByPointer(&number);cout << ”Number now equals "

<< number << endl;}void cubeByPointer(int *n)

{ *n = *n * *n * *n; }

5number

n

(n is a non-constant pointer)

Pointers Pointers are a major component of C/C++

programming. Many persons consider pointers the most difficult

aspect of C/C++ to master. A pointer is a variable that contains an address. There are two operators that are commonly used when

working with pointers. * - the indirection operator which also doubles as the

multiplication operator. & - the address operator.

Pointer Examples

#include <iostream.h>void main() {int i = 20;int *iptr = &i;cout << i << endl; //20cout << &i << endl; //0x8f47fff2cout << iptr << endl; //0x8f47fff2cout << &iptr << endl; //0x8f47fff0cout << *iptr << endl; //20

}

Pointer Examples

void main() {int *iptr, iarr[5] = {10,20,30,40,50};iptr = iarr;cout << iarr << endl; //0x8f47ffe6cout << iptr << endl; //0x8f47ffe6cout << iarr[0] << endl; //10cout << *iptr << endl; //10cout << *iarr << endl; //10cout << iptr[0] << endl; //10cout << iarr[2] << endl; //30iptr += 2;cout << *iptr << endl; //30cout << *(iptr-1) << endl;//20

}

Pointer Examplesvoid main() {

char *cptr, *csptr = "abcde";char carr[6] = "abcde";cptr = carr;cout << carr << endl; //abcdecout << cptr << endl; //abcdecout << carr[0] << endl; //acout << *cptr << endl; //acout << *carr << endl; //acout << cptr[0] << endl; //acout << carr[2] << endl; //ccptr += 2;cout << *cptr << endl; //ccout << *(cptr - 1) << endl; //b

}

Pointer Examplesvoid main() {

char sarr[3][10] = {"Fred", "Susan", "Mary"};cout << sarr << endl; //0x8f43ffbacout << *sarr << endl; //Fredcout << *(sarr + 1) << endl; //Susancout << sarr[2] << endl; //Marycout << sarr[0][1] << endl; //r

char *parr[3] = {"Fred", "Susan", "Mary"};cout << parr << endl; //0x8f43ffd8cout << *parr << endl; //Fredcout << *(parr + 1) << endl; //Susancout << parr[2] << endl; //Marycout << parr[0][1] << endl; //r

}