Functions & Memory Maps Review C Programming Language

Transcription

1 Functions & Memory Maps Review C Programming Language Data Abstractions CSCI-2320 Dr. Tom Hicks Computer Science Department

2 Constants c 2

3 What Is A Constant? Constant a Value that cannot be altered by the program during normal execution, i.e., the value is constant. When associated with an Identifier, a constant is said to be "named," although the terms "constant" and "named constant" are often used interchangeably. # define PI 3.14 PI is a "named constant" in C/C++ The C/C++ Pre-Processor assigns the value to the constant with the pre-processor directive at the beginning of the program; their values can not be changed during the execution of the program! 3

4 Variables c 4

5 What Is A Variable? Variable a storage location paired with an associated symbolic name, which contains some known or unknown quantity of information referred to as a Value; these values can be changed during program execution. int Age, No = 5; Age is an integer Variable whose Value is unknown; some say the "garbage" value assigned is determined by the contents of memory at that instant in time. No is an integer Variable whose Value is known because this statement both creates and initializes the variable. 5

6 Datatyping c Static vs. Dynamic 6

7 Static & Dynamic Data Typing int No = 5; Static Datatyping once No is defined to be an integer, only integer data may be stored in the container. It is not an appropriate container in which to store a FullName. Static Datatyping Languages Include: Ada, C, C++, C#, JADE, Java, Fortran, Haskell, ML, Pascal, and Scala. Dynamic Datatyping the datatype is determined by whatever is assigned to the container at the moment; It may store a No at one moment and a FullName at the next. Dynamic Datatyping Languages Include: JavaScript, Python, Ruby, PHP, Lua and Perl. 7

8 Why c Functions? 8

9 List 3 Reasons Why We Need Functions 1] Reduce Duplication 2] Reduce Abstraction: Partition Task Into Major Ideas 3] Divide Task Into Smaller Portions That Can Be Written By A Team Of Programmers. 9

10 Recommended Ordering Of Components c Both C/C++ 10

11 Recommended Program Layout Order 1. Include Statements 2. Define Statements 3. Structs & Classes (classes are C++) 4. Function Prototypes 5. Functions In Some Type Of Logical Order (Including main at the top) Many Companies Require Developers To Declare Variables At Top 11

12 Function Size? c 12

13 How Big Shall You Make A Function? 1] 50 Lines Of Code vs. "No More Than Half Hour For An Experienced Computer Scientist To Understand The Complexity [ ½ Hr Better!] * Each Module Should Have Well Defined Task! * Write Them With Maintenance In Mind - Good Variables, Well Indented, Well Documented, Easy To Understand. [Solve General Problems!] 13

14 How Big Shall You Make A Function? void ClearScreen(void) system("cls"); Function ClearScreen, above, will clear the screen on a Windows System void ClearScreen(void) system("clear"); Short Functions Are Sometimes OK! Function ClearScreen, above, will clear the screen on a Mac Terminal or a Linux System Since the screen might have to be cleared more than 200 times within our Interactive System it would be a good idea to create the Function this would simplify the process of porting the code to the alternate system. 14

15 More General ClearScreen Solution void ClearScreen(void) #ifdef SYMANTEC_MAC // printf ("\f"); #endif //SYMANTEC_MAC //# define BORLAND_IBM #ifdef MICROSOFT_VISUAL // system("cls"); #endif //MICROSOFT_VISUAL //# define SYMANTEC_IBM //# define SYMANTEC_MAC #ifdef BORLAND_IBM // clrscr(); //# define LINUX #endif //BORLAND_IBM //# define CURSES //# define CODE_WARRIOR_IBM //# define CODE_WARRIOR_MAC # define MICROSOFT_VISUAL #ifdef LINUX // system("clear"); #endif //LINUX #ifdef CURSES // clear(); refresh(); #endif //CURSES Some Of You Would Might Prefer To Make One define Change which then makes all of the alterations necessary for the various operating systems. 15

16 I Am Going To Use Memory Maps To Review What c Happens With Memory In Main, Memory In Functions, Arguments Passed, etc. 16

17 Function HitCarriageReturnToContinue() Write A Function Which Will c Prompt The User To "Hit Return Key To Continue" Delay Processing Until The User Hits The Return Key 17

18 Function No Arguments No Explicit Return void HitCarriageReturnToContinue (void) char JunkString[5000]; flush_stream(stdin); printf(" <Hit Enter/Return Key To Continue> "); gets_s(junkstring); Called From main int main (int argc, char * argv[]) puts (" Start Of Main \n"); puts (" End Of Main \n"); HitCarriageReturnToContinue(); return (0); 18

19 c Examine What Happens When We Create An Un- Initialized Integer, Called No1, In Main. 19

20 About No1 (Assume Compiler Assigns Memory Starting At (Decimal) ) int main(int argc, char * argv[]) int No1 ;?? 101 What Is The Symbolic Name No1 What Value Is Currently Stored In No1 Garbage?? unknown Write An Assignment To Change The Value In No1 to 101 No1 = 101 Print The Value Contained In No1 printf ("No1 = %d\n", No1); Assume That The Address Where No1 Is Stored = Print The Address (base 10) Where No1 Is Stored printf ("&No1 = %ld\n", &No1); Print The Address (base 16) Where No1 Is Stored printf ("&No1 = %X\n", &No1); Print The Size (in bytes) of No1 printf ("sizeof( No1) = %ld\n", sizeof(no1)); No1 20

