Download
cse 5311 fundamentals of computer science n.
Skip this Video
Loading SlideShow in 5 Seconds..
CSE 5311 Fundamentals of Computer Science PowerPoint Presentation
Download Presentation
CSE 5311 Fundamentals of Computer Science

CSE 5311 Fundamentals of Computer Science

162 Views Download Presentation
Download Presentation

CSE 5311 Fundamentals of Computer Science

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

  1. CSE 5311 Fundamentals of Computer Science C++ Programming

  2. 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.

  3. C++ Compiler Object file The C++ Compilation Process C Library Linker C++ Source Code C++ Library Programmer Library Executable

  4. 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.

  5. 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

  6. C/C++ Primitive Data Types • Floating point data types • long double • double • float • Floating point values are usually stored in IEEE format

  7. 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 number • IEEE Short Real exponents are stored as a 8-bit unsigned integer with a bias of 127 decimal (01111111 binary)

  8. 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.

  9. 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.

  10. 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).

  11. 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.

  12. 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

  13. 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);

  14. C++ Operators OperatorAssociativityType ( ) [ ] 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

  15. 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.

  16. 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.

  17. 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; }

  18. 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.

  19. 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.

  20. 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

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

  22. 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.

  23. 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.

  24. 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) }

  25. Conditional Expressions Watch 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.

  26. Pass By Value 5 number #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; } n 5

  27. Pass By Reference 5 number #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; } n (n is a constant pointer)

  28. Pass By Reference with Pointer 5 number #include <iostream.h> void cubeByPointer(int *); //function prototype main() { int number = 5; cout << ”Number equals " << number << endl; cubeByPointer(&number); cout << ”Number now equals " << number << endl; } void cubeByPointer(int *n) { *n = *n * *n * *n; } n (n is a non-constant pointer)

  29. 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.

  30. Pointer Examples #include <iostream.h> void main() { int i = 20; int *iptr = &i; cout << i << endl; //20 cout << &i << endl; //0x8f47fff2 cout << iptr << endl; //0x8f47fff2 cout << &iptr << endl; //0x8f47fff0 cout << *iptr << endl; //20 }

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

  32. Pointer Examples void main() { char *cptr, *csptr = "abcde"; char carr[6] = "abcde"; cptr = carr; cout << carr << endl; //abcde cout << cptr << endl; //abcde cout << carr[0] << endl; //a cout << *cptr << endl; //a cout << *carr << endl; //a cout << cptr[0] << endl; //a cout << carr[2] << endl; //c cptr += 2; cout << *cptr << endl; //c cout << *(cptr - 1) << endl; //b }

  33. Pointer Examples void main() { char sarr[3][10] = {"Fred", "Susan", "Mary"}; cout << sarr << endl; //0x8f43ffba cout << *sarr << endl; //Fred cout << *(sarr + 1) << endl; //Susan cout << sarr[2] << endl; //Mary cout << sarr[0][1] << endl; //r char *parr[3] = {"Fred", "Susan", "Mary"}; cout << parr << endl; //0x8f43ffd8 cout << *parr << endl; //Fred cout << *(parr + 1) << endl; //Susan cout << parr[2] << endl; //Mary cout << parr[0][1] << endl; //r }