ES 036 Programming Fundamentals

1. ES 036Programming Fundamentals C++ Basics Dr. Roy Eagleson eagleson@uwo.ca www.eng.uwo.ca/people/reagleson

2. Converting C++ programs in to machine language • Text Editor • Preprocessor • Compiler • Linker • Loader ES036 QMR/RE

3. Converting C++ in to machine language • Text Editor • The program is written using the text editor is known as source code. • The source code (human readable instructions) is saved on to the secondary storage section of the computer system (disk) with an extension ‘.cpp’ to let the compiler know that it is written in C++ language. • The source code needs to be grammatically correct ES036 QMR/RE

4. Converting C++ in to machine language • Preprocessor: A program that modifies the source code by adding other files and performing various text replacements • It executes automatically before the translation period starts. • Examples: • #include <iostream> adds a file called a header file to the source code. It contains, among other things, the prototypes for cin and cout functions. • #define PI 3.141593 replaces all instances of PI in a program with 3.141593. • Compilation (step 3) follows immediately after the preprocessing, so, none can access the modifications made by the preprocessor ES036 QMR/RE

5. Converting C++ in to machine language • Compiler translates preprocessed source code into an object code that contains machine readable instructions • The object code is saved on to the disk by the compiler with an extension ‘.obj’ along with the same source-code name • This file is basically a binary file ES036 QMR/RE

6. Converting C++ in to machine language • Linker: • scans the standard library, • selects the needed function (precompiled) and • upon linking them into the object file, produces an executable file with extension ‘.exe’ (for UNIX based system it is ‘.out’) and stores it on to the disk. • Libraries are a collection of functions/objects • Examples: • The linker adds the precompiled (in binary form) function definitions for cin, cout, etc. • If one separates his program into more than one source file, the object code for each source file is added. ES036 QMR/RE

7. Converting C++ in to machine language • Loader: The loader places the executable file on to the primary storage location (RAM) of the computer system, from where the CPU executes the program, instruction by instruction ES036 QMR/RE

8. Converting C++ in to machine language Text Editor /* hello.cpp */ #include <iostream> int main() { cout<<"hello world\n"; return 0; } Preprocessor adds iostream text (prototype for cout) Compiler converts to machine code hello.obj Object code Linker -add library -add cout object code -add object code for other functions Executable image hello.exe Loader copies file to RAM and CPU executes the program when the icon is double-clicked, for example Program Example ES036 QMR/RE

9. Converting C++ in to machine language • Integrated Development Environment (IDE) program: • It manages all the previously discussed steps and combines an editor, compiler, linker and debugger into a single development environment. • Advantage: all the pieces are designed to work together; for example, if the compiler detects an error, the system is switched to the editor with the file positioned at the problem line. • Debugger: The debugger locates the problem in the program during the compilation time ES036 QMR/RE

10. //The first C++ Program #include <iostream> //preprocessor directive using namespace std; //”using” directive // entry point int main() //first function called in C++ {// function body begins with curly bracket cout << “Hello world!"; /* printing a string on the standard output*/ return 0; /*represents successful termination of the program*/ } // function body ends with curly bracket ES036 QMR/RE

11. Comments in C++ • Comments allow us to put some descriptions in our code • Compiler completely ignores them • // this is a comment • Starting from ‘//’ to the end of the line • /* this is also a comment */ • Everything between ‘/*’ and ‘*/’ • a = b /* comment inside a statement */ + c; ES036 QMR/RE

12. Preprocessing Directive • The line begins with ‘#’ characters are known as preprocessor directives. • #include<iostream> causes the preprocessor to include a copy of the standard input /output file iostream (this is a C++ system file) • The angle bracket indicates that this file is available at a system dependent place. • The iostream file contains information on the function coutused in the program ES036 QMR/RE

13. Function main • Every C++ (and C) program executes its instructions from the function called main. This is the first function, called in C++ environment. • Any function in C++ has a prototype as, Return_data_type Function_name (Argument_list_with_data_types) • According to the prototype, the main function returns an integer (int) type value without taking any argument to process. Note: one can use (optional) the keyword void inside the parentheses as int main(void), to represent that the function takes no argument. ES036 QMR/RE

14. Curly Brackets • The left curly bracket begins the body of each function • This right curly bracket ends the body of each function. • A function definition looks like the following: Return_data_type Function_name(Argument_list_with_data_types) { Body of the function; } ES036 QMR/RE

15. Producing Output With cout • cout • is an ostream object • streams output to standard output • uses the << (output) operator • General Form: • cout << expression << expression; • Note: An expression is any C++ expression (string constant, identifier, formula or function call) ES036 QMR/RE

16. return 0 • return is a keyword for C++ (and C) programming language • A returned zero value is interpreted as successful termination of the program. • Non-zero values are interpreted as unsuccessful termination ES036 QMR/RE