21 c Examine What Happens When We Create An Initialized Integer, Called No2, In Main. 21

22 About No2 (Assume Compiler Assigns Memory Starting At &1004 (Decimal) ) int main(int argc, char * argv[]) int No1, No2 = 12 ; 101 What Is The Symbolic Name No2 What Value Is Currently Stored In No2 12 Write An Assignment To Change The Value In No2 to 202 No2 = 202 Print The Value Contained In No2 printf ("No2 = %d\n", No2); Assume That The Address Where No2 Is Stored = &1004 Print The Address (base 10) Where No2 is Stored printf ("&No2 = %ld\n", &No2); Print The Address (base 16) Where No2 Is Stored printf ("&No2 = %X\n", &No2); Print The Size (in bytes) of No2 printf ("sizeof( No2) = %ld\n", sizeof(no2)); No1 12 & No2 22

23 Function DisplayAddition(Addend1, Addend2) Write A Function Which Will Display Addition Problem: Addend1 + Addend2 = Sum c 23

24 Function No Arguments No Explicit Return void DisplayAddition (int Addend1, int Addend2) int Sum = Addend1 + Addend2; printf("%d + %d = %d\n", Addend1, Addend2, Sum); Addend1 & Addend2 Are Passed By Value int main (int argc, char * argv[]) int No1 = 5, No2 = 6; DisplayAddition(No1, No2); DisplayAddition(3,4); Called From main Function DisplayAddition Has No Access To No1 Or No2 Unless Their Values Are Passed In As Arguments. 24

25 c DisplayAddition Exists, But Is Not Evoked/Called 25

26 [0] DisplayAdditon (Assume Compiler Assigns Memory Starting At (Decimal) ) int main(int argc, char * argv[ ]) No1 = 5, No2 = 6 ; 5 No1 6 &1002 No2 void DisplayAddition (int Addend1, int Addend2) int Sum = Addend1 + Addend2; printf("%d + %d = %d\n", Addend1, Addend2, Sum); 26

27 c DisplayAddition Is Evoked/Called Pass Arguments By Value 27

28 [0] DisplayAdditon (Assume Compiler Assigns Memory Starting At (Decimal) ) int main(int argc, char * argv[ ]) No1 = 5, No2 = 6 ; 5 No1 6 &1002 No2 DisplayAddition(No1, No2); void DisplayAddition (int Addend1, int Addend2) int Sum; Sum = Addend1 + Addend2; printf("%d + %d = %d\n", Addend1, Addend2, Sum); 1 Function DisplayAddition Is Called 2 Addend1 Is Passed By Value Create The Short Int Container 5 &2000 Addend1 3 Place A Copy Of The Information In No1 (first argument match) Into The Container 28

29 [1] DisplayAdditon (Assume Compiler Assigns Memory Starting At (Decimal) ) int main(int argc, char * argv[ ]) No1 = 5, No2 = 6 ; 5 No1 6 &1002 No2 DisplayAddition(No1, No2); void DisplayAddition (int Addend1, int Addend2) int Sum; Sum = Addend1 + Addend2; printf("%d + %d = %d\n", Addend1, Addend2, Sum); 4 Addend2 Is Passed By Value Create The Short Int Container 5 & &2002 Addend1 Addend2 5 Place A Copy Of The Information In No2 (second argument match) Into The Container 29

30 [2] DisplayAdditon (Assume Compiler Assigns Memory Starting At (Decimal) ) int main(int argc, char * argv[ ]) No1 = 5, No2 = 6 ; DisplayAddition(No1, No2); 5 void DisplayAddition (int Addend1, int Addend2) int Sum; Sum = Addend1 + Addend2; printf("%d + %d = %d\n", Addend1, Addend2, Sum); 6 Create The Short Int Container For Sum No1 6 No2 &1002?? Sum & Addend1 & Addend2 &

31 [3] DisplayAdditon (Assume Compiler Assigns Memory Starting At (Decimal) ) int main(int argc, char * argv[ ]) No1 = 5, No2 = 6 ; DisplayAddition(No1, No2); 5 void DisplayAddition (int Addend1, int Addend2) int Sum; Sum = Addend1 + Addend2; printf("%d + %d = %d\n", Addend1, Addend2, Sum); 7 Place Addend1 (5) + Addend2 (6) into Sum No1 6 No2 &1002?? 11 Sum & Addend1 & Addend2 &

32 [4] DisplayAdditon (Assume Compiler Assigns Memory Starting At (Decimal) ) int main(int argc, char * argv[ ]) No1 = 5, No2 = 6 ; DisplayAddition(No1, No2); 5 void DisplayAddition (int Addend1, int Addend2) int Sum; Sum = Addend1 + Addend2; printf("%d + %d = %d\n", Addend1, Addend2, Sum); 8 The Print Output Goes To The Terminal Console No1 6 No2 &1002?? 11 Sum & Addend1 & Addend2 &

