Question? Leave a message!




FILE I/O Reading and Writing

FILE I/O Reading and Writing
CIS 190: C/C++ Programming Lecture 4 Assorted Topics (and More on Pointers) 1 Outline • Makefiles • File I/O • Command Line Arguments • Random Numbers • ReCovering Pointers • Memory and Functions • Homework 2 Makefiles • list of rules you can call from the terminal –make ruleTwo will call the ruleTwo –make will call first rule in the file • basic formatting – use at line beginning to denote comments – must use tab character, not 8 spaces 3 Rule Construction target: dependencies (optional) command another command (optional) • target (rule name) • dependency (right side of colon) • command (explicit commands) 4 Creating a Rule • let’s create a rule to compile and link the files for Homework 4A: hw4a.c karaoke.c karaoke.h • what commands will let us do this 5 Creating a Rule we need to, in order: 1. separately compile hw4a.c 2. separately compile karaoke.c 3. link hw4a.o and karaoke.o together 6 Creating a Rule 1. separately compile hw4a.c • we’ll make a rule called hw4a.o • what command would we run in the terminal • what files does it need to work 7 Creating a Rule 1. separately compile hw4a.c • we’ll make a rule called hw4a.o • what command would we run in the terminal • what files does it need to work – hw4a.c – so it’s dependent on hw4a.c 8 Creating a Rule 2. separately compile karaoke.c • we’ll call this rule karaoke.o • what command will compile karaoke.c • what files does it need to work 9 Creating a Rule 2. separately compile karaoke.c • we’ll call this rule karaoke.o • what command will compile karaoke.c • what files does it need to work – karaoke.c – so it’s dependent on karaoke.c 10 Creating a Rule 3. link hw4a.o and karaoke.o together • we’ll call this rule hw4a • what command will link the files together • what files does it depend on 11 Creating a Rule 3. link hw4a.o and karaoke.o together • we’ll call this rule hw4a • what command will link the files together • what files does it depend on – hw4a.o – karaoke.o – so it’s dependent on both of these files 12 Other Common Rules • a rule to remove .o and executable files clean: rm –f .o hw4a • a rule to remove garbage files cleaner: rm –f • a rule to run both cleanest: clean cleaner 13 Why Use Makefiles • makes compiling, linking, executing, etc – easier – quicker – less prone to human error • allows use to create and run helper rules – clean up unneeded files (like hw2.c or trains.o) – open files for editing 14 Makefiles and Beyond • there’s much more you can do with Makefiles – variables – conditionals – system configuration – phony targets • more information available here http://www.chemie.fuberlin.de/chemnet/use /info/make/maketoc.html 15 Outline • Makefiles • File I/O • Command Line Arguments • Random Numbers • ReCovering Pointers • Memory and Functions • Homework 16 Input and Output • printf – stdout – output written to the terminal • scanf – stdin – input read in from user • redirection – executable input.txt output.txt 17 FILE I/O Basics • allow us to read in from and print out to files – instead of from and to the terminal • use a file pointer (FILE) to manage the file(s) we want to be handling • naming conventions: FILE ofp; / output file pointer / FILE ifp; / input file pointer / 18 Opening a File FILE fopen (filename, mode); • fopen() returns a FILE pointer – hopefully to a successfully opened file • filename is a string • mode is singlecharacter string 19 FILE I/O Reading and Writing ifp = fopen(“input.txt”, “r”); • opens input.txt for reading – file must already exist 20 FILE I/O Reading and Writing ifp = fopen(“input.txt”, “r”); • opens input.txt for reading – file must already exist ofp = fopen(“output.txt”, “w”); • opens output.txt for writing – if file exists, it will be overwritten 21 FILE I/O Reading and Writing ifp = fopen(“input.txt”, “r”); • opens input.txt for reading – file must already exist ofp = fopen(“output.txt”, “w”); • opens output.txt for writing – if file exists, it will be overwritten 22 Dealing with FILE Pointers • FILE pointers should be handled with the same care as allocated memory 1. check that it works before using 2. gracefully handle failure 3. free when finished 23 Handling FILE Pointers 1. check that it worked before using • if the FILE pointer is NULL, there was an error 2. gracefully handle failure • print out an error message • exit or reprompt the user, as appropriate 3. free the pointer when finished • use fclose() and pass in the file pointer 24 Standard Streams in C • three standard streams: stdin, stdout, stderr • printf() and scanf() automatically access stdout and stdin, respectively • printing to stderr prints to the terminal – even if we use redirection 25 Using File Pointers • fprintf fprintf(ofp, “print: s\n”, textStr); – output written to where ofp points • fscanf fscanf(ifp, “d”, inputInt); – input read in from where ifp points LIVECODING LIVECODING 26 Using stderr with fprintf / if an error occurs / if (error) fprintf(stderr, “An error occurred”); exit(1); / exit() requires stdlib.h / LIVECODING LIVECODING 27 Reaching EOF with fscanf • fscanf() returns an integer – number of items in argument list that were filled • if no data is read in, it returns EOF – EOF = End Of File (predefined) • once EOF is returned, we have reached the end of the file – handle appropriately (e.g., close) LIVECODING LIVECODING 28 Reaching EOF Example • example usage: while (fscanf(ifp, “s”, str) = EOF) / do things / / while loop exited, EOF reached / • to use fscanf() effectively, it helps to know basic information about the layout of the file LIVECODING LIVECODING 29 Outline • Makefiles • File I/O • Command Line Arguments • Random Numbers • ReCovering Pointers • Memory and Functions • Homework 30 Giving Command Line Arguments • command line arguments are given after the executable name on the command line – allows user to change parameters at run time without recompiling or needing access to code – also sometimes called CLAs • for example, the following might allow a user to set the maximum number of train cars: ./hw2 25 31 Handling Command Line Arguments • handled as parameters to main() function int main(int argc, char argv) • int argc – number of arguments – including name of executable • char argv – array of argument strings 32 More About argc/argv • names are by convention, not required • char argv can also be written as char argv • argv is just an array of strings (the arguments) • for example, argv0 is the executable − since that is the first argument passed in 33 Command Line Argument Example ./hw2 25 Savannah – set max of cars and a departure city 34 Command Line Argument Example ./hw2 25 Savannah – set max of cars and a departure city • in this example: –argc = –argv0 is –argv1 is –argv2 is 35 Command Line Argument Example ./hw2 25 Savannah – set max of cars and a departure city • in this example: –argc = 3 (executable, number, and city) 36 Command Line Argument Example ./hw2 25 Savannah – set max of cars and a departure city • in this example: –argc = 3 (executable, number, and city) –argv0 is “./hw2” 37 Command Line Argument Example ./hw2 25 Savannah – set max of cars and a departure city • in this example: –argc = 3 (executable, number, and city) –argv0 is “./hw2” –argv1 is “25” 38 Command Line Argument Example ./hw2 25 Savannah – set max of cars and a departure city • in this example: –argc = 3 (executable, number, and city) –argv0 is “./hw2” –argv1 is “25” –argv2 is “Savannah” 39 How to Use argc • before we begin using CLAs, we need to make sure that we have been given what we expect • check that the value of argc is correct – that the number of arguments is correct • if it’s not correct, exit and prompt user with expected program usage LIVECODING LIVECODING 40 How to Use argv • char argv is an array of strings • if an argument needs to be an integer, we must convert it from a string – using the atoi() function (from stdlib.h) intArg = atoi(“5”); intArg = atoi( argv2 ); LIVECODING LIVECODING 41 Optional Command Line Arguments • argument(s) can optional – e.g., default train to size 20 if max size not given • number of acceptable CLAs is now a range, or at least a minimum number • should only use the CLAs you actually have 42 Handling Optional CLAs if (argc MAXARGS) / print out error message / exit(1); if (argc = SIZEARG+1) trainSize = argvSIZEARG; else trainSize = DEFAULTTRAINSIZE; 43 Outline • Makefiles • File I/O • Command Line Arguments • Random Numbers • ReCovering Pointers • Memory and Functions • Homework 44 Random Numbers • useful for many things: – cryptography, games of chance probability, procedural generation, statistical sampling • random numbers generated via computer can only be pseudorandom 45 Pseudo Randomness • “Anyone who considers arithmetical methods of producing random digits is, of course, in a state of sin.” – John von Neumann • pseudorandom – appears to be random, but actually isn’t – mathematically generated, so it can’t be 46 Seeding for Randomness • you can seed the random number generator • same seed means same “random” numbers – good for testing, allow identical runs void srand (unsigned int seed); srand(1); srand(seedValue); 47 Seeding with User Input • can allow the user to choose the seed – gives user more control over how program runs srand(userSeedChoice); • obtain user seed choice via – inprogram prompt (“Please enter seed: ”) – as a command line argument • can make this an optional CLA 48 Seeding with Time • can also give a “unique” seed with time() – need to include time.h library • time() returns the seconds since the “epoch” – normally since 00:00 hours, Jan 1, 1970 UTC • NOTE: if you want to use the time() function, you can not have a variable called time error: called object ‘time’ is not a function 49 Example of Seeding with time() • get the seconds since epoch int timeSeed = (int) time(0); –time() wants a pointer, so just give it 0 – returns a timet object, so we cast as int • use timeSeed to seed the rand() function srand(timeSeed); • NOTE: running again within a second will return the same value from time() 50 Generating Random Numbers int rand (void); • call the rand() function each time you want a random number int randomNum = rand(); • integer returned is between 0 and RANDMAX – RANDMAX guaranteed to be at least 32767 51 Getting a Usable Random Number • if we want a smaller range than 0 32767 • use (mod) to get the range you want / 1 to MAX / int random = (rand() MAX) + 1; / returns MIN to MAX, inclusive / int random = rand() (MAX – MIN + 1) + MIN; 52 Outline • Makefiles • File I/O • Command Line Arguments • Random Numbers • ReCovering Pointers • Memory and Functions • Homework 53 Why Pointers Again • important programming concept • understand what’s going on “inside” • other languages use pointers heavily – you just don’t see them • but pointers can be difficult to understand – abstract concept – unlike what you’ve learned before 54 Memory Basics – Regular Variables • all variables have two parts: – value 5 55 Memory Basics – Regular Variables • all variables have two parts: – value – address where value is stored 0xFFC0 5 56 Memory Basics – Regular Variables • all variables have two parts: – value – address where value is stored 0xFFC0 5 value • x’s value is 5 57 Memory Basics – Regular Variables • all variables have two parts: – value – address where value is stored 0xFFC0 5 address value • x’s value is 5 • x’s address is 0xFFC0 58 Memory Basics – Regular Variables • so the code to declare this is: int x = 5; 0xFFC0 5 address value 59 Memory Basics – Regular Variables • we can also declare a pointer: int x = 5; int ptr; 0xFFC0 5 address value 60 Memory Basics – Regular Variables • and set it equal to the address of x: int x = 5; int ptr; ptr = x; 0xFFC0 5 address value 61 Memory Basics – Regular Variables • ptr = x 0xFFC0 5 address value 62 Memory Basics – Regular Variables • ptr = x • ptr = x 0xFFC0 5 address value 63 Memory Basics – Regular Variables • ptr points to the address where x is stored • ptr gives us the value of x – (dereferencing ptr) 0xFFC0 5 address value 64 Memory Basics – Pointer Variables • but what about the variable ptr – does it have a value and address too 0xFFC0 5 address value 65 Memory Basics – Pointer Variables • but what about the variable ptr – does it have a value and address too • YES 0xFFC0 5 address value 66 Memory Basics – Pointer Variables • ptr’s value is just “ptr” – and it’s 0xFFC0 0xFFC0 5 address value 67 Memory Basics – Pointer Variables • ptr’s value is just “ptr” – and it’s 0xFFC0 0xFFC0 0xFFC0 5 value address value 68 Memory Basics – Pointer Variables • ptr’s value is just “ptr” – and it’s 0xFFC0 • but what about its address 0xFFC0 0xFFC0 5 value address value 69 Memory Basics – Pointer Variables • ptr’s value is just “ptr” – and it’s 0xFFC0 • but what about its address – its address is ptr 0xFFC0 0xFFC0 5 value address value 70 Memory Basics – Pointer Variables • ptr’s value is just “ptr” – and it’s 0xFFC0 • but what about its address – its address is ptr 0xFFC4 0xFFC0 0xFFC0 5 address value address value 71 Memory Basics – Pointer Variables • if you want, you can think of value and address for pointers as this instead… 0xFFC4 0xFFC0 0xFFC0 5 address value address value 72 Memory Basics – Pointer Variables • address where it’s stored in memory 0xFFC4 0xFFC0 0xFFC0 5 address value address value where it’s stored in memory 73 Memory Basics – Pointer Variables • address where it’s stored in memory • value where it points to in memory 0xFFC4 0xFFC0 0xFFC0 5 address value address value where it’s where it stored in points to in memory memory 74 Memory Basics – “Owning” Memory • each process gets its own memory chunk, or address space 0x000000 Stack Function calls, locals Dynamically 4 GB Heap allocated address memory space “data segment” Global/static vars “code segment” Code 0xFFFFFFF 75 Memory Basics – “Owning” Memory • you can think of memory as being “owned” by: – the OS • most of the memory the computer has – the process • a chunk of memory given by the OS – about 4 GB – the program • memory (on the stack) given to it by the process – you • when you dynamically allocate memory in the program (memory given to you by the process ) 76 Memory Basics – “Owning” Memory • the Operating System has a very large amount of memory available to it the OS the OS the OS the OS 77 Memory Basics – “Owning” Memory • when the process begins, the Operating System gives it a chunk of that memory Stack the OS the OS the OS Heap Global/static vars Code 78 Memory Basics – “Owning” Memory • when the process begins, the Operating System gives it a chunk of that memory Stack Heap Global/static vars Code 79 Memory Basics – “Owning” Memory • when the process begins, the Operating System gives it a chunk of that memory Stack Heap Global/static vars Code 80 Memory Basics – “Owning” Memory • within that chunk of memory, only the stack and the heap are available to you and the program Stack Heap Global/static vars Code 81 Memory Basics – “Owning” Memory • within that chunk of memory, only the stack and the heap are available to you and the program Stack Heap 82 Memory Basics – “Owning” Memory • within that chunk of memory, only the stack and the heap are available to you and the program Stack Heap 83 Memory Basics – “Owning” Memory • some parts of the stack are given to the program for variables Stack Heap 84 Memory Basics – “Owning” Memory • some parts of the stack are given to the program for variables program variables Stack Heap 85 Memory Basics – “Owning” Memory • and when a function is called, the program is given more space on the stack for the return address and infunction program variables variables function return address variables Stack Heap 86 Memory Basics – “Owning” Memory • and every time you allocate memory, the process gives you space for it on the heap program variables function return address variables Stack Heap 87 Memory Basics – “Owning” Memory • and every time you allocate memory, the process gives you space for it on the heap program variables CAR train; function return address variables Stack char userStr; int intArray; Heap 88 Memory Basics – “Owning” Memory • and every time you allocate memory, the process gives you space for it on the heap program variables CAR train; function return address variables Stack char userStr; int intArray; train Heap userStr intArray 89 Memory Basics – “Owning” Memory • and every time you allocate memory, the process gives you space for it on the heap program variables function return address variables Stack train Heap userStr intArray = (int) malloc(…) intArray 90 Memory Basics – “Owning” Memory • and every time you allocate memory, the process gives you space for it on the heap program variables function return address variables Stack train Heap userStr = (char) malloc(…) userStr intArray = (int) malloc(…) intArray 91 Memory Basics – “Owning” Memory • and every time you allocate memory, the process gives you space for it on the heap program variables function return address variables Stack train = (CAR) malloc(…) train Heap userStr = (char) malloc(…) userStr intArray = (int) malloc(…) intArray 92 Memory Basics – “Owning” Memory • don’t forget – those pointers are program variables, so where they are stored is actually on the stack with the rest program variables of the program variables function return address variables Stack – they are program variables because they are declared in the program’s code (also program variables) train = (CAR) malloc(…) train Heap userStr = (char) malloc(…) userStr intArray = (int) malloc(…) intArray 93 Memory Basics – “Returning” Memory • but how does the process get any of that memory back program variables function return address variables Stack (also program variables) train = (CAR) malloc(…) train Heap userStr = (char) malloc(…) userStr intArray = (int) malloc(…) intArray 94 Memory Basics – “Returning” Memory • when a function returns, the program gives that memory on the stack back to the process program variables function return address variables Stack (also program variables) train = (CAR) malloc(…) train Heap userStr = (char) malloc(…) userStr intArray = (int) malloc(…) intArray 95 Memory Basics – “Returning” Memory • when a function returns, the program gives that memory on the stack back to the process program variables function return address variables Stack return fxnAnswer; (also program variables) train = (CAR) malloc(…) train Heap userStr = (char) malloc(…) userStr intArray = (int) malloc(…) intArray 96 Memory Basics – “Returning” Memory • when a function returns, the program gives that memory on the stack back to the process program variables function return address variables Stack return fxnAnswer; (also program variables) train = (CAR) malloc(…) train Heap userStr = (char) malloc(…) userStr intArray = (int) malloc(…) intArray 97 Memory Basics – “Returning” Memory • when a function returns, the program gives that memory on the stack back to the process program variables Stack (also program variables) train = (CAR) malloc(…) train Heap userStr = (char) malloc(…) userStr intArray = (int) malloc(…) intArray 98 Memory Basics – “Returning” Memory • and when you use free(), the memory you had on the heap is given back to the process program variables Stack (also program variables) train = (CAR) malloc(…) train Heap userStr = (char) malloc(…) userStr intArray = (int) malloc(…) intArray 99 Memory Basics – “Returning” Memory • and when you use free(), the memory you had on the heap is given back to the process program variables Stack free(intArray); (also program variables) train = (CAR) malloc(…) train Heap userStr = (char) malloc(…) userStr intArray = (int) malloc(…) intArray 100 Memory Basics – “Returning” Memory • and when you use free(), the memory you had on the heap is given back to the process program variables Stack free(intArray); (also program variables) train = (CAR) malloc(…) train Heap userStr = (char) malloc(…) userStr intArray = (int) malloc(…) intArray 101 Memory Basics – “Returning” Memory • and when you use free(), the memory you had on the heap is given back to the process program variables Stack (also program variables) train = (CAR) malloc(…) train Heap userStr = (char) malloc(…) userStr intArray 102 Memory Basics – Memory Errors • but simply using free() doesn’t change anything about the intArray variable program variables Stack (also program variables) train = (CAR) malloc(…) train Heap userStr = (char) malloc(…) userStr intArray 103 Memory Basics – Memory Errors • but simply using free() doesn’t change anything about the intArray variable • it still points to that space program variables in memory Stack (also program variables) train = (CAR) malloc(…) train Heap userStr = (char) malloc(…) userStr intArray 104 Memory Basics – Memory Errors • but simply using free() doesn’t change anything about the intArray variable • it still points to that space program variables in memory Stack • it’s still stored on the stack with the rest of the variables (also program variables) train = (CAR) malloc(…) train Heap userStr = (char) malloc(…) userStr intArray 105 Memory Basics – Memory Errors • intArray is now a program variables Stack (also program variables) train = (CAR) malloc(…) train Heap userStr = (char) malloc(…) userStr intArray 106 Memory Basics – Memory Errors • intArray is now a dangling pointer program variables Stack (also program variables) train = (CAR) malloc(…) train Heap userStr = (char) malloc(…) userStr intArray 107 Memory Basics – Memory Errors • intArray is now a dangling pointer – points to memory that has been freed program variables Stack (also program variables) train = (CAR) malloc(…) train Heap userStr = (char) malloc(…) userStr intArray 108 Memory Basics – Memory Errors • intArray is now a dangling pointer – points to memory that has been freed program variables Stack (also program variables) train = (CAR) malloc(…) train Heap userStr = (char) malloc(…) userStr intArray 109 Memory Basics – Memory Errors • intArray is now a dangling pointer – points to memory that has been freed – memory which is now back program variables to being owned by the process, not you Stack (also program variables) train = (CAR) malloc(…) train Heap userStr = (char) malloc(…) userStr intArray 110 Memory Basics – Memory Errors • if we tried to free() intArray’s memory again • we would get a program variables Stack (also program variables) train = (CAR) malloc(…) train Heap userStr = (char) malloc(…) userStr intArray 111 Memory Basics – Memory Errors • if we tried to free() intArray’s memory again • we would get a program variables Stack (also program variables) train = (CAR) malloc(…) train Heap userStr = (char) malloc(…) userStr intArray 112 Memory Basics – Memory Errors • if we tried to free() intArray’s memory again • we would get a • to prevent segfaults, program variables good programming practices Stack dictate that after free()ing, we set intArray to be equal to (also program variables) train = (CAR) malloc(…) train Heap userStr = (char) malloc(…) userStr intArray 113 Memory Basics – Memory Errors • if we tried to free() intArray’s memory again • we would get a • to prevent segfaults, program variables good programming practices Stack dictate that after free()ing, we set intArray to be equal to NULL (also program variables) train = (CAR) malloc(…) train Heap userStr = (char) malloc(…) userStr intArray 114 Memory Basics – Memory Errors • NOTE: if you try to free a NULL pointer, no action occurs (and it doesn’t segfault) program variables • much safer than accidentally Stack double free()ing memory (also program variables) train = (CAR) malloc(…) train Heap userStr = (char) malloc(…) userStr intArray 115 NULL Memory Basics – Running Out • the process is capable of giving memory to you and the program as many times as necessary (including having program variables that memory returned), as Stack long as it doesn’t run out of memory to hand out (also program variables) train = (CAR) malloc(…) train Heap userStr = (char) malloc(…) userStr intArray 116 NULL Memory Basics – Running Out • if you try to allocate memory, but there’s not enough contiguous space to handle your request program variables Stack (also program variables) train = (CAR) malloc(…) train Heap userStr = (char) malloc(…) userStr intArray 117 NULL Memory Basics – Running Out • if you try to allocate memory, but there’s not enough contiguous space to handle your request program variables intArray = (int) Stack malloc ( sizeof(int) HUGENUM); (also program variables) train = (CAR) malloc(…) train Heap userStr = (char) malloc(…) userStr intArray 118 NULL Memory Basics – Running Out • if you try to allocate memory, but there’s not enough contiguous space to handle your request program variables intArray = (int) Stack malloc ( sizeof(int) intArray = (int) malloc (sizeof(int) HUGENUM) HUGENUM); (also program variables) train = (CAR) malloc(…) train Heap userStr = (char) malloc(…) userStr intArray 119 NULL Memory Basics – Running Out • if you try to allocate memory, but there’s not enough contiguous space to handle your request program variables intArray = (int) Stack malloc ( sizeof(int) intArray = (int) malloc (sizeof(int) HUGENUM) HUGENUM); (also program variables) train = (CAR) malloc(…) train Heap userStr = (char) malloc(…) userStr intArray 120 NULL Memory Basics – Running Out • if you try to allocate memory, but there’s not enough contiguous space to handle your request program variables intArray = (int) Stack malloc ( sizeof(int) intArray = (int) malloc (sizeof(int) HUGENUM) HUGENUM); (also program variables) train = (CAR) malloc(…) train Heap userStr = (char) malloc(…) userStr intArray 121 NULL Memory Basics – Running Out • if you try to allocate memory, but there’s not enough contiguous space to handle your request program variables • malloc will return NULL Stack (also program variables) train = (CAR) malloc(…) train Heap userStr = (char) malloc(…) userStr intArray 122 NULL Memory Basics – Running Out • if you try to allocate memory, but there’s not enough contiguous space to handle your request program variables • malloc will return NULL Stack • that’s why you must check that intArray = NULL before you use it (also program variables) train = (CAR) malloc(…) train Heap userStr = (char) malloc(…) userStr intArray 123 NULL Quick Note on Segfaults • segfaults are not consistent (unfortunately) • even if something should result in a segfault, it might not (and then occasionally it will) – this doesn’t mean there isn’t an error – C is trying to be “nice” to you when it can • you have to be extrasuperdupercareful with your memory management 124 Outline • Makefiles • File I/O • Command Line Arguments • Random Numbers • ReCovering Pointers • Memory and Functions • Homework 125 Memory and Functions • how do different types of variables get passed to and returned from functions • passing by value • passing by reference – implicit: arrays, strings – explicit: pointers 126 Memory and Functions • some simple examples: int Add(int x, int y); int answer = Add(1, 2); void PrintMenu(void); PrintMenu(); int GetAsciiValue(char c); int ascii = GetAsciiValue (‘m’); • all passed by value 127 Memory and Functions • passing arrays to functions void TimesTwo(int array, int size); int arr ARRSIZE; / set values of arr / TimesTwo(arr, ARRSIZE); • arrays of any type are passed by reference – changes made infunction persist 128 Memory and Functions • passing arrays to functions void TimesTwo(int array, int size); void TimesTwo(int array, int size); • both of these behave the same way – they take a pointer to: • the beginning of an array • an int – that we (can) treat like an array 129 Memory and Functions • passing strings to functions void PrintName(char name); void PrintName(char name ); char myName NAMESIZE = “Alice”; PrintName(myName); • strings are arrays (of characters) – implicitly passed by reference 130 Memory and Functions • passing pointers to int to functions void Square(int n); int x = 9; Square(x); • pass address of an integer (in this case, x) 131 Memory and Functions • passing int pointers to function void Square(int n); int x = 9; int xPtr = x; Square(); • pass 132 Memory and Functions • passing int pointers to function void Square(int n); int x = 9; int xPtr = x; Square(xPtr); • pass xPtr, which is an address to an integer (x) 133 Memory and Functions • returning pointers from functions CAR MakeCar(void) CAR temp; return temp; • temp is on the stack – so what happens 134 Memory and Functions • returning pointers from functions CAR MakeCar(void) CAR temp; return temp; • temp is on the stack – so it will be returned to the process when MakeCar() returns 135 Memory and Functions • returning pointers from functions CAR MakeCar(void) CAR temp; temp = (CAR) malloc (sizeof(CAR)); return temp; • temp is on the heap – so what happens 136 Memory and Functions • returning pointers from functions CAR MakeCar(void) CAR temp; temp = (CAR) malloc (sizeof(CAR)); return temp; • temp is on the heap – so it belongs to you and will remain on the heap until you free() it 137 Outline • Makefiles • File I/O • Command Line Arguments • Random Numbers • ReCovering Pointers • Memory and Functions • Homework 138 Homework 4A • Karaoke • File I/O • command line arguments • allocating memory • no grade for Homework 4A • turn in working code or 10 points for HW 4B 139 Quick Notes • answered questions from HW2 on Piazza • magic numbers – should use defines as you code – not replace with define after you’re done • elegant solution to printing the full train 140