17. Good Programming Approach • Purpose of a program • it presents the computer with a set of instructions and • it provides the programmer a clear, easy to read description of what it does. • The goal of a programmer • Create a simple and easy to read programs. • Make the program as clear, concise and simple as possible ES036 QMR/RE

18. Good Programming Approach • Comment the program • Pick meaningful names for the variables • Indentation • Clarity • Simplicity • Do not write a long function • Avoid complex logics • Write many short statements instead of a very long one • Make the program as simple and easy to understand as possible ES036 QMR/RE

19. C++ Variables (Objects) • Variables are boxes that can hold things • Each box has a name (“identifier”) • Size of the box depends on the “type” of things you are planning to put there • You have to tell the compiler in advance (“declare”), • Names of each of the boxes you want • The type of things that will go in each box ES036 QMR/RE

20. Why Use Types • Computer sees everything in 1’s and 0’s • “Type” is how we interpret these patterns • What is 1101101? • Integer (int): it is 109 • Character (char): it is ‘m’ • Floating point (float): it is 1.53x10-43 ES036 QMR/RE

21. Tell the compiler in advance Types Names Names can have A-Z, a-z, 0-9 and ‘_’ Case sensitive Cannot start with a digit Cannot be a reserved word int alice; float bob, chad; int alice = 10; int alice(10); float bob, chad = 2.4; float bob(1.5), chad(2.4); Element atom; Declaring Objects Type Name ES036 QMR/RE

22. Identifier sum Box 75 Holds int type objects Size is 32 bits (4 bytes) Identifier atom Na Outer box 11 Inner boxes 22.989770 Holds Element type objects Size is 10 bytes Built in type User defined type ES036 QMR/RE

23. Some Built In Types ES036 QMR/RE

24. Mixing types: • avg = (a + b)/2; • avg, a and b must be same type • Exception • It is OK to mix numerical types • i.e. int, float, double • Be careful not to loose precision ES036 QMR/RE

25. C++ Reserved Words asm, auto, bool, break, case, catch, char, class, const, const_cast, continue, default, delete, do, double, dynamic_cast, else, enum, explicit, export, extern, false, float, for, friend, goto, if, inline, int, long, mutable, namespace, new, operator, private, protected, public, register, reinterpret_cast, return, short, signed, sizeof, static, static_cast, struct, switch, template, this, throw, true, try, typedef, typeid, typename, union, unsigned, using, virtual, void, volatile, wchar_t, while ES036 QMR/RE

26. Immediately prior to use int main(){ … int sum; sum = a + b; … return 0; } At the beginning int main(){ int sum; … sum = a + b; … return 0; } Where to Declare ES036 QMR/RE

27. One C++ instruction that ends with a semicolon Can take more than one line Declaration statements Assignment statements int sum(0), a(5), b(10); sum = a + b; float temp_c(0); float temp_f(78); temp_c = (temp_f – 32)*5/9; C++ Statements ES036 QMR/RE

28. Use { and } to group any number of statements This block is treated as one statement { cout << “Hello”; return 0; } Compound Statements ES036 QMR/RE

29. Concepts Presented So Far • How to write a simple C++ program? • What is a variable? • How to tell the compiler what variables I want? • What is a C++ statement? ES036 QMR/RE

30. Pre-processor directives “using” directives main: single C++ statement ! A declaration statement An assignment statement #include <iostream> using namespace std; // entry point int main() { float w_lb, w_kg; cout << "Enter weight (lb): "; cin >> w_lb; w_kg = w_lb * 0.454; cout << “Weight is " << w_kg << “kg\n"; return 0; } // end function main ES036 QMR/RE

31. #include <iostream> // without “using namespace std;” // entry point int main() { float w_lb, w_kg; std::cout << "Enter weight (lb): "; std::cin >> w_lb; w_kg = w_lb * 0.454; std::cout << “Weight is " << w_kg << “kg\n"; return 0; } // end function main ES036 QMR/RE

32. Symbolic Constants • Objects that won’t let you change the initial value • So, they must be given a value in its declaration • As a matter of style, names are all caps • E.g. const double PI = acos(-1.0); • Always use to these to represent numeric values within your program • Or for anything that you know will not change ES036 QMR/RE

33. Calculating Things • Using calculator • 4-2+5-1 = ? • +, - *, / and = are the operators • 3+2*5 vs (3+2)*5 • Need to consider operator precedence • * and / have higher precedence than +, - • C++ operators have these and more ES036 QMR/RE

34. C++ Operators • Operators take one or more input values and produce one output value • E.g. + , - , * , / , < , > , <= , >= , && , || • Operators come in three flavours • Unary operators – take one input value • Binary operators – take two input values • Ternary operators – take three input values ES036 QMR/RE