33 [5] DisplayAdditon (Assume Compiler Assigns Memory Starting At (Decimal) ) int main(int argc, char * argv[ ]) No1 = 5, No2 = 6 ; DisplayAddition(No1, No2); 5 void DisplayAddition (int Addend1, int Addend2) int Sum; Sum = Addend1 + Addend2; printf("%d + %d = %d\n", Addend1, Addend2, Sum); No1 9 At The End Of The Function All Of The Memory Allocated For Arguments & Local Variables Is Returned To The Operating System For Reuse Addend1, Addend2, & Sum Cease To Exist! 11 & & & &1002 Sum No2 Addend1 Addend2 33

34 Function SwapA (A,B) Write A Function Which Will Swap The Contents Of A & B c THIS ATTEMP FAILS! 34

35 Function No Arguments No Explicit Return void SwapA ( A, B) Temp; Temp = A; A = B; B = Temp; int main (int argc, char * argv[]) No1 = 5, No2 = 12 ; printf ("No1 = %d\n", No1); printf ("No2 = %d\n", No2); A & B Are Passed By Value Called From main Function SwapA Has No Access To No1 Or No2 Unless Their Values Are Passed In As Arguments. SwapA ( No1, No2); 35

36 c SwapA Is Evoked/Called Pass Arguments By Value 36

37 [1] SwapA (Assume Compiler Assigns Memory Starting At (Decimal) ) int main(int argc, char * argv[]) No1 = 5, No2 = 12 ; 5 No1 12 &1002 No2 printf ("No1 = %d\n", No1); printf ("No2 = %d\n", No2); No1 = 5 No2 = 12 void SwapA ( A, B) Temp; Temp = A; A = B; B = Temp; 37

38 [2] SwapA (Assume Compiler Assigns Memory Starting At (Decimal) ) int main(int argc, char * argv[]) No1 = 5, No2 = 12 ; printf ("No1 = %d\n", No1); printf ("No2 = %d\n", No2); SwapA ( No1, No2); No1 No1 = 5 No2 = 12 V A Is It Passed By Value Or By Reference? 5 12 &1002 No2 Reference int * A Int & A Value Int A void SwapA ( A, B) Temp; Temp = A; A = B; B = Temp; 38

39 [3] SwapA (Assume Compiler Assigns Memory Starting At (Decimal) ) int main(int argc, char * argv[]) No1 = 5, No2 = 12 ; 5 No1 12 &1002 No2 printf ("No1 = %d\n", No1); printf ("No2 = %d\n", No2); No1 = 5 No2 = 12 SwapA ( No1, No2); Since A Is By Reference Create A Variable Whose Symbolic Name Is A And Fill It With The Value Of The First Argument In The Function Call. void SwapA ( A, B) Temp; 5 A &1004 Temp = A; A = B; B = Temp; 39

40 [4] SwapA (Assume Compiler Assigns Memory Starting At (Decimal) ) int main(int argc, char * argv[]) No1 = 5, No2 = 12 ; 5 No1 12 &1002 No2 printf ("No1 = %d\n", No1); printf ("No2 = %d\n", No2); No1 = 5 No2 = 12 SwapA ( No1, No2); Since B Is By Reference Create An int Variable Whose Symbolic Name Is B And Fill It With The Value Of The Second Argument In The Function Call. void SwapA ( A, B) Temp; 5 A & B &1006 Temp = A; A = B; B = Temp; 40

41 [5] SwapA (Assume Compiler Assigns Memory Starting At (Decimal) ) int main(int argc, char * argv[]) No1 = 5, No2 = 12 ; 5 No1 12 &1002 No2 printf ("No1 = %d\n", No1); printf ("No2 = %d\n", No2); No1 = 5 No2 = 12 SwapA ( No1, No2); Temp is a local variable will be destroyed when function is finished. Create An int Variable Whose Symbolic Name Is Temp Contains Garbage void SwapA ( A, B) Temp; 5 A & B &1006? Temp &1008 Temp = A; A = B; B = Temp; 41

42 [6] SwapA (Assume Compiler Assigns Memory Starting At (Decimal) ) int main(int argc, char * argv[]) No1 = 5, No2 = 12 ; 5 No1 12 &1002 No2 printf ("No1 = %d\n", No1); printf ("No2 = %d\n", No2); SwapA ( No1, No2); Function SwapA can access it s parameters (A & B), global variables (bad practice), defines, and it s local variables (Temp). No1 = 5 No2 = 12 void SwapA ( A, B) Temp; printf ("No2 = %d\n", No2); 5 A & B &1006? Temp &1008 Temp = A; A = B; B = Temp; 42

43 [7] SwapA (Assume Compiler Assigns Memory Starting At (Decimal) ) int main(int argc, char * argv[]) No1 = 5, No2 = 12 ; 5 No1 12 &1002 No2 printf ("No1 = %d\n", No1); No1 = 5 printf ("No2 = %d\n", No2); SwapA ( No1, No2); No2 = 12 void SwapA ( A, B) Temp; printf ("A = %d\n", A); printf ("B = %d\n", B); A = 5 B = 12 Temp = A; A = B; B = Temp; 5 A & B &1006? Temp &1008 printf ("A = %d\n", A); printf ("B = %d\n", B); printf ("Temp = %d\n", Temp); 43

