CIS 190: C/C++ Programming
Lecture 4
Assorted Topics
(and More on Pointers)
1
Outline
Makefiles
File I/O
Command Line Arguments
Random Numbers
Re-Covering 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
Rule Construction
target: dependencies (optional)
command
another command (optional)
target (rule name)
dependency (right side of colon)
command (explicit commands)
4
Creating a Rule
lets 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
Creating a Rule
1. separately compile hw4a.c
well make a rule called hw4a.o
what command would we run in the terminal?
what files does it need to work?
Creating a Rule
1. separately compile hw4a.c
well make a rule called hw4a.o
what command would we run in the terminal?
what files does it need to work?
hw4a.c
so its dependent on hw4a.c
Creating a Rule
2. separately compile karaoke.c
well call this rule karaoke.o
what command will compile karaoke.c?
what files does it need to work?
Creating a Rule
2. separately compile karaoke.c
well call this rule karaoke.o
what command will compile karaoke.c?
what files does it need to work?
karaoke.c
so its dependent on karaoke.c
10
Creating a Rule
3. link hw4a.o and karaoke.o together
well 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
well call this rule hw4a
what command will link the files together?
what files does it depend on?
hw4a.o
karaoke.o
so its 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
theres much more you can do with Makefiles
variables
conditionals
system configuration
phony targets
more information available here
[Link]
/info/make/make_toc.html
15
Outline
Makefiles
File I/O
Command Line Arguments
Random Numbers
Re-Covering 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 < [Link] > [Link]
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 single-character string
19
FILE I/O Reading and Writing
ifp = fopen([Link], r);
opens [Link] for reading
file must already exist
20
FILE I/O Reading and Writing
ifp = fopen([Link], r);
opens [Link] for reading
file must already exist
ofp = fopen([Link], w);
opens [Link] for writing
if file exists, it will be overwritten
21
FILE I/O Reading and Writing
ifp = fopen([Link], r);
opens [Link] for reading
file must already exist
ofp = fopen([Link], w);
opens [Link] 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 re-prompt 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
26
Using stderr with fprintf
/* if an error occurs */
if (error)
{
fprintf(stderr,
An error occurred!);
exit(-1);
/* exit() requires <stdlib.h> */
}
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 (pre-defined)
once EOF is returned, we have reached the
end of the file
handle appropriately (e.g., close)
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
29
Outline
Makefiles
File I/O
Command Line Arguments
Random Numbers
Re-Covering 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, argv[0] 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 = ???
argv[0] is ???
argv[1] is ???
argv[2] 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)
argv[0] 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)
argv[0] is ./hw2
argv[1] 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)
argv[0] is ./hw2
argv[1] is 25
argv[2] 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 its not correct, exit and prompt user
with expected program usage
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( argv[2] );
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 > MAX_ARGS) {
/* print out error message */
exit(-1);
}
if (argc >= SIZE_ARG+1) {
trainSize = argv[SIZE_ARG];
} else {
trainSize = DEFAULT_TRAIN_SIZE;
}
43
Outline
Makefiles
File I/O
Command Line Arguments
Random Numbers
Re-Covering 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 isnt
mathematically generated, so it cant 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
in-program 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 time_t 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 RAND_MAX
RAND_MAX 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
Re-Covering Pointers
Memory and Functions
Homework
53
Why Pointers Again?
important programming concept
understand whats going on inside
other languages use pointers heavily
you just dont see them!
but pointers can be difficult to understand
abstract concept
unlike what youve learned before
54
Memory Basics Regular Variables
all variables have two parts:
value
55
Memory Basics Regular Variables
all variables have two parts:
value
address where value is stored
0xFFC0
56
Memory Basics Regular Variables
all variables have two parts:
value
address where value is stored
0xFFC0
xs value is 5
5
value
57
Memory Basics Regular Variables
all variables have two parts:
value
address where value is stored
xs value is 5
xs address is 0xFFC0
0xFFC0
address
value
58
Memory Basics Regular Variables
so the code to declare this is:
int x = 5;
0xFFC0
address
value
59
Memory Basics Regular Variables
we can also declare a pointer:
int x = 5;
int *ptr;
0xFFC0
address
value
60
Memory Basics Regular Variables
and set it equal to the address of x:
int x = 5;
int *ptr;
ptr = &x;
0xFFC0
address
value
61
Memory Basics Regular Variables
ptr = &x
0xFFC0
address
value
62
Memory Basics Regular Variables
ptr = &x
*ptr = x
0xFFC0
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
address
value
64
Memory Basics Pointer Variables
but what about the variable ptr?
does it have a value and address too?
0xFFC0
address
value
65
Memory Basics Pointer Variables
but what about the variable ptr?
does it have a value and address too?
YES!!!
0xFFC0
address
value
66
Memory Basics Pointer Variables
ptrs value is just ptr and its 0xFFC0
0xFFC0
address
value
67
Memory Basics Pointer Variables
ptrs value is just ptr and its 0xFFC0
0xFFC0
0xFFC0
value
address
value
68
Memory Basics Pointer Variables
ptrs value is just ptr and its 0xFFC0
but what about its address?
0xFFC0
0xFFC0
value
address
value
69
Memory Basics Pointer Variables
ptrs value is just ptr and its 0xFFC0
but what about its address?
its address is &ptr
0xFFC0
0xFFC0
value
address
value
70
Memory Basics Pointer Variables
ptrs value is just ptr and its 0xFFC0
but what about its address?
its address is &ptr
0xFFC4
0xFFC0
0xFFC0
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
address
value
address
value
72
Memory Basics Pointer Variables
address where its stored in memory
0xFFC4
0xFFC0
0xFFC0
address
where its
stored in
memory
value
address
value
73
Memory Basics Pointer Variables
address where its stored in memory
value where it points to in memory
0xFFC4
0xFFC0
0xFFC0
address
where its
stored in
memory
value
where it
points to in
memory
address
value
74
Memory Basics Owning Memory
each process gets its own memory chunk,
or address space
0x000000
Stack
4 GB
address
space
0xFFFFFFF
Heap
Function calls,
locals
Dynamically
allocated
memory
Global/static vars
data segment
Code
code segment
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
the OS
the OS
the OS
Stack
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 in-function
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;
char* userStr;
int* intArray;
function return address & variables
Stack
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;
char* userStr;
int* intArray;
function return address & variables
Stack
?
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
intArray = (int*) malloc()
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
userStr = (char*) malloc()
intArray
intArray = (int*) malloc()
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
Heap
train
train = (CAR*) malloc()
userStr
userStr = (char*) malloc()
intArray
intArray = (int*) malloc()
92
Memory Basics Owning Memory
dont 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 programs code
(also program
variables)
Heap
train
train = (CAR*) malloc()
userStr
userStr = (char*) malloc()
intArray
intArray = (int*) malloc()
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)
Heap
train
train = (CAR*) malloc()
userStr
userStr = (char*) malloc()
intArray
intArray = (int*) malloc()
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)
Heap
train
train = (CAR*) malloc()
userStr
userStr = (char*) malloc()
intArray
intArray = (int*) malloc()
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
return fxnAnswer;
Stack
(also program
variables)
Heap
train
train = (CAR*) malloc()
userStr
userStr = (char*) malloc()
intArray
intArray = (int*) malloc()
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
return fxnAnswer;
Stack
(also program
variables)
Heap
train
train = (CAR*) malloc()
userStr
userStr = (char*) malloc()
intArray
intArray = (int*) malloc()
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)
Heap
train
train = (CAR*) malloc()
userStr
userStr = (char*) malloc()
intArray
intArray = (int*) malloc()
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)
Heap
train
train = (CAR*) malloc()
userStr
userStr = (char*) malloc()
intArray
intArray = (int*) malloc()
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)
Heap
train
train = (CAR*) malloc()
userStr
userStr = (char*) malloc()
intArray
intArray = (int*) malloc()
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)
Heap
train
train = (CAR*) malloc()
userStr
userStr = (char*) malloc()
intArray
intArray = (int*) malloc()
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)
Heap
train
train = (CAR*) malloc()
userStr
userStr = (char*) malloc()
intArray
102
Memory Basics Memory Errors
but simply using free() doesnt change
anything about the intArray variable
program variables
Stack
(also program
variables)
Heap
train
train = (CAR*) malloc()
userStr
userStr = (char*) malloc()
intArray
103
Memory Basics Memory Errors
but simply using free() doesnt change
anything about the intArray variable
it still points to that space
program variables
in memory
Stack
(also program
variables)
Heap
train
train = (CAR*) malloc()
userStr
userStr = (char*) malloc()
intArray
104
Memory Basics Memory Errors
but simply using free() doesnt change
anything about the intArray variable
it still points to that space
program variables
in memory
Stack
its still stored on the stack
with the rest of the variables
(also program
variables)
Heap
train
train = (CAR*) malloc()
userStr
userStr = (char*) malloc()
intArray
105
Memory Basics Memory Errors
intArray is now a
program variables
Stack
(also program
variables)
Heap
train
train = (CAR*) malloc()
userStr
userStr = (char*) malloc()
intArray
106
Memory Basics Memory Errors
intArray is now a dangling pointer
program variables
Stack
(also program
variables)
Heap
train
train = (CAR*) malloc()
userStr
userStr = (char*) malloc()
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)
Heap
train
train = (CAR*) malloc()
userStr
userStr = (char*) malloc()
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)
Heap
train
train = (CAR*) malloc()
userStr
userStr = (char*) malloc()
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)
Heap
train
train = (CAR*) malloc()
userStr
userStr = (char*) malloc()
intArray
110
Memory Basics Memory Errors
if we tried to free() intArrays memory again
we would get a
program variables
Stack
(also program
variables)
Heap
train
train = (CAR*) malloc()
userStr
userStr = (char*) malloc()
intArray
111
Memory Basics Memory Errors
if we tried to free() intArrays memory again
we would get a
program variables
Stack
(also program
variables)
Heap
train
train = (CAR*) malloc()
userStr
userStr = (char*) malloc()
intArray
112
Memory Basics Memory Errors
if we tried to free() intArrays 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)
Heap
train
train = (CAR*) malloc()
userStr
userStr = (char*) malloc()
intArray
113
Memory Basics Memory Errors
if we tried to free() intArrays 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)
Heap
train
train = (CAR*) malloc()
userStr
userStr = (char*) malloc()
intArray
114
Memory Basics Memory Errors
NOTE: if you try to free a NULL pointer, no
action occurs (and it doesnt segfault!)
program variables
much safer than accidentally
double free()ing memory
Stack
(also program
variables)
NULL
Heap
train
train = (CAR*) malloc()
userStr
userStr = (char*) malloc()
intArray
115
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 doesnt run out of
memory to hand out
(also program
variables)
NULL
Heap
train
train = (CAR*) malloc()
userStr
userStr = (char*) malloc()
intArray
116
Memory Basics Running Out
if you try to allocate memory, but theres not
enough contiguous space to handle your
request
program variables
Stack
(also program
variables)
NULL
Heap
train
train = (CAR*) malloc()
userStr
userStr = (char*) malloc()
intArray
117
Memory Basics Running Out
if you try to allocate memory, but theres not
enough contiguous space to handle your
request
intArray = (int*)
malloc ( sizeof(int)
* HUGE_NUM);
program variables
Stack
(also program
variables)
NULL
Heap
train
train = (CAR*) malloc()
userStr
userStr = (char*) malloc()
intArray
118
Memory Basics Running Out
if you try to allocate memory, but theres not
enough contiguous space to handle your
request
intArray = (int*)
malloc ( sizeof(int)
* HUGE_NUM);
program variables
Stack
intArray = (int*) malloc
(sizeof(int) * HUGE_NUM)
(also program
variables)
NULL
Heap
train
train = (CAR*) malloc()
userStr
userStr = (char*) malloc()
intArray
119
Memory Basics Running Out
if you try to allocate memory, but theres not
enough contiguous space to handle your
request
intArray = (int*)
malloc ( sizeof(int)
* HUGE_NUM);
program variables
Stack
intArray = (int*) malloc
(sizeof(int) * HUGE_NUM)
(also program
variables)
NULL
Heap
train
train = (CAR*) malloc()
userStr
userStr = (char*) malloc()
intArray
120
Memory Basics Running Out
if you try to allocate memory, but theres not
enough contiguous space to handle your
request
intArray = (int*)
malloc ( sizeof(int)
* HUGE_NUM);
program variables
Stack
intArray = (int*) malloc
(sizeof(int) * HUGE_NUM)
(also program
variables)
NULL
Heap
train
train = (CAR*) malloc()
userStr
userStr = (char*) malloc()
intArray
121
Memory Basics Running Out
if you try to allocate memory, but theres not
enough contiguous space to handle your
request
program variables
malloc will return NULL
Stack
(also program
variables)
NULL
Heap
train
train = (CAR*) malloc()
userStr
userStr = (char*) malloc()
intArray
122
Memory Basics Running Out
if you try to allocate memory, but theres not
enough contiguous space to handle your
request
program variables
malloc will return NULL
Stack
thats why you must check
that intArray != NULL
before you use it (also program
variables)
NULL
Heap
train
train = (CAR*) malloc()
userStr
userStr = (char*) malloc()
intArray
123
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 doesnt mean there isnt an error!
C is trying to be nice to you when it can
you have to be extra-super-duper-careful
with your memory management!!!
124
Outline
Makefiles
File I/O
Command Line Arguments
Random Numbers
Re-Covering 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 [ARR_SIZE];
/* set values of arr */
TimesTwo(arr, ARR_SIZE);
arrays of any type are passed by reference
changes made in-function 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 [NAME_SIZE] = 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
Re-Covering 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 youre done
elegant solution to printing the full train
140