35. C++ Operator Map Operators Binary Unary Arithmetic + - add - - sub * - mul / - div % - mod Logical && - and || - or Bitwise & - and | - or ^ - xor Comparison < - less-than > - gt.-than <= - less-or-eq >= - gt-or-eq == - equal != - not-equal Arithmetic - - negate ++ - increment -- - decrement Logical ! - negate Copy = +=, -=, *=, /=, %= &&=, ||=, &=, |=, ^= Bitwise ~ - negate Pointer* , & ES036 QMR/RE

36. Unary Operators int a(9); • Negate: -a gives -9 • Logical-invert: !a gives 0 • * and & are pointer operations (discussed later) • Increment: ++ • Decrement: -- ES036 QMR/RE

37. More Unary Expressions int a(9), b; • Pre-Increment : • b = ++a; b is 10 and a is 10 • Post-Increment: • b = a++; b is 9 and a is 10 • Pre-Decrement : • b = --a; b is 8 and a is 8 • Post-Decrement: • b = a--; b is 9 and a is 8 ES036 QMR/RE

38. Arithmetic Operators: +-*/% • a+b, a-b, a*b, a/b • Integer division: 11/4 gives 2 • Floating point division: • 11.0/4 gives 2.75 • Modulo operator: % (only for integers) • 11%4 gives 3 • 10%5 gives 0 ES036 QMR/RE

39. Copy Operator (Assignment operator) • Simple copy: a = b; • Overwrites the left object (l-value) with the result of the expression on the right (r-value) • l-value must be writable • Copy with add • a += b; is the same as a = a + b; • Other copy-with-subtract, multiplication, division behaves the same • a -= b; a *= b; a /= b; etc ES036 QMR/RE

40. Comparison Operators • < , > , =<, =>, ==, != • All yield Boolean true (1) or false (0) • 11<4 is false. 11<11 is false • 11>4 is true. 11>11 is false • 11>=11 and 11<=11 both are true • 4==4 is true. 4!=4 is false • Don’t use floating-point values with == or != ES036 QMR/RE

41. Logical Operators • Logical AND: && • exp1 && exp2 && exp3 && exp3 • Yields true if all the expressions are true • If an expression is false, skips the rest • Logical OR: || • exp1 || exp2 || exp3 || exp3 • Yields true if any expression is true • If an expression is true, skips the rest • These are called “short-circuit” operators ES036 QMR/RE

42. Examples of Logical Operators true && true results in true • (-6<0)&&(12>=10) • (3.0 >= 2.0) || (3.0 >= 4.0) • (3.0 >= 2.0) && (3.0 >= 4.0) true || false results in true true && false results in false ES036 QMR/RE

43. Expressions • A series of operators and their inputs • E.g. x+3-y+5 • Evaluated from left-to-right • Be careful with division • Pay attention to operator precedence Correct form: (x+3)/5 + 4/(y+3) ES036 QMR/RE

44. Operator Precedence • Use parenthesis if you are not sure! • Unary (++, --, !, -) • Arithmetic (*, /, %, +, -) • Comparison (< , <= , > , >=, ==, !=) • Logical (&&, ||) • Assignment (= , +=,-=,*= ,/= ,%=, etc) ES036 QMR/RE

45. Expression Examples • 2*x*x-3*y/5*y+6 • Should really be • 2*x*x-(3*(y/5)*y)+6 • (2*x*x-3*y)/(5*y+6) ES036 QMR/RE

46. Expressions With Side Effects • r = x + y--; is equivalent to • r = x + y; y = y-1; (two actions!) • r = ++x - y; is equivalent to • x = x+1; r = x - y; (two actions!) • Keep it simple • Not r = --x + y++; ES036 QMR/RE

47. Using Standard Utilities • C++ compilers comes with a vast collection of utilities: i/o, math etc • This is called the “standard library” • You need to: • Include proper header files. E.g. #include<iostream> • Use using namespace std; statement • Or use std:: prefix ES036 QMR/RE

48. Standard Input and Output • Called the i/o stream objects • #include <iostream> • Input is usually from keyboard • Output is usually to a console window • cout object is the output stream (ostream) • cin object is the input stream (istream) ES036 QMR/RE

49. Producing Output With cout • cout • is an ostream object • streams output to standard output • uses the << (output) operator • General Form: • cout << expression << expression; • Note: An expression is any C++ expression (string constant, identifier, formula or function call) ES036 QMR/RE

50. //Example1 for input and output • #include <iostream> • #include <string> • using namespace std; • int main() • { • int i, j; • double x; • string units = “ cm”; • cin >> i >> j; • cin >> x; • cout << “output \n”; • cout << i << ‘,’ << j << ‘,’ << endl • << x << units << endl; • return 0; • } // Input stream: 1 2 4.5 output 1,2, 4.5 cm ES036 QMR/RE