44 [8] SwapA (Assume Compiler Assigns Memory Starting At (Decimal) ) int main(int argc, char * argv[]) No1 = 5, No2 = 12 ; 5 No1 12 &1002 No2 printf ("No1 = %d\n", No1); No1 = 5 printf ("No2 = %d\n", No2); SwapA ( No1, No2); No2 = 12 void SwapA ( A, B) Temp; printf ("A = %d\n", A); printf ("B = %d\n", B); A = 5 B = 12 Temp = A; A = B; B = Temp; 5 A & B &1006? 5 Temp &1008 printf ("A = %d\n", A); printf ("B = %d\n", B); printf ("Temp = %d\n", Temp); 44

45 [9] SwapA (Assume Compiler Assigns Memory Starting At (Decimal) ) int main(int argc, char * argv[]) No1 = 5, No2 = 12 ; 5 No1 12 &1002 No2 printf ("No1 = %d\n", No1); No1 = 5 printf ("No2 = %d\n", No2); SwapA ( No1, No2); No2 = 12 void SwapA ( A, B) Temp; printf ("A = %d\n", A); printf ("B = %d\n", B); A = 5 B = 12 Temp = A; A = B; B = Temp; 5 12 A & B &1006? 5 Temp &1008 printf ("A = %d\n", A); printf ("B = %d\n", B); printf ("Temp = %d\n", Temp); 45

46 [10] SwapA (Assume Compiler Assigns Memory Starting At (Decimal) ) int main(int argc, char * argv[]) No1 = 5, No2 = 12 ; 5 No1 12 &1002 No2 printf ("No1 = %d\n", No1); No1 = 5 printf ("No2 = %d\n", No2); SwapA ( No1, No2); No2 = 12 void SwapA ( A, B) Temp; printf ("A = %d\n", A); printf ("B = %d\n", B); A = 5 B = 12 Temp = A; A = B; B = Temp; 5 12 &1004 A 12 5 &1006 B? 5 Temp &1008 printf ("A = %d\n", A); printf ("B = %d\n", B); printf ("Temp = %d\n", Temp); 46

47 [11] SwapA (Assume Compiler Assigns Memory Starting At (Decimal) ) int main(int argc, char * argv[]) No1 = 5, No2 = 12 ; 5 No1 12 &1002 No2 printf ("No1 = %d\n", No1); No1 = 5 printf ("No2 = %d\n", No2); SwapA ( No1, No2); No2 = 12 void SwapA ( A, B) Temp; printf ("A = %d\n", A); printf ("B = %d\n", B); A = 5 B = 12 Temp = A; A = B; B = Temp; 5 12 &1004 A 12 5 &1006 B? 5 Temp &1008 printf ("A = %d\n", A); A = 12 printf ("B = %d\n", B); B = 5 printf ("Temp = %d\n", Temp); 47

48 [12] SwapA (Assume Compiler Assigns Memory Starting At (Decimal) ) int main(int argc, char * argv[]) No1 = 5, No2 = 12 ; 5 No1 12 &1002 No2 printf ("No1 = %d\n", No1); No1 = 5 printf ("No2 = %d\n", No2); SwapA ( No1, No2); No2 = 12 void SwapA ( A, B) Temp; printf ("A = %d\n", A); printf ("B = %d\n", B); A = 5 B = 12 Temp = A; A = B; B = Temp; 5 12 &1004 A 12 5 &1006 B? 5 Temp &1008 printf ("A = %d\n", A); A = 12 printf ("B = %d\n", B); B = 5 printf ("Temp = %d\n", Temp); 48

49 [13] SwapA (Assume Compiler Assigns Memory Starting At (Decimal) ) int main(int argc, char * argv[]) No1 = 5, No2 = 12 ; 5 No1 12 &1002 No2 printf ("No1 = %d\n", No1); printf ("No2 = %d\n", No2); No1 = 5 No2 = 12 SwapA ( No1, No2); printf ("No1 = %d\n", No1); No1 = 5 printf ("No2 = %d\n", No2); No2 = 12 void SwapA ( A, B) Temp; Temp = A; A = B; B = Temp; 49

50 Passing Arguments By Value The function receives a copy of the actual arguments passed to the function as parameters. The function can change the value of the parameter, but cannot change the values of the actual actual arguments. 50

51 Function SwapB (A,B) Write A Function Which Will Swap The Contents Of A & B c THIS ATTEMP WORKS! 51

52 Function No Arguments No Explicit Return void SwapB ( * A, * B) Temp; Temp = *A; *A = *B; *B = Temp; A & B Are Passed By Reference int main (int argc, char * argv[]) No1 = 5, No2 = 12 ; printf ("No1 = %d\n", No1); printf ("No2 = %d\n", No2); SwapB ( &No1, &No2); Called From main Since Function SwapB Uses Pointers This Swap Will Be Able To Change The Values Of No1 & No2. 52

