Today we will continue working with C, focusing on dynamic memory allocation, and loops. Lecture codes are in the Git repository

Future lecture code will continue to be added to the above Bitbucket repository, so you should be able to just git pull after you clone it the first time. te

1. Allocating memory and freeing it

• Anatomy of malloc
• Separate declaration and allocation
• When should we free memory

2. Multidimensional arrays

int matrix[2][4];   // A 2-D array of integers

3. Pointers

After executing the above code, the dynamically allocated memory can be loosely represented as follows:

Note: For operator precedence, consult this table. When in doubt, use parentheses or look it up!

When you use malloc, you simply "reserve" chunks of memory and keep track of their location. You still don't have any values stored in the memory, i.e., it is uninitialized.

To initialize all values to something reasonable, for example, 0 in the case of an integer array, you can change the above code as follows.

You can also do it without memset, but it can be less efficient:

Now all the values in the 2x4 matrix array are initialized to 0:

Next, we will focus on function arguments and continue working with pointers. We will also introduce some simple Bash commands and take a look at a Makefile.

4. Function arguments -- passing by value vs passing by reference.

Suppose we are required to provide a function that doesn't return a value (void) and which takes a single integer argument and adds 1 to it.

First version:

This compiles and runs, but the value of y does not change because it is passed by value, i.e., its value, 2, is copied into x, leaving y unmodified. In C, function parameters are always passed by value. Pass-by-reference is simulated in C by explicitly passing pointer values.

Another try:

This time y is incremented because instead of copying its value (2) to the increment function's argument x, we simulated passing it by reference, i.e., we passed the address of y, so that inside the increment function, the value of x is the address of y and it can be used to modify whatever memory location x points to (in this case, y) by dereferencing it with *x.

5. C typedefs

In this exercise, we define the struct Point datatype, which stores two integer coordinates, x and y. Then we implement a function to "move" the point by adding an integer distance to both the x and y fields of the struct.

Every time we want to use it to declare a variable or a function argument, we have to specify the type as struct Point. Why not just Point?

In C (and C++), users can specify new types by using typedef. These types are called user-defined types, as opposed to the basic types provided by the language.

We can declare a type for the Point structure in one of the following ways.

Or the following syntax would also work:

Now we no longer use "struct" when declaring variables of type Point,

Passing more complex data types as arguments.

As you recall, a C struct consists of a list of fields, each of which can have almost any type. The total memory required for a struct is the sum of the storage requirements of all the fields, plus any internal padding. When you pass a struct by value, you are copying its contents, which can be inefficient for very large structs. Hence, when you have read-only function arguments of type struct, you should consider passing them through a const * instead of passing the entire struct (so only the address is copied rather than the entire contents of the struct).

See the complete implementation, including a Makefile in the week2/norris subdirectory of the lecture exercises repository.

C also has enum types (similar to Python and Java) and union types. Here is an example of a union type used inside a struct, which contains a somewhat arbitrary collection of fields, just for illustration purposes (and also assumes that the struct Point type is defined).

7. C function pointers

So far we have only considered pointers to variables. In C you can point to functions, too, for example, fptr below is a pointer to a function. You can assign to it any function that has a matching prototype (return type and list of arguments):

double (*fptr) (double x[]);

You must initialize the pointer (i.e., assign a function to it) before you can call it. For example:

Why are function pointers useful? They can be used to enable callbacks -- i.e., have a certain function be called when some event occurs, or to pass functions as arguments of functions, enabling more flexible implementations.

Here is an example of an array of function pointers.

Many more examples of function pointers can be found here.

8. Separate compilation and makefiles (a very initial look, much more later)

• A nice introduction to C header files and separate compilation can be found here.

Memory bugs

When managing your own memory, it is not uncommon to make mistakes which result in runtime problems. That is, your code will compile without any errors or warnings, but it will not behave correctly at runtime. In the best case, it will crash with some runtime error. In the worst case, you will get an answer, but it may not be correct, or somebody can exploit your bug to get access to privileged data.

One of the most commonly available tools for checking for dynamic memory problems in your code is Valgrind. You should start learning about it here or by using this little tutorial, and then refer to the rest of the documentation as needed for more options and debugging strategies.

CIS 330 Wiki Pages

• Home Page
• Course Schedule
• Piazza
• Projects
• Unix cheat sheet
• Git cheat sheet
• GDB cheat sheet
• Additional Resources

edit SideBar