53 c SwapB Is Evoked/Called Pass Arguments By Reference POINTERS! 53

54 [1] SwapB (Assume Compiler Assigns Memory Starting At (Decimal) ) int main(int argc, char * argv[]) No1 = 5, No2 = 12 ; 5 No1 12 &1002 No2 printf ("No1 = %d\n", No1); No1 = 5 printf ("No2 = %d\n", No2); No2 = 12 void SwapB ( * A, * B) Temp; Temp = *A; *A = *B; *B = Temp; 54

55 [2] SwapB (Assume Compiler Assigns Memory Starting At (Decimal) ) int main(int argc, char * argv[]) No1 = 5, No2 = 12 ; printf ("No1 = %d\n", No1); printf ("No2 = %d\n", No2); SwapB ( &No1, &No2); No1 R A Is It Passed By Value Or By Reference? 5 No1 = 5 No2 = &1002 No2 Reference int * A Int & A Value Int A The Only Way To Change No1 Is To Use A Pointer Variable Or A Reference Variable; We Are Using A Standard C Pointer Variable In This Example! void SwapB ( * A, * B) Temp; Temp = *A; *A = *B; *B = Temp; 55

56 [3] SwapB (Assume Compiler Assigns Memory Starting At (Decimal) ) int main(int argc, char * argv[]) No1 = 5, No2 = 12 ; 5 No1 12 &1002 No2 printf ("No1 = %d\n", No1); printf ("No2 = %d\n", No2); No1 = 5 No2 = 12 SwapB ( &No1, &No2); Store &No1 In Pointer A Since A Is By Reference Create A Pointer To A Variable Whose Symolic Name Is A And Fill It With The Address Passed In The First Argument In The Function Call. void SwapB ( * A, * B) Temp; &1004 A Ptrs Are 4 Bytes Temp = *A; *A = *B; *B = Temp; 56

57 [4] SwapB (Assume Compiler Assigns Memory Starting At (Decimal) ) int main(int argc, char * argv[]) No1 = 5, No2 = 12 ; 5 No1 12 &1002 No2 printf ("No1 = %d\n", No1); printf ("No2 = %d\n", No2); No1 = 5 No2 = 12 SwapB ( &No1, &No2); Store &No2 In Pointer B Since B Is By Reference Create A Pointer To A Variable Whose Symolic Name Is B And Fill It With The Address Passed In The Second Argument In The Function Call. void SwapB ( * A, * B) Temp; &1004 A &1002 &1008 B Temp = *A; *A = *B; *B = Temp; 57

58 [5] SwapB (Assume Compiler Assigns Memory Starting At (Decimal) ) int main(int argc, char * argv[]) No1 = 5, No2 = 12 ; 5 No1 12 &1002 No2 printf ("No1 = %d\n", No1); printf ("No2 = %d\n", No2); No1 = 5 No2 = 12 SwapB ( &No1, &No2); Temp is a local variable will be destroyed when function is finished. Create An int Variable Whose Symolic Name Is Temp Contains Garbage void SwapB ( * A, * B) Temp; &1004 A &1002 &1008 B? Temp &1012 Temp = *A; *A = *B; *B = Temp; 58

59 [6] SwapB (Assume Compiler Assigns Memory Starting At (Decimal) ) int main(int argc, char * argv[]) No1 = 5, No2 = 12 ; 5 No1 12 &1002 No2 printf ("No1 = %d\n", No1); printf ("No2 = %d\n", No2); No1 = 5 No2 = 12 SwapB ( &No1, &No2); Function SwapB can access it s parameters (A & B), global variables (bad practice), defines, and it s local variables (Temp). void SwapB ( * A, * B) Temp; printf ("No2 = %d\n", No2); &1004 A &1002 &1008 B? Temp &1012 Temp = *A; *A = *B; *B = Temp; 59

60 [7] SwapB (Assume Compiler Assigns Memory Starting At (Decimal) ) int main(int argc, char * argv[]) No1 = 5, No2 = 12 ; printf ("No1 = %d\n", No1); printf ("No2 = %d\n", No2); SwapB ( &No1, &No2); 5 No1 = 5 No2 = 12 No1 12 &1002 No2 void SwapB ( * A, * B) Temp; printf ("A = %d\n", A); printf ("B = %d\n", B); printf ("*A = %d\n", *A); printf ("*B = %d\n", *B); A = 1000 B = 1002 *A = 5 *B = 12 Temp = *A; *A = *B; *B = Temp; &1004 A &1002 &1008 B? Temp &1012 printf ("A = %d\n", A); printf ("B = %d\n", B); printf ("Temp = %d\n", Temp); 60

61 [8] SwapB (Assume Compiler Assigns Memory Starting At (Decimal) ) int main(int argc, char * argv[]) No1 = 5, No2 = 12 ; printf ("No1 = %d\n", No1); printf ("No2 = %d\n", No2); SwapB ( &No1, &No2); 5 No1 = 5 No2 = 12 No1 12 &1002 No2 void SwapB ( * A, * B) Temp; printf ("A = %d\n", A); printf ("B = %d\n", B); printf ("*A = %d\n", *A); printf ("*B = %d\n", *B); A = 1000 B = 1002 *A = 5 *B = 12 Temp = *A; *A = *B; *B = Temp; &1004 A &1002 &1008 B? 5 Temp &1012 printf ("A = %d\n", A); printf ("B = %d\n", B); printf ("Temp = %d\n", Temp); 61

62 [9] SwapB (Assume Compiler Assigns Memory Starting At (Decimal) ) int main(int argc, char * argv[]) No1 = 5, No2 = 12 ; printf ("No1 = %d\n", No1); printf ("No2 = %d\n", No2); SwapB ( &No1, &No2); 5 12 No1 No2 No1 = 5 No2 = 12 void SwapB ( ** A, A, ** B) Temp; 12 &1002 printf ("A = %d\n", A); printf ("B = %d\n", B); printf ("*A = %d\n", *A); printf ("*B = %d\n", *B); A = 1000 B = 1002 *A = 5 *B = 12 Temp = *A; *A = *B; *B = Temp; &1004 A &1002 &1008 B? 5 Temp &1012 printf ("A = %d\n", A); printf ("B = %d\n", B); printf ("Temp = %d\n", Temp); 62

63 [10] SwapB (Assume Compiler Assigns Memory Starting At (Decimal) ) int main(int argc, char * argv[]) No1 = 5, No2 = 12 ; printf ("No1 = %d\n", No1); printf ("No2 = %d\n", No2); SwapB ( &No1, &No2); 5 12 No No2 &1002 No1 = 5 No2 = 12 void void SwapB ( int ** A, A, short int ** B) B) short int Temp; printf printf ("A ("A = %d\n", A); A); printf printf ("B ("B = %d\n", B); B); printf printf ("*A ("*A = %d\n", *A); *A); printf printf ("*B ("*B = %d\n", *B); *B); A = 1000 B = 1002 *A = 5 *B = 12 Temp Temp = *A; *A; *A *A = *B; *B; *B *B = Temp; &1004 A &1002 &1008 B? 5 Temp &1012 printf printf ("A ("A = %d\n", A); A); printf printf ("B ("B = %d\n", B); B); printf printf ("Temp = %d\n", Temp); 63

64 [11] SwapB (Assume Compiler Assigns Memory Starting At (Decimal) ) int main(int argc, char * argv[]) No1 = 5, No2 = 12 ; printf ("No1 = %d\n", No1); printf ("No2 = %d\n", No2); SwapB ( &No1, &No2); 5 No1 = 5 No2 = No &1002 No2 void SwapB ( * A, * B) Temp; printf ("A = %d\n", A); printf ("B = %d\n", B); printf ("*A = %d\n", *A); printf ("*B = %d\n", *B); A = 1000 B = 1002 *A = 5 *B = 12 Temp = *A; *A = *B; *B = Temp; &1004 A &1002 &1008 B? 5 Temp &1012 printf ("A = %d\n", A); printf ("B = %d\n", B); printf ("Temp = %d\n", Temp); A = 1000 B = 1002 Temp = 5 64

65 [12] SwapB (Assume Compiler Assigns Memory Starting At (Decimal) ) int main(int argc, char * argv[]) No1 = 5, No2 = 12 ; printf ("No1 = %d\n", No1); printf ("No2 = %d\n", No2); SwapB ( &No1, &No2); 5 12 No &1002 No1 = 5 void SwapB ( * A, * B) No2 = 12 Temp; printf ("A = %d\n", A); printf ("B = %d\n", B); printf ("*A = %d\n", *A); printf ("*B = %d\n", *B); No2 A = 1000 B = 1002 *A = 5 *B = 12 Temp = *A; *A = *B; *B = Temp; &1004 A &1002 &1008 B? 5 Temp &1012 printf ("A = %d\n", A); printf ("B = %d\n", B); printf ("Temp = %d\n", Temp); A = 1000 B = 1002 Temp = 5 65

66 [13] SwapB (Assume Compiler Assigns Memory Starting At (Decimal) ) int main(int argc, char * argv[]) No1 = 5, No2 = 12 ; printf ("No1 = %d\n", No1); printf ("No2 = %d\n", No2); SwapB( No1, No2); 5 12 No &1002 No1 = 5 No2 = 12 No2 printf ("No1 = %d\n", No1); printf ("No2 = %d\n", No2); No2 = 12 No1 = 5 void SwapB ( * A, * B) Temp; Temp = *A; *A = *B; *B = Temp; 66

67 Passing Arguments By Reference Very useful when we need a function which "returns more than one value". The formal parameter becomes an alias (a pointer to) for the actual parameter. The function can change the values of the actual arguments. 67

68 Function Square (No1) Write A Function Which Will c Explicitly Return The Square Of No1 68

69 Function No Arguments No Explicit Return long int Square (long int No1) long Product = No1 * No1; return (Product); Called From main int main(int argc, char * argv[]) long int No1 = 5; No1 Is Passed By Value printf ("Square(No1) = %d\n", Square(No1)); printf("square(10) = %ld\n", Square(10)); No1 = Square(12); printf("no1 = %ld\n", No1); 69

70 c SwapB Is Evoked/Called Pass Arguments By Reference POINTERS! 70

71 [1] Square (Assume Compiler Assigns Memory Starting At (Decimal) ) int main(int argc, char * argv[]) long int No1 = 5; 5 No1 printf ("No1 = %ld\n", No1); No1 = 5 long int Square (long int No1) return (No1 * No1); 71

72 [2] Square (Assume Compiler Assigns Memory Starting At (Decimal) ) int main(int argc, char * argv[]) long int No1 = 5; 5 No1 printf ("No1 = %ld\n", No1); No1 = 5 printf("square(no1) = %ld\n", Square(No1)); Create A long int Variable Whose Symbolic Name Is No1 And Fill It With The Value Of The First Argument In The Function Call. 5 &1004 No1 long int Square (long int No1) long Product = No1 * No1; return (Product); 72

73 [3] Square (Assume Compiler Assigns Memory Starting At (Decimal) ) int main(int argc, char * argv[]) long int No1 = 5; 5 No1 printf ("No1 = %ld\n", No1); No1 = 5 printf("square(no1) = %ld\n", Square(No1)); Create A long int Variable Whose Symbolic Name Is Product And Fill It With The No1 * No1 5 No1 & &1008 Product long int Square (long int No1) long Product = No1 * No1; return (Product); 73

74 [4] Square (Assume Compiler Assigns Memory Starting At (Decimal) ) int main(int argc, char * argv[]) long int No1 = 5; 5 No1 printf ("No1 = %ld\n", No1); No1 = 5 printf("square(no1) = %ld\n", Square(No1)); Return The Product to each and every place where Function Square Is Evoked/Called 5 &1004 No1 25 &1008 Product long int Square (long int No1) long Product = No1 * No1; return (Product); 74

75 [2] Square (Assume Compiler Assigns Memory Starting At (Decimal) ) int main(int argc, char * argv[]) long int No1 = 5; 5 No1 printf ("No1 = %ld\n", No1); No1 = 5 printf("square(no1) = %ld\n", Square(No1)); Displays 25 On Terminal Create A long int Variable Whose Symbolic Name Is Product And Fill It With The No1 * No1 5 No1 & &1008 Product long int Square (long int No1) long Product = No1 * No1; return (Product); 75

76 [5] Square (Assume Compiler Assigns Memory Starting At (Decimal) ) int main(int argc, char * argv[]) long int No1 = 5; 5 No1 printf("square(no1) = %ld\n", Square(No1)); printf("square(10) = %ld\n", Square(10)); No1 = Square(12); Fills No1 With 144 Displays 25 On Terminal Displays 100 On Terminal printf("no1 = %ld\n", No1); Displays 144 On Terminal Return The Product to each and every place where Function Square Is Evoked/Called 144 &1004 No1 25 &1008 Product long int Square (long int No1) long Product = No1 * No1; return (Product); 76

77 Function Increment (No1) Write A Function Which Will Add 1 To The Short Integer Whose Address Is Passed c REFERENCE VARIABLE Preview Of Things To Come C++ 77

78 Function No Arguments No Explicit Return void Increment ( & No1) No1++; No1 Is Passed By Reference int main(int argc, char * argv[]) No1 = 5; printf ("No1 = %d\n", No1); Increment(No1); Called From main Function Increment Has No Access To No1 Unless It's Values Are Passed In As Arguments. 78

79 c Increment Is Evoked/Called Preview Of C++ Reference Variables 79

80 [0] Increment (Assume Compiler Assigns Memory Starting At (Decimal) ) int main(int argc, char * argv[]) No1 = 5; printf ("No1 = %d\n", No1); 5 No1 No1 = 5 void Increment ( & No1) No1++; 80

81 [1] Increment (Assume Compiler Assigns Memory Starting At (Decimal) ) int main(int argc, char * argv[]) No1 = 5; 5 No1 printf ("No1 = %d\n", No1); No1 = 5 Increment(No1); Store &No1 In Pointer No1 &10042 No1 void Increment ( & No1) No1++; 81

82 [2] Increment (Assume Compiler Assigns Memory Starting At (Decimal) ) int main(int argc, char * argv[]) No1 = 5; 5 6 No1 printf ("No1 = %d\n", No1); No1 = 5 Increment(No1); printf ("No1 = %d\n", No1); No1 = 6 void Increment ( & No1) No1++; 82

83 Passing Arrays To c Functions? 83

84 Arrays Are Always Passed As Pointers Sizeof Cannot Be Used To Determine Capacity void FillIntArray(int Array[], int StartingNo, int NoElements) printf("fillintarray--> sizeof(array)= %ld\n", sizeof(array)); Array 5 StartingNo 4 NoElements &2000 &2004 &2008 int main (int argc, char * argv[]) int Nos[4]; I Have To Pass The NoToFill In Order To Know How Many Elements To Put Into Array printf("main--> sizeof(nos)= %ld\n", sizeof(nos)); FillIntArray(Nos, 5, 4); 20 bytes???????? Nos 84

85 Arrays Are Always Passed As Pointers Function Call Did Not Include &Nos? void FillIntArray(int Array[], int StartingNo, int NoElements) printf("fillintarray--> Array = %ld\n\n", Array); & Array 5 StartingNo 4 NoElements &2000 &2004 &2008 int main (int argc, char * argv[]) int Nos[4]; Note That The int Array[] Parameter Does Not Have A Value Such As [4] printf("fillintarray--> Array = %ld\n\n", Array); FillIntArray(Nos, 5, 4); 20 bytes???????? & Nos 85

86 Arrays Are Always Passed As Pointers Function Call Could Pass &Nos[0] void FillIntArray(int Array[], int StartingNo, int NoElements) printf("fillintarray--> Array = %ld\n\n", Array); & Array 5 StartingNo 4 NoElements &2000 &2004 &2008 int main (int argc, char * argv[]) 20 bytes int Nos[4]; printf("fillintarray--> Array = %ld\n\n", Array); FillIntArray(&Nos[0], 5, 4);???????? & Nos 86

87 Arrays Are Passed By Reference Arrays may have thousands/millions of elements; it would slow the program down if the compiler automatically copied all of the elements. We can manually make a copy of those elements in the small number of situations that this would be required. Sizeof cannot be used to determine capacity. The capacity/max will have to be passed or included in some type of struct or class. 87

88 Arrays Are Always Passed As Pointers Changing Nos[0] void FillIntArray(int Array[], int StartingNo, int NoElements) Array[0] = StartingNo; & Array 5 StartingNo 4 NoElements &2000 &2004 &2008 int main (int argc, char * argv[]) int Nos[4]; I Don't Want You To Take It On Faith That The Change In Nos[0] Has Occurred! FillIntArray(Nos, 5, 4); 20 bytes???????? 5 & Nos 88

89 void DisplayIntArray(int Array[], int NoElements) for (int Pos = NoElements - 1; Pos >= 0; Pos--) printf(" \n"); printf("%4ld %10ld \n", Pos, Array[Pos]); printf(" Arrays Are Always Passed As Pointers Confirm The Change Not A Very Good Display! \n\n"); int main (int argc, char * argv[]) int Nos[4]; FillIntArray(Nos, 5, 4); DisplayIntArray(Nos, 4); void FillIntArray(int Array[], int StartingNo, int NoElements) Array[0] = StartingNo;

90 Arrays Are Always Passed As Pointers Finish My FillIntArray void FillIntArray(int Array[], int StartingNo, int NoElements) for (int Pos = 0-1; Pos < NoElements; Pos++) Array[Pos] = StartingNo + Pos; void FillIntArray(int Array[], int StartingNo, int NoElements) Objective: Place StartingNo in Element 0 StartingNo + 1 in Element 1 StartingNo + 2 in Element 2 Continue Until All Elements Have Been Filled int main (int argc, char * argv[]) int Nos[4]; FillIntArray(Nos, 5, 4); DisplayIntArray(Nos, 4); 90

91 Character Strings Are Passed By Reference Character Strings are Arrays Of Character Character Strings Are Passed By Reference void ToLowerCase (char String[]) long int Pos; for (Pos = 0; Pos <= strlen(string); Pos ++) if ((String[Pos] >= 'A') && (String[Pos] <= 'Z')) String[Pos] = String[Pos] + 32; 91

92 c 92

93 A Complete Program - 1 // Includes # include <iostream> # include <fstream> # include <iomanip> # include <stdio.h> # include <string.h> # include <stdlib.h> using namespace std; 93

94 A Complete Program - 2 // Includes # include <iostream> # include <fstream> # include <iomanip> # include <stdio.h> # include <string.h> # include <stdlib.h> using namespace std; // Defines # define PI

95 A Complete Program - 3 // Includes # include <iostream> # include <fstream> # include <iomanip> # include <stdio.h> # include <string.h> # include <stdlib.h> using namespace std; // Defines # define PI 3.14 // Structs & Classes struct Student char FirstName[15], LastName[20]; long No; ; 95

96 A Complete Program - 4 // Includes # include <iostream> # include <fstream> # include <iomanip> # include <stdio.h> # include <string.h> # include <stdlib.h> using namespace std; // Defines # define PI 3.14 // Structs & Classes struct Student char FirstName[15], LastName[20]; long No; ; // Function Prototypes void HitCarriageReturnToContinue(void); void Set(Student * ThisStudent, char NewFirst[], char NewLast[], long NewNo); void Display(Student ThisStudent); 96

97 A Complete Program - 5 // Main & The Other Functions int main (int argc, char * argv[]) puts(" Start Of Main \n"); Student Jane; Set(&Jane, "Jane", "Doe", 1234); Display(Jane); puts (" HitCarriageReturnToContinue(); return (0); End Of Main \n"); 97

98 A Complete Program - 6 // Main & The Other Functions void Set(Student * ThisStudent, char NewFirst[], char NewLast[], long NewNo) ThisStudent->No = NewNo; strcpy_s(thisstudent->firstname, NewFirst); strcpy_s(thisstudent->lastname, NewLast); void Display(Student ThisStudent) printf("no = %d\n", ThisStudent.No); printf("first = %s\n", ThisStudent.FirstName); printf("second = %s\n\n", ThisStudent.LastName); 98