HOW-TO
Written by Elie De Brauwer
N/A
Dev
Graphics Internet Multimedia System
CD/DVD HardDrive USB Drive Laptop
T
his article is the first in a
series which will focus on
having fun with the C
programming language. In the
first articles, we will introduce the
C language and some basic
computer programming concepts
to the novice user. This way,
inexperienced users should be
able to follow the series, and get
to a level where they should be
able to write and understand
simple C applications. Once the
PROGRAM IN C - PART 1
basics of the language are explained,
we will introduce new concepts,
techniques, and more intermediate-
to-advanced principles -- by
example. I hereby promise I will do
my best not to make too-large leaps,
and to introduce new concepts as we
encounter them. If any reader
experiences problems, or fails to
properly understand certain things,
please do not hesitate to get in touch
with me.
Wireless
Today, there are numerous
programming languages out there,
and the question of why to use 'A'
and not 'B' has led to never-ending
discussions. A first argument is that
C is still a very popular language. A
second argument is the link between
UNIX and C -- C was initially
developed at AT&T Bell Labs
between 1969 and 1973 by Dennis
Ritchie, and the UNIX kernel was the
first major project to be implemented
in the language. Nowadays, the
number of (open) software projects
written in C is still huge -- the best
8
known is probably the Linux
kernel itself. The main objections
against learning C are that it is
not a modern language; for
example, it lacks a rich
framework, and it is not object-
oriented, which makes C a rather
simple language to learn. On the
other hand, a valid objection is
that, since C is a language
closely related to the hardware,
it can allow users to do things
that were not supposed to be
done. If you really want to shoot
yourself in the foot, C will not
prevent you from doing so.
Now, the scary part -- it's time
to get our hands dirty. If you visit
a programming-related forum or
newsgroup, you will encounter,
at regular intervals, somebody
who wants to start programming
and fails to compile/execute the
first example they found on a
website (or in a magazine).
Especially for those beginning
programmers, Debian/Ubuntu
has foreseen this, and provided a
special metapackage called 'build-
essential`. Running:
sudo apt-get install build-
essential
will equip your system with
everything required to compile a
simple C application (amongst
others the GNU GCC compiler and
make). In this series, we won't
teach you how to use an IDE
(
— a graphical suite
that performs embedded
debugging, editing, building, and
includes, preferably, some
content help for the user as well).
There are some excellent IDEs
available, such as
, and
in conjunction with the
CDT. You are, of course, free to
use any of those, but I suggest
you learn programming using
your favorite text editor such as
Emacs, Vi, Vim, Kate, and
numerous others. Simply pick an
editor that supports syntax
highlighting for C (most editors
should have this feature). And,
next to your favorite editor, make
use of a terminal
01. #include <stdio.h>
emulator to type in
02.
some commands.
03. /***********************************
Once you master
04. * Main function gets called when *
these steps, and
05. * the application is launched *
know what's going on
06. ***********************************/
under the hood, you
07. int main()
can still switch to an
08. {
IDE, or not. I write all
09. // Say something to the audience
my code using Emacs
10. printf("Hello world\n");
and some x-terminals.
11. return 0;
12. }
Enough talk. The
simplest application
(which actually does something), and echo $?
the de facto first example for every 0
programming language, is the so-
called 'hello world' application. This The first line will invoke the
is an application which starts up, GNU C compiler to compile the
displays the string 'Hello world', and file called and
terminates. This code can be seen in output (-o) it to an executable
Listing 1. To compile and execute this called . The options
application, put it in a text file with -Wall -W and -Werror instruct the
the extension .c, open a terminal, go compiler to check for warnings
to the directory where you saved the (a warning is a non-critical error,
file, and execute: meaning the compilation will still
succeed but it might not do what
gcc -Wall -W -Werror hello- the user expected in all
world.c -o hello-world situations), and abort when a
./hello-world warning is encountered. We
execute the binary by prefixing it
Hello world with './' -- this is because the
9
directory where you placed the
binary will typically not be in your
$PATH. And we used the funny
echo command to inform us of the
exit status of the last command
executed. It is not a coincidence
that this value is the same as the
value after the 'return' statement.
Now, let's take a close look at
the source file:
• instructs the
preprocessor. This is a piece of
logic executed prior to the actual
compilation, and it focuses on
manipulating the C language,
such as inserting other files or
replacing macros with C code. It
includes a header file called
stdio.h. This file should be located
in /usr/include/stdio.h, and
contains definitions for several
functions; in our case, we need it
to let the compiler know that
something called printf() exists.
• consist of a block
comment that will be ignored by
the compiler -- everything
between '/*' and '*/' will be
ignored. It is clear that this
comment can span multiple lines.
• defines the main entry point
of our application. When the
application is executed, it will start
executing the function
called main(); the int in
Let's take a close
front of it means that
the main function look at the source...
should return an
integer. The '()' means that main() is
a function, and it takes no arguments
(it can take arguments, but we will
discuss this later).
• opens a block -- which is
closed at line 12. These blocks group
instructions which belong together;
in this case they group the main()
function instructions.
• is a single-line comment.
When '//' is encountered on a line,
what remains of that line is ignored
by the compiler. It's impossible to
end these comments, and they can
not span multiple lines.
• , we finally find
something useful; here we call
another function called printf(), and,
between the parenthesis, we pass
the function an argument, which, in
our case, is a string literal. C strings
are placed between double-quotes.
Thus, we call the printf() function
10
with a string as an argument.
The only odd thing here is the
'\n'; this is a so-called escape
sequence, and it
means nothing
more than a
newline. Try
removing it, and
you will see that when you
execute the application, your
prompt will be printed on the
same line as the application.
Note that every instruction ends
with a semicolon. You will forget
to place these semicolons on
numerous occasions! This way,
you can put multiple instructions
on one line, or can have them
span multiple lines.
• exits from the main
function, and passes a certain
value (in this case 0 -- which is of
type int) back to whatever called
this function. In this case, the
shell called the main function.
And that's why gave us
our zero. This is an instruction,
and thus also terminated with a
semicolon.
One final note is that, if you
modify your source file, you
should run gcc again. C is unlike
Perl, Bash, Python, PHP, and
others -- it's not an interpreted
language; the gcc command calls
a compiler (which transforms a
higher level language into
assembler), an assembler
translates assembler into object
files (machine instructions), and a
linker, which combines several
object files into an executable.
These will transform the C code
into machine code that your CPU
is able to understand and execute.
• Compile the example
yourself, see that you can
reproduce the result.
• Make the application display
.
• Replace return 0; by return 1;,
and confirm that the exit status
has changed.
• Delete the return 1;
statement, and check what the
compiler says. Is it a warning or
an error?
• Run gcc without the
parameter; does it create a binary
now or not?
• Remove the
parameter at the command line.
What is the default name given to
the binary? Answer is shown below.
• Try removing all comments from
the source file, verify that this has no
effect.
• If you rename the
function to , what will the
compiler (actually the linker) tell
you?
the default name is
is a Belgian
Linux fanatic, currently
employed as an embedded
software engineer with one of the
world's leading satellite
communications companies. Apart
from spending time with his family, he https://launchpad.net/
enjoys playing with technology, and
spends his days waiting for Blizzard to
finally release Diablo III.
11
 HOW-TO
Written by Elie De Brauwer
FCM#17 - Program In C - Part 1
Dev Graphics Internet Multimedia System
CD/DVD HardDrive USB Drive Laptop
I
n the first article in this series,
we learned to configure our
system and compile and
execute an application that didn't
do anything useful at all, but we
had to start somewhere. This
article is of major importance for
novice programmers since here
we'll introduce some thinking in
code. This article will introduce
functions, loops, and decision
making, from a C perspective.
However, it should be clear that
PROGRAM IN C - PART 2
it's impossible to be complete in
these short articles - the main goal of
which is to create some base, and
give people a starting point to
continue their journey.
C is a so-called procedural
language, which means that, when
programming in C, you are working
in a procedure-oriented way (the
most popular alternative is object-
oriented programming where people
manipulate objects). This means that
Wireless
when you need to solve a problem,
you will start by breaking it up into
smaller and reusable pieces.
Suppose you were writing an office
suite. You would have a print
function to print your work on paper,
and this function could be reused by
all your suite components. In C most
prototypes will look like:
return_type
function_name(parameter_type1
param1, parameter_type2 param2)
Here you define a function called
8
function_name, which returns a
result of type return_type, and
takes two parameters. If you
don't have a return type, you
would replace return_type by
void. A more concrete example
would look like:
int add(int a, int b){
return a+b; }
This adds two integers ('int a'
says the the first variable is of
type integer and that it is given
the name 'a'), and returns their
sum as an int. You could call it
by putting 'add(1,1);' in your
code. Note that the function
needs to be defined before it is
used. And this is where the use
of header files pops in; a header
file will typically contain
'function prototypes'; this is the
function header as displayed
above, but terminated with a ';',
and not followed by the function
body. This is enough to let the C
compiler know that a function,
with a given signature, will be
defined in the future, and let's
 01. #include <stdio.h>
just hope that the linker will find section, 'statements1;' means 02. #define VERSION "1.0"
that function. In the example any sequence of application 03.
code, there are three functions logic. The first and most common 04. /*
defined. One is the main function, structure can be seen from line 05. * Runs a prime check on a given
but there is also the function 13 to 28 and line 49 to 56, and integer, return
isPrime() defined on line 8 - which has the following structure: 06. * 1 when the integer is a prime
takes one integer as a parameter, number, 0 otherwise
if(condition1)
and will return 0 when the integer 07. */
{
is a prime. Then we have also 08. int isPrime(int prime)
statements1;
printVersion() on line 34, which 09. {
}
only prints some information, and 10. int count=2;
else if(condition2)
doesn't return anything at all. 11.
{
printVersion() makes use of the 12. // Catch two special cases
statements2;
symbols __DATE__ and __TIME__, 13. if(prime==1)
}
which are replaced at compile 14. {
else
time by the compilation 15. return 0;
{
timestamp. Other symbols such 16. }
statements3;
as __LINE__ and __FILE__ also 17. else if(prime==2)
}
exist - which can help during 18. {
debugging. This function also If condition1 is true, 19. return 1;
uses the VERSION symbol which statements1 will be executed, 20. }
is defined on line 2. When the otherwise condition2 will be 21. else
preprocessor is run (before the checked; if this is true, 22. {
compiler), it does some plain statements2 will be executed, 23. while(prime%count!=0 &&
string replaces; in this case and, if all else fails, statements3 count*count<=prime)
VERSION will be replaced by '1.0'. will be executed. Both the 'else 24. {
if' and 'else' parts are optional, 25. count++;
and you can also add more 'else 26. }
The example code (Listing 1) if' parts. A condition is 27. return
has been written so that the most considered true when it differs (prime%count==0)?0:1;
common loop/decisions from zero - which explains line 28. }
constructs are used. In this 49. 29. }
30.

9
 31. /*
A special form of the if...else to 57; this is a for loop and 32. * Print version information
structure is on line 27. This form has the following syntax: 33. */
isn't that common, and is typically 34. void printVersion()
for(init_variable;conditio
used for very compact things. 35. {
n;update_variable)
Here, it is a compact way of 36. printf("Primality checker
{
saying that the function should version %s\n", VERSION);
statements;
return 0 if count is a divisor or 37. printf("Compiled on %s
}
prime, or 1 otherwise. %s\n", __DATE__, __TIME__);
Here, there are three parts: 38. }
A first loop is a while loop, for
first a loop variable is 39.
example lines 23 to 26. Here, the
initialized to a value (typically 40. int main()
body of the loop will be executed
0 but in our example to 1), 41. {
provided and as long as the
next there is a condition which 42. int i=1;
condition is true, which means it
is checked on every iteration 43. const int max_prime=2500;
is potentially not executed. In this
and the for loop will continue 44.
example, we say a number is a
as long as this condition is 45. printVersion();
prime by trying all numbers
true, and finally the variable is 46.
smaller than the square root of
updated -- this is typically a 47. for(i=1;i<max_prime;i++)
the number (but we use
'i++' (i++ is shorthand for 48. {
count*count <= prime instead of
i=i+1). It is good style to use 49. if(isPrime(i))
count <= sqrt(prime) because
while loops when you don't 50. {
multiplying is more CPU friendly
know the number of iterations 51. printf("%d is
than calculating a square root.
up front, and a for loop when prime\n",i);
The % operator is used to take the
you do know, and thus do not 52. }
modulo. Meaning that 7%2=1
need to modify the loop 53. else
because the remainder of the
variable in the loop body. 54. {
division of 7 by 2 is 1 (7-2*3=1). 55. printf("%d is not
Within the main loop, you make The language has two other prime\n",i);
some changes which impact the constructs which are not 56. }
loop condition. Failing to do this present in the example. First 57. }
will result in an eternal loop. there is the: 58. return 0;
A second loop is seen on line 47 59. }

10
do variable on which the decision will be • Rewrite the if...else in the
{ based, and this is followed by a list of main() function to make use of
statements; case keywords succeeded by all the ternary operator
}while(condition); cases which need handling (here,
• Replace the isPrime() function
one will typically use enum with a
Here, the statements will be by an isOdd() function which
limited range). Statements can be
executed as long as condition is returns 1 when a given integer is
terminated with break, otherwise
true, which is almost the same as odd.
execution would fall through (which
the while loop. The difference is
also has its uses) and continue the • Design and write a small
that the body will be executed at
statements of the next case (if application which prints out the
least once. While loops are,
variable equals 4, statements2 will n Fibonacci sequence, where n
however, more common than
be executed). And finally there is a should be easily modifiable.
do...while.
default which stands for 'all other
A more popular format which cases'.
has been omitted here is the
One final note: it is possible to
switch...case construct:
jump out of if..else, while, for,
switch(variable) do..while and switch...case blocks by
{ using the 'break;' statement. And it is
case 1: possible to proceed with the next
statements1; iteration (of a loop) by using the
break; 'continue;' statement.
case 4:
is a
case 2:
Belgian Linux fanatic,
statements2; • Rewrite the for loop in the main() currently employed as an
break; function so it becomes a while loop embedded software engineer
default: with one of the world's leading
statements3; • Rewrite the if...else if..else satellite communications
} structure in the isPrime() function to companies. Apart from spending
a switch...case structure time with his family, he enjoys
This is a very compact form of playing with technology, and
writing if..else if...else if...else • Rewrite the ternary spends his days waiting for
(condition)?value1:value2 to an Blizzard to finally release Diablo
statements. A switch is passed a III.
if..else structure

11
 HOW-TO
Written by Elie De Brauwer
FCM#17 - Program In C - Part 1
FCM#18 - Program in C - Part 2
Dev
Graphics Internet Multimedia System
CD/DVD HardDrive USB Drive Laptop
S
o far so good. This is already
the third part in this series,
and we have already made
a lot of progress. The past articles
explained how to think in code -
by introducing functions. This
article will probably be one of the
most difficult in this series; here
we'll touch something which is
almost C-specific: the notion of
pointers. C is a programming
language which lives close to the
PROGRAM IN C - PART 3
assembly language, and in assembly
languages you spend most of your
time moving data around, but in
order to do that you need to know
where the data is located, hence its
address in memory. And this is just
what a pointer is. A pointer is an
address in your computer's memory,
nothing more, nothing less. But when
you're working with C, you'll end up
with the conclusion that pointers are
everywhere. So, after conquering
functions and pointers, we should be
able to handle almost anything.
Wireless
In this article, I will not present a
'fully functional program'. I will
present small snippets between the
text, but you are encouraged to fire
up your editor and start
experimenting. You will also see that
I introduce some 'extras' which are
not mentioned in the main title. I
will, for example, also introduce
structures, arrays, strings, ... ,
because I want to see this series
evolve into a practical tutorial, and
not into a C textbook.
8
When handling pointers, you
will encounter two 'extra'
operators. These are * and &. It
helps, when you look at code,
that you read * as 'the value
stored at this address', and & as
'the address of this variable'.
int anInt=5;
int * anIntPointer=&anInt;
printf("Address: %p Value:
%d \n",&anInt, anInt);
printf("Address of pointer:
%p Address: %p Value: %d
\n",&anIntPointer,
anIntPointer,
*anIntPointer);
printf("Size of pointer: %d
size of int: %d\n",
sizeof(anIntPointer),
sizeof(anInt));
Thus, we declare an integer
and assign this integer the value
5, we declare a pointer (mind
the extra *), and we let it point
to the address of the previously
declared integer. Next, we print
the address of the integer, and
the value of the integer. Then we
print the address of the pointer,
the value of the pointer (which is
an address, the address of anInt),
and the value the pointer points
to. And to end, we print the size
of the pointers and the size of the
integer. This produces the
following output:
Address: 0xbfc819d8 Value: 5
Address of pointer:
0xbfc819d4 Address:
0xbfc819d8 Value: 5
Size of pointer: 4 size of
int: 4
Here we can see that both
pointers and integers are 4 bytes
large (which makes sense, since
I'm on a 32-bit computer; if you
run this on a 64-bit or a 16-bit
computer, these values may
vary). The address will be
different on your system, but the
fact that the address of the
pointer and the address of the
integer are only 4 bytes apart is
not a coincidence; they are simply
physically stored next to each
other. In printf, we use p to print a
pointer (in hexadecimal), s to print a
string (for more information see man
3 printf). The sizeof() operator used
in the printf statement returns the
size of an element (in bytes).
What is an array? An array is
simply a list of variables of the same
type. In this example, we declare an
array of integers where we can store
5 integers. At this point, we also
declare how many integers we want
to put in there (in this case five).
Here we initialize the array at
declaration, but we could do it
elsewhere in the program as well.
int
anIntArray[5]={10,20,30,40,50};
printf("Address of array:
%p\n", &anIntArray);
printf("Size of array:
%d\n",sizeof(anIntArray));
for(i=0;i<sizeof(anIntArray)/si
zeof(int);i++)
{ address an element of the array
printf("Index:%x
Address:%p Value:%d Value:
%d\n", i, &anIntArray[i],
9
anIntArray[i],
*(anIntArray+i));
}
This code produces the
following output:
Address of array: 0xbf8b55d4
Size of array: 20
Index:0 Address:0xbf8b55d4
Value:10 Value: 10
Index:1 Address:0xbf8b55d8
Value:20 Value: 20
Index:2 Address:0xbf8b55dc
Value:30 Value: 30
Index:3 Address:0xbf8b55e0
Value:40 Value: 40
Index:4 Address:0xbf8b55e4
Value:50 Value: 50
Now, what does this show us?
The size of the array equals the
number of elements times the
size of each element (there is
nothing extra stored). All
elements are placed next to
each other in memory (look at
the memory addresses: they
each differ by 4. By adding [i]
after the array name, we can
at index i. But, and here's some
magic called 'pointer arithmetic',
if we add 1 to an int pointer, the
pointer is increased by 4 (the size
of the integer) - not by one. So,
we can address the array by using
the subscript method ([i]), but
also with some pointer arithmetic,
and, in essence, the array we
declared is just a pointer to
memory - where several values of
the same type are stored.
We have touched on integers
and arrays of integers, and we'll
extend this principle. A single
character ('c') can be stored in a
'char' type, and, if we take
multiples of these chars, and put
them after each other, a string is
thus nothing more than an array
of chars.
char aChar='c';
char * aString="Hello";
printf("Address: %p Value:
%c Size: %d\n",&aChar,
aChar, sizeof(aChar));
printf("Address of string:
%p\n", &aString);
printf("Size of string:
%d\n",strlen(aString));
printf("Value: %s\n", aString);
for(i=0;i<=strlen(aString);i++)
{
printf("Index:%x
Address:%p Value:%c\n", i,
&aString[i], aString[i]);
}
Here, we create a char, and a char
array (which is, in essence, a
pointer; this is equal to writing 'char
aString[6]=”Hello”;', and do mind
the difference between the char 'c'
and the string “c”). This generates
the following output:
Address: 0xbf8b560f Value: c
Size: 1
Address of string: 0xbf8b5600
Size of string: 5
Value: Hello
Index:0 Address:0x8048780
Value:H
Index:1 Address:0x8048781
Value:e
Index:2 Address:0x8048782
Value:l
Index:3 Address:0x8048783
Value:l
Index:4 Address:0x8048784
Value:o
Index:5 Address:0x8048785
Value:
There is actually nothing new
here. We handle it the same way
as adding integers, except we
now use 'strlen()', a function
defined in string.h (see man 3
strlen for details) to get the
length of the string; a char is
only one byte large, and we use
%s to print it. There is only one
magical thing here and that is
how will we know that the string
is finished? Well, the array is not
{'H','e','l','l','o'}, it is
{'H','e','l','l',o',0}. The ASCII null
character is added after the
string, so how does strlen()
work? It is just a while loop
which continues increasing the
index until the value becomes 0.
This defines a
structure...
Everything's going well. Let's
add another thing on the pile -
structures. We know arrays?
Arrays are a collection of items
of the same type; structures are
a collection of things with
different types.

10
struct aStruct
{ &aStruct.stringPointer);
int intMember;
int * intPointer;
char charMember;
char ** stringPointer;
};
This defines a structure called
'aStruct', which combines an
integer, a pointer to an integer, a
char, and a 'double' pointer (a
pointer to a string or a pointer to
a pointer to a char). Put this
declaration outside your
functions. Typically, these are
placed in header files. Next we
can use this struct; we use the
previously defined variables to
populate this struct:
struct aStruct aStruct;
struct aStruct *
aStructPointer;
printf("Address: %p Size:
%d\n",&aStruct,
sizeof(struct aStruct));
printf("%p %p %p
%p\n",&aStruct.intMember,
&aStruct.intPointer,
&aStruct.charMember,
aStruct.intMember=6;
aStruct.intPointer=&anInt;
aStruct.charMember='k';
aStruct.stringPointer=&aString;
aStructPointer=&aStruct;
printf("Member of struct:
%d\n",
(*aStructPointer).intMember);
printf("Member of struct:
%d\n",
*(*aStructPointer).intPointer);
printf("Member of struct:
%d\n", aStructPointer-
>intMember);
printf("Member of struct:
%d\n", *aStructPointer-
>intPointer);
printf("Member of struct:
%s\n", *aStructPointer-
>stringPointer);
And the output:
Address: 0xbf8b55e8 Size: 16
0xbf8b55e8 0xbf8b55ec
0xbf8b55f0 0xbf8b55f4
11
Member of struct: 6
Member of struct: 5
Member of struct: 6
Member of struct: 5
Member of struct: Hello
And what does this teach us?
Well, we can declare structures,
we can have pointers to
structures (it goes further, we
can have arrays of structures,
and structures can contain
arrays, structures can also
contain structures and structures
can even contain pointers to
structures of the same type --
this is called a linked list). By
using the '.' operator we can
access the members of a struct,
and when we have a pointer to a
struct, we do not need to
dereference it first as in
(*aStructPointer).intMember,
since this is so common we can
use the '->' operator as in
aStructPointer->intMember. Also,
using the double pointer is
peanuts. There is, however, one
odd thing in the output: here it
says the size of this struct is 16,
while we added one int (4 byte),
one int pointer (4 byte), one char
(1 byte) and one char pointer (4
byte). Who stole those three
bytes of memory? Well that is
called alignment. During the
compilation process all memory
addresses were aligned to 4-byte
multiples since it is
much more efficient
for the processor to You
fetch an address little practice...
which starts at an
address which is a multiple of
four. But if you would really want
to change this, you can.
For all the brave who managed
to bear with me this far, my
congratulations. I know that the
first time people talk about
pointers it results in a lot of
frowning and thinking 'why would
somebody want to use this', but,
don't panic - you just need a little
practice to get full speed with
pointers, and you'll soon see the
advantage they bring. But one
word of caution is in place:
pointers point to 'a' memory
location. They can point to any
memory location. If you forget to
initialize them, or forget to
dereference them, you can end
up in strange situations. I lost a day
this week, because I incremented a
pointer (which was zeroed
afterwards) instead of incrementing
the value the pointer pointed to. C
will not prevent you
from doing these
just need a things, but these will
result in your
application being
terminated. It's the same with
arrays: if you write int array[5]; int b;
array[6]=0;, you will set the value of
b to zero. This leads to memory
corruption, and, in extremis, to stack
corruption. So, pointers are very
powerful, but you need to use them
right.
• Collect all the code snippets on this
page and turn them into a working
program.
• Try to run this program on a 32bit
and a 64bit system (use a livecd for
example), and compare the
differences.
• Implement strlen yourself using a
12
while loop.
• Take a look at some manpages -
those of memcpy strcpy strcat
memzero, and see that all these
functions operate on pointers.
• A C application typically has
'int main(int argc, char **argv)'
as it's main prototype, here argc
contains the number of strings
passed to the application, and
argc is an array of argc strings.
Write a small application which
prints all arguments given to the
application. What is stored in
argv[0] ?
is a
Belgian Linux fanatic,
currently employed as an
embedded software engineer
with one of the world's leading
satellite communications
companies. Apart from spending
time with his family, he enjoys
playing with technology, and
spends his days waiting for
Blizzard to finally release Diablo
III.
 HOW-TO
Written by Elie De Brauwer
PROGRAM IN C - PART 4
But, since it's also the holiday
season, the demo application will be
FCM#17-19 - Program In C - Parts 1-3
an application which creates ASCII
snow. In order to create this effect I
will use a small subset of a library
called 'ncurses'. For more
information regarding this library,
you are strongly advised to read
http://tldp.org/HOWTO/NCURSES-
Dev Graphics Internet Multimedia System
Programming-HOWTO, since I will
touch only the functions used in the
demo.
CD/DVD HardDrive USB Drive Laptop Wireless
In order to use ncurses, you will
Then, we will need to include
the ncurses header in our source
file - by adding #include
<ncurses.h> at the top of our
source file. But, what is really
new is that ncurses is provided
as a dynamic library, which
means two things: first, we will
instruct the linker to link our
source against the ncurses
library which can be done calling
gcc this way:
gcc -Wall -lncurses snow.c -o
snow
The -l flags instructs the linker

I
n this fourth article in the
series, I'll introduce an
important topic that every C
programmer should master,
because it can cause a whole lot
of problems: dynamic memory
allocation. Failing to use and
understand dynamic memory
allocation (and pointers) correctly
will result in memory leaks and
application failures (think of the
well known Segmentation Fault as
an example).
first need to install the ncurses to link with the ncurses shared
package and the ncurses developers library. And as a result of this we
package: see the output below:
apt-get install libncurses5
libncurses5-dev
edb@lapedb:~/fullcircle/c-4$ ldd snow
linux-gate.so.1 => (0xb805c000)
libncurses.so.5 => /lib/libncurses.so.5 (0xb7ff7000)
libc.so.6 => /lib/tls/i686/cmov/libc.so.6 (0xb7e99000)
libdl.so.2 => /lib/tls/i686/cmov/libdl.so.2 (0xb7e94000)
/lib/ld-linux.so.2 (0xb8042000)

8
 When we use ldd (ldd prints the • getmaxyx() to get the
shared libraries required to terminal dimensions
execute a binary), we see that the 1.int main()
• clear() to clear the 2.{
applications require
screen 3. char * field=NULL;
libncurses.so.5 to be available on 4. int row=0;
our system. This also means that • mvaddch() to display 5. int col=0;
running our binary on a system a character at a given 6. initscr(); //nc
with this library not installed will location 7. atexit(exitfun);
not work. 8.
• refresh() to force 9. /* Eternal snow ! */
Now what does ncurses do? output on the terminal 10. while(1)
Well, a text terminal is in fact an 11. {
odd thing - with printf(), we can • endwin() to properly 12. updateFlakes(&field,&row,&col);
write text, but the text always reset the terminal at 13. if(field==NULL)
appears at the end of the line - application exit 14. {
we can't scroll back; we can't • initscr() to initialize
15. break;
16. }
print colors; we can't print bold the ncurses library 17. drawScreen(field,row,col);
characters; etc. There are things 18. sleep(1);
called 'escape sequences' which 19. }
manipulate the cursor behavior
The main() (see Listing 20. return 0;
and the way text is printed on 21.}
1) doesn't do much. It
such a terminal (this all dates Listing 1: main()
initializes the screen (line
from the roots of the history of
6), and every second it
computing), but these escape
updates and array of snowflakes (line
sequences are non-human
12). If that succeeds, it draws them
friendly. Well, ncurses is a form of 1. /* At termination, properly
to the screen (line 17). There is only
wrapper library which eases the close the terminal */
one special thing here and that is the
use of these escape sequences. In 2. void exitfun()
atexit() function. This function is 3. {
my example code, I've added //nc
used to instruct the application that, 4. endwin(); //nc
after a function call when this
prior to termination, this function 5.}
function call belongs to ncurses.
should be called. The contents of this Listing 2: exitfun()
The functions I've used are:
function are shown in Listing 2. All it
does is call endwin(). Note, that the

9
trick used here is called a
'function pointer'. Just as we can
have pointers to data, we can
have pointers to functions too
(and this is simply the function
name, without the parentheses).
In the main(), we have storage
for the number of rows, the
number of columns, and the array
of flakes; we pass these three
parameters to the updateFlakes()
function (see Listing 3). This
function will allocate memory if a
change of the terminal dimension
is detected. Every time this
function is called it reads the
dimension of the terminal. If these
don't match those stored in the
main function, we allocate a new
array and start from scratch. From
lines 6 to 19, we read the
dimensions, and reallocate the
memory (and free old memory if it
existed). And this is where
dynamic allocation kicks in.
Sometimes you don't know at
compile time how much memory
you will need. Here, we need one
byte for each position on the
screen, but the window isn't fixed
at compile time, so we need 1./* Update the structure */
to learn this and ask for the 2.void updateFlakes(char ** fieldIn,
amount of memory we need. int *rowIn, int *colIn)
3.{
The same happens at the
4. int numnew=0; int row=0; int
point of a resize of the col=0; int i=0;
window; then we need to 5. char *field=*fieldIn;
update the amount of 6. getmaxyx(stdscr,row,col); //nc
required memory. This is 7.
done using a combination of 8. /* Create new field */
the functions malloc() (line 9. if(field==NULL || *rowIn!=row
15) and free() (line 13). With || *colIn!=col)
10. {
malloc() (which stands for
11. if(field!=NULL)
memory allocate), you pass it 12. {
the number of bytes you wish 13. free(field);
to allocate, and it will return a 14. }
pointer to this amount of 15. *fieldIn=malloc(row*col);
bytes (or NULL when the 16. field=*fieldIn;
system is out of memory). 17. memset(field,0,row*col);
With a call to free(), you tell 18. *rowIn=row; *colIn=col;
the system you no longer 19. }
20.
need the memory. Not
21. /* Apply gravity ! */
combining a malloc() with a 22.
free() properly will result in a memmove(&field[col],&field[0],(row-
memory leak and an eventual 1)*col);
crash of your application. 23. memset(field,0,col);
Well, that's all there is to it - 24. numnew=random()%(col/2);
easy isn't it? Now, see how 25. for(i=0;i<numnew;i++)
many times you will shoot 26. {
27. field[random()%col]=1;
yourself in the foot using
28. }
dynamic memory allocation. 29.}
The real difficult part in this
Listing 3: updateFlakes
function is the memory
10
juggling. First, we use a one
dimensional array (char * field) to
represent two dimensional data
(the 2D screen contents). This
means simply that field[0] is at
row 0, col 0, field[1] is at row 0,
col 1, field[row] is at row 1, col 0
and field[row+1] is at row 1, col 1.
This is because it's easier to work
with one large array than with an
array of arrays. In Figure 1, this is
illustrated for a screen consisting
out of five rows and three
columns. We make use of
memset() (line 17 ) to initialize
the allocated array to zero (which
is always a good idea, since
allocated memory usually
contains junk).
The real magic however occurs
on line 22, here we use
memmove() to move the first row-
Figure 2 - memmove() in action
1 rows and shift these by
col bytes. See also Figure 1;
the move is illustrated with 1./* Let it snow */
the dotted arrow. When that 2.void drawScreen(char * field, int row,
is done, we zero the new int col)
'first' row, and place some 3.{
random cells to 1 (implying 4. clear(); //nc
5. int x=0;
it will snow there).
6. int y=0;
7. for(y=0;y<row;y++)
8. {
And finally, all we need is 9. for(x=0;x<col;x++)
to iterate over the array, 10. {
and put some snow on the 11. if(field[y*col+x]==1)
screen. How this is done is 12. {
shown in Listing 4. Which is
13. mvaddch(y,x,'*'); //nc
14. }
nothing more than two for 15. }
loops, one to iterate the 16. }
columns and one to iterate 17. refresh(); //nc
the rows - combined with 18.}
the decision whether or not Listing 4: drawScreen()
to print a snowflake.
Although only four articles have
been presented, already a lot of
'heavy stuff' has been covered. It can
be clearly seen that, with this article, this path and to focus more and
we're already drifting a bit away from more on Linux specific goodies in
the generic-c-programming, and application development, and
we're making a move towards more from this I wish all you
Linux/Ubuntu specific applications. enthusiasts out there an exciting
The goal in this series is to continue New Year filled with discoveries!
11
 free the memory in the exit function.
• Get the application up and • Write a while(1) {malloc(1);} A PENNY FOR YOUR
running on your application, and THOUGHTS
own system (you'll confirm that in the
Get the application
need to figure out end your system will
the required up and running on run out of memory.
We want to know what you
headers yourself, your own system... like, or dislike, to help us
• Check the random improve Full Circle to make
hint consult the
and srand manpages to learn how to 2009 even better than 2008.
manpages of the calls which give
seed the random number generator.
implicit declaration errors). We'd really appreciate it if
you could take a few
• Instead of passing exitfun() to
minutes to fill in this short
atexit(), we could as well have
survey:
passed endwin() directly; verify
that this works. Read the atexit http://url.fullcirclemagazine.
manpage to figure out which org/e78bdf
function prototypes it accepts.
Why is it useless to pass a We'll keep the survey up
function which returns a value? until 24th Jan. and publish
the results in the January
• Remove the functionality to issue of FCM.
reallocate the field after a window
size, try resizing the window now, From everyone at Full
is a Circle, we want to wish you
what are the pro and contras? Belgian Linux fanatic,
all the best for 2009, and
currently employed as an
• Note that the currently used thank you for melting our
embedded software engineer
field array isn't free()'ed at with one of the world's leading admins server each month
application exit, this is not a satellite communications with over 20,000 downloads.
problem since this won't cause a companies. Apart from spending
memory leak and the kernel will time with his family, he enjoys
free the memory; nevertheless, playing with technology, and
spends his days waiting for
try making field a global variable Blizzard to finally release Diablo
(place it outside the main() ) and III.

12
 HOW-TO
Written by Elie De Brauwer
FCM#17-20 - Program In C - Parts 1-4
PROGRAM IN C - PART 5
we will focus more on how we can
make use of C to get things done, 01.int divide(int a, int b)
how issues with C applications can 02.{
03. return a/b;
be diagnosed, and how 04.}
troubleshooting can be done. 05.
06.typedef int
(*mathFun)(int, int);
We already explained that if int a is 07.
an integer then int * b=&a declares a 08.struct operator

Dev Graphics Internet Multimedia System

pointer b and initializes it to point to 09.{
10. char c;
a. Now, take a look at Listing 1; here 11. mathFun f;
we have a function called divide 12.};
(lines 1-4), and, on line 6, we have a
typedef where we define a new Listing 1
CD/DVD HardDrive USB Drive Laptop Wireless
datatype called “mathFun” - which is

A
fter four articles, most of
the basic and generic C-
related topics have already
been covered. I hope that after
these articles you can confirm two
things: the first being that C isn't
a terrible large and complex
language, and the second being
that it is also a very powerful
language which allows you to do
lots of low-level things. This will
be the last article to cover the
“basics”; in the coming articles,
a function pointer to a function
returning an integer, and taking two
integers as an argument. Lines 8-12
define a structure which links a
character with a function. This
principle is called a 'callback' (or
handler), and is used a lot (in fact
this is how object oriented
programming can be simulated in C;
you define a structure with some
data and some function pointers and
this is almost a class). But, it's very
common to use this, for example, in
GUI programming - you register a
function which needs to be
called when the user performs
an action. If you have the
manpages-dev package
installed, and type “man qsort”,
you will get the definition of a
function which implements the
quicksort algorithm (see also
Listing 2), and you can see that
this function is used for sorting
some data, and you should pass
it a function pointer to a function

8
 man scanf for details).
NAME These functions are
qsort - sorts an array
the opposite of printf()
SYNOPSIS
#include <stdlib.h> (and sprintf(), fprintf()
...). Where printf()
void qsort(void *base, size_t nmemb, size_t size, takes a format
int(*compar)(const void *, const void *)); definition to format
DESCRIPTION some variables
The qsort() function sorts an array with nmemb elements of size size. accordingly, and put
The base argument points to the start of the array. this to a destination,
scanf() will read a
Listing 2: man 3 qsort extract
string, dissect the
string according to the
format, and store the result in
capable of doing the comparison we allocate storage for four some variables. Take line 13 for
(this can be useful when you are structures which are filled in with the example; here, it will read a
sorting an array of points, and you operator and the function pointers on “%d” (an integer), and store the
wish to sort them on distance to lines 4-7. Next, there is the user result in the location passed as
the origin). input handling on lines 12 to 18. an argument (note that here we
When the user has entered some pass pointers, with printf()
input, lines 20-32 show a search variables are passed). But
Now, to illustrate how we can through the command array to find there's nothing more to it than
use callbacks, which are typically the entry matching the operator and, that. The format strings are
used to handle events, we will if found, we issue the callback with completely alike. The only
develop a small application which the read data, and print the result. confusing thing might be line 17;
prompts the user for two digits And that's all there is to it. we need a second scanf()
and an operator and, if the because the first one will read
operator is known, it calls the the newline of the previous read.
function with the two digits as Although printf() was already used As with printf(), it is possible to
parameters and prints the result. in the past, this is the first time we have more complex format
Listing 3 shows a basic encounter a scanf()-alike function strings where multiple variables
implementation of this; on line 3 (alike because there are some are read at once; in this case you
variants like sscanf(), fscanf(), ... see will be interested in the return

9
 01.int main()
02.{
value of scanf() which is the based on their distance to 03. struct operator functs[4];
number of elements properly the origin, and use the 04. functs[0].c='-'; functs[0].f=&minus;
qsort() function for this.
decoded. I strongly suggest to 05. functs[1].c='+'; functs[1].f=&add;
play a little with scanf(), printf(), • Extend the calculator with 06. functs[2].c='*'; functs[2].f=&multiply;
and various formats, since these the possibility for the user to 07. functs[3].c='/'; functs[3].f=&divide;
enter 'q' to quit.
format strings can be found
08. while(1)
09. {
almost everywhere, and it's very • Modify the application that,
10. int a,b,i;
useful to understand how they instead of entering
characters, the user is able 11. char c;
behave. One important thing to to enter “5 plus 6” or “6 12. printf("Enter a:\n");
keep in mind, when handling minus 5”. In order to do this, 13. scanf("%d",&a);
strings, is to keep track of the you will need to adapt the 14. printf("Enter b:\n");
amount of data you read. structure to hold a string as 15. scanf("%d",&b);
Something as simple as “char the operator, and, instead of 16. printf("Enter the operator:\n");
reading a character, you will
s[10]; scanf(“%s\n”,s);” is the de 17. scanf("%c",&c); // Get the newline
need to read a string. Extra 18. scanf("%c",&c);
facto example of a buffer credit if you manage to do 19. i=0;
overflow, waiting to be exploited; this without buffer overrun 20. while(i<4)
for things like these one should issues (see man getline) and 21. {
limit the amount of bytes read in memory leaks. 22. if(functs[i].c==c)
the format, or use more advanced 23. {
solutions like getline() (man 24. printf("Result:
getline) which dynamically %d\n",functs[i].f(a,b));
allocates more memory if it is 25. break;
26. }
needed.
27. i++;
is a
28. }
Belgian Linux
29. if(i==4)
fanatic, and apart from
spending time with his 30. {
family, he enjoys 31. printf("Unknown operator:
• Write the missing callbacks, and get
the application working. playing with %c\n",c);
technology, and 32. }
• Modify the application to operate on spends his days 33. }
floating point numbers instead of waiting for Blizzard to 34. return 0;
integers. finally release Diablo 35. }
• Write an application which sorts points III.
Listing 3: calc.c main loop

10
 HOW-TO
Written by Elie De Brauwer
FCM#17-21 - Program In C - Parts 1-5
Dev Graphics Internet Multimedia System
CD/DVD HardDrive USB Drive Laptop
U
ntil now, I have been
presenting to you some
code, and instructions on
how to compile and execute that
code. So, until now, you've
probably only needed an editor
(emacs, vi, ...) and a compiler
suite (gcc). However, there are
some other tools which make
developing code easy (bear in
mind that developing doesn't
mean only typing source code; it
covers the entire process - typing
PROGRAM IN C - PART 6
code, compiling code, testing code,
etc.), and there are many tools out
there. There are even some IDEs
(integrated development
environments) which combine some
of these tools in a nice graphical
front-end (e.g. the CDT in the Eclipse
project, kdevelop, Code::blocks,
anjuta, and more), but it is my
humble opinion that a beginning
programmer should first get an idea
about how things work under the
hood, before he starts using
shortcuts. Although there are many
Wireless tools out there which cover many
categories, in this article we will
focus on troubleshooting
code/applications.
strace is one of my best friends.
ltrace is also a nice tool, but I don't
make use of it that often. You can
install both by typing
sudo apt-get install strace ltrace
Now, what do they do? strace
intercepts the system calls made by
8
processes. A system call is a
function call which transfers
control to the kernel for some
functions that can be done in
user space. For example,
incrementing a variable is
translated to a simple assembler
command, but when you do
something which deals with
resources, this always goes past
your kernel. If you read 'man 2
syscalls', you can get a list of all
system calls the kernel supports.
Now, why is this a good thing to
monitor? Well, if you monitor
which system calls your
application makes, you can
follow the logical flow of your
application, and the good thing
is that it is non-intrusive, which
means you can run it on every
binary on your system. As an
example, I will highlight the
output of wget, installable by
typing:
sudo apt-get install wget
wget is an application which
fetches an URL from the Internet
and writes it to disk.
If we take a look at the output of
strace wget -q
http://www.google.com
shown in Fig. 1 (right) we can
clearly see some interesting parts
in the execution.
We can see that it starts with a
call to 'execve()' (you can use
man execve; this goes for each
systemcall - the first word on a
line echoed by strace), which
loads the binary. A bit later, the
application checks if an init file
called '/etc/wgetrc/' exists; it does,
and it is read. Next, we see that it
tries to open a '.wgetrc' in my
home directory, but this file does
not exist, so this file is not opened.
The next example (Fig. 2, below
right) shows that '/etc/resolv.conf'
is being opened, and that a socket
is opened to a DNS server, in
order to resolve the address I
asked for.
execve("/usr/bin/wget", ["wget", "-q", "http://www.google.com"], [/*
38 vars */]) = 0
...
stat64("/etc/wgetrc", {st_mode=S_IFREG|0644, st_size=4221, ...}) = 0
open("/etc/wgetrc", O_RDONLY|O_LARGEFILE) = 3
fstat64(3, {st_mode=S_IFREG|0644, st_size=4221, ...}) = 0
mmap2(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1,
0) = 0xb7ad2000
read(3, "###\n### Sample Wget initializati"..., 4096) = 4096
read(3, "on:\n#backup_converted = off\n\n# T"..., 4096) = 125
read(3, "", 4096) = 0
close(3) = 0
...
stat64("/home/edb/.wgetrc", 0xbfe57a48) = -1 ENOENT (No such file or
directory)
...
Fig. 1
stat64("/etc/resolv.conf", {st_mode=S_IFREG|0644, st_size=88, ...}) = 0
socket(PF_INET, SOCK_DGRAM, IPPROTO_IP) = 4
connect(4, {sa_family=AF_INET, sin_port=htons(53),
sin_addr=inet_addr("195.130.131.5")}, 28) = 0
fcntl64(4, F_GETFL) = 0x2 (flags O_RDWR)
fcntl64(4, F_SETFL, O_RDWR|O_NONBLOCK) = 0
gettimeofday({1234091526, 549043}, NULL) = 0
poll([{fd=4, events=POLLOUT, revents=POLLOUT}], 1, 0) = 1
send(4, "\372\312\1\0\0\1\0\0\0\0\0\0\3www\6google\2be\0\0\1\0\1"...,
31, MSG_NOSIGNAL) = 31
poll([{fd=4, events=POLLIN, revents=POLLIN}], 1, 5000) = 1
ioctl(4, FIONREAD, [367]) = 0
recvfrom(4,
"\372\312\201\200\0\1\0\6\0\7\0\7\3www\6google\2be\0\0\1"..., 1024, 0,
{sa_family=AF_INET, sin_port=htons(53),
sin_addr=inet_addr("195.130.131.5")}, [16]) = 367
close(4)
Fig. 2
9

Now, isn't this nice? We
examined the internals of an
application, without taking a
look at a single line of code; we
immediately learned where it
stored some config files, which
ones didn't exist, and how it
translated the DNS entry to an
ip address. ltrace works in a
similar fashion, but instead of
tracing system calls, ltrace
gives you an idea of which
functions are called and which are
located in a dynamically linked
library, see Fig. 3 (right).
ldd tells us that wget makes use
of libssl (secure connections),
libpthread (for creating threads),
libz (compression), and libc
amongst others. Libc is, in
essence, the base of your system.
It implements generic C functions
like printf(), malloc(), and free(),
and it implements this logic, often
mapping them on system calls
(e.g., a printf() maps to a write()).
Now ltrace will tell us where our
application makes use of
functions provided by such a
library. So, if we examine the
output of
edb@lapedb:~$ whereis wget
wget: /usr/bin/wget /usr/share/man/man1/wget.1.gz
edb@lapedb:~$ ldd /usr/bin/wget
linux-gate.so.1 => (0xb7f12000)
libdl.so.2 => /lib/tls/i686/cmov/libdl.so.2 (0xb7ed8000)
librt.so.1 => /lib/tls/i686/cmov/librt.so.1 (0xb7ecf000)
libssl.so.0.9.8 => /usr/lib/i686/cmov/libssl.so.0.9.8 (0xb7e88000)
libcrypto.so.0.9.8 => /usr/lib/i686/cmov/libcrypto.so.0.9.8 (0xb7d3c000)
libc.so.6 => /lib/tls/i686/cmov/libc.so.6 (0xb7bde000)
/lib/ld-linux.so.2 (0xb7ef8000)
libpthread.so.0 => /lib/tls/i686/cmov/libpthread.so.0 (0xb7bc5000)
libz.so.1 => /usr/lib/libz.so.1 (0xb7baf000)
Fig. 3
ltrace wget -q internals without any extra
http://www.google.com effort. The only difference is that
they will run a bit slower than
we can find this snippet (some normal, and this allows you to
spaces omitted): learn what the application is
strlen("www.google.com") = 14 doing, and where something
dcgettext(0, 0x8075c8a, 5, goes wrong.
0x804e66d, 0xbf8e1761) = 0x8075c8a
getaddrinfo("www.google.com",
NULL, 0xbf8e1780, 0xbf8e17b4) = 0
Valgrind can be installed by
calloc(1, 20) = 0x909c1e0
malloc(96) = 0x909c1f8 typing:
freeaddrinfo(0x909c100) = <void>
sudo apt-get install valgrind
This is the ltrace counterpart of the
It is a collection of tools that do
DNS resolution we examined in the
some advanced checking of
strace output. All the network
applications. See
communication is hidden by a simple
http://www.valgrind.org for more
call to 'getaddrinfo()'.
information on the available
I hope that you now can appreciate tools. In this article, I will focus
the value of strace and ltrace. Both only on the most-used tool,
allow you to examine a binary's called 'memcheck'. This tool will
override libc calls that deal with
10
handling memory. And it will do allocates some memory in the main timescale. Some applications,
some bookkeeping – is all function, and then goes into an which leak only a couple of bytes
memory (that is dynamically eternal loop. The first thing I want an hour, might run perfectly for
allocated) given back to the you to do is to run this code, replace years - before all hell breaks
system, and is all the allocated the for loop with a while(1) loop, and loose. This is why valgrind is
memory still reachable? replace the malloc(10) with such a useful tool. This is the
malloc(1000). Start the application, output of Listing 1 on my system
Take a look at Listing 1 (below). and see what happens with your after compiling it with
This is some bad code. It calls a system. Your physical memory will
function leak() (lines 3 to 7) 10 be filled, then your swapspace will
gcc -Wall -g leak.c -o memleak
times, which allocates 10 bytes be filled, and eventually the
and does not free it. Then it displays Fig.4 (following page).
oom_killer (out of memory killer) will
kill the fat When I terminate the while(1)
01. #include <stdio.h> process. Things loop by pressing Ctrl+C, it tells
02. #include <stdlib.h> like this are me how many calls to malloc() I
03. void leak() devastating to a did, how much memory I
04. { system and its allocated, and how much I gave
05. char * ptr = malloc(10); performance. back. And then it concludes that
06. printf("malloc(10) points to: %p\n",ptr); You have just I have lost 100 bytes of memory
07. } observed the in 10 blocks. This means that I
08. int main()
effect of a asked for some memory that I
09. {
10. int i=0; memory leak. can't reach anymore because I
11. for(i=0;i<10;i++) This is the don't have a pointer to it
12. { painful part of (“definitely lost” in the output),
13. leak(); dynamically and it says that I have also
14. } asking for allocated 15 bytes in 1 block,
15. char * ptr = malloc(15); memory - it which, at the moment of
16. printf("malloc(15) in main: %p\n",ptr); should all be termination, I could still free
17. while(1){} because I have a pointer to it.
given back! This
18. return 0;
is the example This is why I had to write the
19.}
of a memory while(1) loop. If I hadn't done
Listing 1: leak.c leak on an that, valgrind would have
extreme concluded that I lost 115 bytes

11
edb@lapedb:~/fullcircle/c-6$ valgrind --leak-check=full --show-
reachable=yes ./memleak
==7257== Memcheck, a memory error detector.
==7257== Copyright (C) 2002-2007, and GNU GPL'd, by Julian
in 11 blocks (verify this!), because valgrind accounts for
Seward et al. what really happens; it doesn't look forward to what
==7257== Using LibVEX rev 1854, a library for dynamic binary might happen in the system.
translation.
One special thing I should still mention here: I told you
==7257== Copyright (C) 2004-2007, and GNU GPL'd, by OpenWorks
LLP.
==7257== Using valgrind-3.3.1-Debian, a dynamic binary earlier I compiled the code with the '-g' flag, which adds
instrumentation framework.
==7257== Copyright (C) 2000-2007, and GNU GPL'd, by Julian
debugging symbols to the binary. This is why valgrind is
Seward et al. able to tell us at which file and on which line number the
==7257== For more details, rerun with: -v
==7257==
error occurred. If I would compile the binary with
malloc(10) now points to: 0x41a2028
malloc(10) now points to: 0x41a2068
gcc -Wall leak.c -o memleak
malloc(10) now points to: 0x41a20a8
malloc(10) now points to: 0x41a20e8 the output would look like:
malloc(10) now points to: 0x41a2128
malloc(10) now points to: 0x41a2168 ==7339== 100 bytes in 10 blocks are definitely lost
malloc(10) now points to: 0x41a21a8
malloc(10) now points to: 0x41a21e8 in loss record 2 of 2
malloc(10) now points to: 0x41a2228 ==7339== at 0x4025D2E: malloc
malloc(10) now points to: 0x41a2268 (vg_replace_malloc.c:207)
malloc(15) in main: 0x41a22a8 ==7339== by 0x8048405: leak (in
^C==7257==
==7257== ERROR SUMMARY: 0 errors from 0 contexts (suppressed:
/home/edb/fullcircle/c-6/memleak)
11 from 1) ==7339== by 0x8048443: main (in
==7257== malloc/free: in use at exit: 115 bytes in 11 blocks. /home/edb/fullcircle/c-6/memleak)
==7257== malloc/free: 11 allocs, 0 frees, 115 bytes allocated.
==7257== For counts of detected errors, rerun with: -v
==7257== searching for pointers to 11 not-freed blocks. It still is able to tell us we lost some memory, but it can
==7257== checked 52,132 bytes. no longer tell us on which file or line things went wrong.
==7257==
==7257== 15 bytes in 1 blocks are still reachable in loss
record 1 of 2
So, the good news is valgrind telling us if we have a
==7257== at 0x4025D2E: malloc (vg_replace_malloc.c:207) memory leak or not. The bad news is that we need to
==7257==
==7257==
by 0x8048459: main (memleak.c:15)
have a binary with debugging symbols in it if we wish to
==7257== 100 bytes in 10 blocks are definitely lost in loss know the exact location of the leak. We can then
record 2 of 2 recompile the executable to do some troubleshooting - for
==7257== at 0x4025D2E: malloc (vg_replace_malloc.c:207)
==7257== by 0x8048405: leak (memleak.c:5) which we also need the sources!
==7257== by 0x8048443: main (memleak.c:13)
==7257==
==7257== LEAK SUMMARY:
==7257== definitely lost: 100 bytes in 10 blocks. In this article, I introduced some tools that allow you to
==7257== possibly lost: 0 bytes in 0 blocks.
==7257== still reachable: 15 bytes in 1 blocks. do some easy troubleshooting and analysis on binaries,
==7257== suppressed: 0 bytes in 0 blocks.
Fig. 4 12
without the need to have any
sources or knowledge of these
binaries. Next time, we'll even
attempt to go a bit deeper, and
then we'll take a look at using a
real debugger.
• vmstat is a tool which reports
system usage statistics, use
strace to figure out which /proc/
file(s) it uses to generate its
output.
• Repeat the ltrace/strace
example on wget but now with an
invalid URL, on which output is it
easier to diagnose that the output
was a faulty DNS entry.
• Read the strace manpage; will
strace automatically follow child
processes? What measures do you
have to take when tracing a
multithreaded application?
• Does valgrind automatically trace
child processes?
• Try running valgrind on some of
your favorite command line tools.
And check if they behave properly
13
with respect to memory
management.
• Which others tools are part of
the valgrind suite, and how
could these help you in writing
higher quality applications?
is a
Belgian Linux fanatic, and
apart from spending time
with his family, he enjoys playing
with technology, and spends his
days waiting for Blizzard to finally
release Diablo III.
 HOW-TO
Written by Elie De Brauwer
PROGRAM IN C - PART 7
only what happens with memory
(de)allocation. The tool discussed
FCM#17-22 - Program In C - Parts 1-6 here is named gdb (The GNU
debugger), and to this tool there
are no real limits - if there is
something related to an application
which you want to examine, GDB is
the tool. On a regular Ubuntu
system, gdb can be installed by
Dev
entering:
Graphics Internet Multimedia System
sudo apt-get install gdb

All IDE's on a Linux system which

allow debugging will typically have
CD/DVD HardDrive USB Drive Laptop Wireless
the text-mode gdb as a backend.

I
n part 6 of this series, I showed
you some non-intrusive ways
of examining applications. In
this article, I will present a tool
which allows you to dig deeper, to
do some post-mortem analysis,
and to examine the inner working
of an application. Where
strace/ltrace/valgrind are really
nice tools, they will show only a
part of what really happens;
strace shows, for example, only
system calls, while valgrind shows
Here, I will focus on using gdb from
the command line, but know that
when it comes to complex
debugging, it can sometimes be
useful to have a graphical view on
things. One of the older graphical
frontends on gdb is called (Data
Display Debugger), you can install it
by typing:
sudo apt-get install ddd
Above right is a screenshot of ddd
in action. It consists of three large
panels. At the top, you have the
data panel where you can
display variables and browse
through their contents. In the
middle, you can see the source
panel where the source code is
shown - here you can place
breakpoints. And the bottom
panel allows you to see the gdb
interaction. You can either type
gdb commands in there, or you
can click the matching buttons.

8
 The example in this article is
called . There is already an
ifstat application in Ubuntu, but 01. #include <stdio.h>
this application behaves the same 02. #include <stdlib.h>
but is simpler. The application is 03. #include <string.h>
presented in Listing 1 and Listing 04. #include <unistd.h>
2. The goal of the application is to 05. typedef unsigned long long ull
print, every 2 seconds, the 06. int parseDevFile(const char * iface, ull *bRx, ull *pRx,
07. ull *bTx, ull *pTx)
interface rate of a given network 08. {
interface. It is basically a while 09. FILE * fp = NULL;
loop (Lines 29-49) which reads 10. char * line = NULL;
/proc/dev/net and prints the 11. unsigned int len = 0;
incoming and outgoing interface 12. fp = fopen("/proc/net/dev", "r");
rate for a given network interface 13. if(fp==NULL)
in both kilobytes per second and 14. {
as packets per second. The main 15. return -1;
16. }
function itself is rather simple
17. while(getline(&line,&len,fp)!= -1)
(Lines 51-60). Here we check if 18. {
there is one parameter given from 19. if(strstr(line,iface)!=NULL)
the command line. This one 20. {
parameter will become the 21.
interface the user wants to sscanf(strstr(line,":")+1,"%llu%llu%*u%*u%*u%*u%*u%*u%llu%llu",
monitor. If no parameters, or too 22. bRx, pRx, bTx, pTx);
many parameters, are given, a 23. }
message is printed which
24. }
25. fclose(fp);
instructs the user how to use the 26. free(line);
application. Up until now, nothing 27. return 0;
really new has been shown, all 28. }
new things are in the
parseDevFile() function (Lines 5- Listing 1: ifstat.c (part 1)
28), so the new things are briefly
discussed here. This function will
open /proc/dev/net and parse its

9
 29. void dumpInterfaceUsage(const char * iface)
contents, the counters we are 30. {
interested in will be stored in the 31. ull ifaceBRxOld=0, ifaceBTxOld=0, ifacePRxOld=0, ifacePTxOld=0;
bRx, pRx, bTx and pTx pointers 32. ull ifaceBRxNew=0, ifaceBTxNew=0, ifacePRxNew=0, ifacePTxNew=0;
33. const int SLEEP_TIME = 2;
which are passed when calling
34.
this function. By passing pointers, 35.
we are capable of changing the if(parseDevFile(iface,&ifaceBRxOld,&ifacePRxOld,&ifaceBTxOld,&ifacePTx
values of these variables from Old)==-1) return;
within the function. The function 36. sleep(SLEEP_TIME);
will return 0 on success, or -1 37. while(1)
when opening the file has failed. 38. {
39.
In this example, it is the first if(parseDevFile(iface,&ifaceBRxNew,&ifacePRxNew,&ifaceBTxNew,&ifac
time we open a file - on Line 9 ePTxNew)==-1) return;
there is a file pointer declared. 40. printf("%s In: %8.2f kbyte/s %5llu P/s Out: %8.2f kbyte/s
%5llu P/s\n", iface,
Line 12 contains a call to fopen()
41. (ifaceBRxNew-ifaceBRxOld)/(SLEEP_TIME * 1024.0),
(man fopen for details), the first 42. (ifacePRxNew-ifacePRxOld)/SLEEP_TIME,
argument is the file we want to 43. (ifaceBTxNew-ifaceBTxOld)/(SLEEP_TIME * 1024.0),
open, the second argument says 44. (ifacePTxNew-ifacePTxOld)/SLEEP_TIME);
how we want to open this file. In 45. ifaceBRxOld=ifaceBRxNew; ifaceBTxOld=ifaceBTxNew;
this case “r” means we want to 46. ifacePRxOld=ifacePRxNew; ifacePTxOld=ifacePTxNew;
open the file for reading. Once we 47. sleep(SLEEP_TIME);
are done with reading from the 48. }
file, we close it using fclose() on 49. }
50.
Line 25. 51. int main(int argc, char **argv)
52. {
53. if(argc != 2)
Let's discuss C-style I/O: 54. {
fopen(), fclose(), fread(), fwrite() 55. printf("Usage: %s interfacename\n", argv[0]);
calls are part of the C-standard, 56. exit(1);
and these should be available on 57. }
58. dumpInterfaceUsage(argv[1]);
each platform. open(), close(), 59. return 0;
read(), write(), however, are part 60. }
of the POSIX standard, and these
Listing 2: ifstat.c (part 2)
10
 are the actual internal system
calls. One usually uses fread()
when reading from a file.
However, if you look at the
manual page, it would tell you
that you need to specify a buffer -
the size of an element and how
many elements to read - and this
is not really convenient in our
case. This is why we make use of
getline(); this function takes a
pointer to a pointer as first
argument, and a pointer to an
integer as a second argument.
Internally, this function will always
read a full line, and it will either
copy the data to the buffer passed
if there is enough room, or it will
reallocate a new buffer if there is
not enough room (see man
getline for details). All we should
keep in mind is to free the pointer
getline() allocated for us (Line 26).
edb@lapedb:~/fullcircle/c-7$ gcc -ggdb -o ifstat ifstat.c
edb@lapedb:~/fullcircle/c-7$ ./ifstat wlan0
wlan0 In: 1.36 kbyte/s 16 P/s Out:
wlan0 In: 103.25 kbyte/s 84 P/s Out:
wlan0 In: 1.29 kbyte/s 15 P/s Out:
Lines 19-24 do the actual parsing
of the line read from the file. Line 19
checks if the interface name is
somewhere within the line we read
(meaning we read enough lines). If
we are at the correct line, sscanf()
will be used to convert the values on
the line to the unsigned long long
variable we are using in the
application. Notice that the '*' within
the formatstring means that we are
not interested in this value.
Now, compiling and running the
application gives the output below
when I examine the activity of my
wireless link.
Unfortunately, this article is about
debugging, and although this
example seems to behave now, it is
far from perfect. Notice that I
compiled the example with the -ggdb
1.50 kbyte/s 16 P/s
4.61 kbyte/s 54 P/s
1.50 kbyte/s 16 P/s
11
flags passed to the compiler, this
means that debugging symbols
are embedded within my binary,
and this will allow the debugger
to get more precise information.
When I try to start the
application, and I pass by
accident 'b' as the interface
name, the application behaves
as follows:
edb@lapedb:~/fullcircle/c-7$
./ifstat b
Segmentation fault
Now, what happened here:
apparently our application tried
to access some memory which
didn't belong to the application,
the kernel didn't like this, and
sent us a signal SIGSEGV. As a
result, the application
terminated. There are two
options we could adopt in this
situation; we could either restart
the application in our debugger
and do some live debugging
there. Or we could obtain a core
file and do some post mortem
debugging. When you encounter
a situation like this with any of
the packages your distribution
has to offer, and you file a bug
report, people will often ask you
for a core file. It's useful to know
how to create these core files, so
that's what we'll do first.
edb@lapedb:~/fullcircle/c-7$
ulimit -c unlimited
edb@lapedb:~/fullcircle/c-7$
./ifstat b
Segmentation fault (core
dumped)
edb@lapedb:~/fullcircle/c-7$
ls -hal core
-rw------- 1 edb edb 280K 2009-
03-07 13:33 core
the application was terminated due
to a segmentation violation. We
entered where, and gdb responded
with a backtrace - a list of all
functions that were called - we see
we started at main, then entered
dumpInterfaceUsage, then entered
parseDevFile, which called sscanf.
Thus, usually one hopes (and here
one is usually correct) that the
problem lies within the code you just
wrote, and not within the library you
called. So our guess here would be
that we did something wrong when
calling sscanf(). So, to be sure, I
asked gdb to print the line variable,
and we see here that we are stuck
at a line which contains a 'b'
(which we passed as interface),
but the strstr() which searches for
a ':' has returned NULL since there
is not ':' in the header. So,
sscanf() tried to read from
memory address 1.
In order to have the same effect
on a live session, start gdb, and
pass the binary as the first
argument. At the gdb prompt, you
type run followed by the startup
arguments. And the same will
happen:

With ulimit, limits to certain edb@lapedb:~/fullcircle/c-7$ gdb ifstat core

resources can be set, the size of a
corefile is one of these resources,
and nowadays this is by default
set to 0. When we set this to
unlimited, an application can
dump a core file (a core file is a
dump of the working memory of
an application). Now let's take a
look at it using gdb (right).
Now what have we done here?
We started gdb, and passed our
binary, and the core file, as
startup arguments. gdb told us
GNU gdb 6.8-debian
Copyright (C) 2008 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later
<http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law. Type "show
copying"
and "show warranty" for details.
This GDB was configured as "i486-linux-gnu"...
warning: Can't read pathname for load map: Input/output error.
Reading symbols from /lib/tls/i686/cmov/libc.so.6...done.
Loaded symbols for /lib/tls/i686/cmov/libc.so.6
Reading symbols from /lib/ld-linux.so.2...done.
NOTE: and several other libc.so.6 errors.

12
edb@lapedb:~/fullcircle/c-7$
gdb ifstat
(gdb) run b
Starting program:
/home/edb/fullcircle/c-
7/ifstat b
Program received signal
SIGSEGV, Segmentation fault.
0xb7fd26c7 in rawmemchr ()
from
/lib/tls/i686/cmov/libc.so.6
But here we did not make use of
the core file. The following (right)
is the output of a live session.
When we started the
application with 'bla' as a
parameter, we saw that all our
rates remained zero. So we
decided to take a look. If
something goes wrong, we
suspect it to be in parseDevFile,
so by calling break parseDevFile,
we tell gdb to place a breakpoint
when this function gets called.
This means the application will
start and work as normal, but it
will interrupt and present a gdb
shell each time the breakpoint is
met. After setting the breakpoint,
we start the application and we
get a gdb prompt when the showing an expression every
breakpoint is encountered. We time) on the line pointer which
decide to step through this function contains our string (the output is
by issuing a number of steps a bit trimmed down for
commands (this equals executing formatting reasons). But we see
one line of code). After the fopen() that we go through the while
call, we investigate whether the file loop without executing the
pointer is valid; it seems it is. So we sscanf. So we can only conclude
decide to put a display (this is that the interface “bla” does not
edb@lapedb:~/fullcircle/c-7$ gdb ifstat
(gdb) break parseDevFile
Breakpoint 1 at 0x80485da: file ifstat.c, line 11.
(gdb) run bla
Starting program: /home/edb/fullcircle/c-7/ifstat bla
Breakpoint 1, parseDevFile (iface=0xbf96175d "bla", bRx=0xbf961290,
pRx=0xbf961280, bTx=0xbf961288, pTx=0xbf961278) at ifstat.c:11
11 FILE * fp = NULL;
(gdb) step
12 char * line = NULL;
(gdb) step
13 unsigned int len = 0;
(gdb) step
15 fp = fopen("/proc/net/dev", "r");
(gdb) step
16 if(fp==NULL)
(gdb) print fp
$1 = (FILE *) 0x9e20008
(gdb) step
21 while(getline(&line,&len,fp)!= -1)
(gdb) display line
1: line = 0x0
(gdb) step
23 if(strstr(line,iface)!=NULL)
13
NOTE: and several 'line = 0x9e20170' errors.
exist. When we issue cont to
continue execution, we see the
next time the program encounters
the breakpoint we are dropped
back to the gdb shell.
In this article I introduced first
the concept of C style I/O, and the
use of getline(), but I also gave a
bird's eye overview of gdb. Due to
limited space, I have been able to
only scratch the surface of gdb.
But I hope that this is sufficient to let
the reader understand that gdb
allows you to examine how an
application is running; how it is
making use of the system. And I
strongly advise everybody who
works with C applications to invest
some time in getting to learn to work
with gdb, since this will prove to be
an extremely valuable tool when it
comes to troubleshooting
applications. When it comes to
exercises for this article, fix the
' ' is
reviewed on page 23 of this issue.
14
application! Make sure it prints a
warning when an interface
cannot be found, and make the
interface matching more
intelligent.
is a
Belgian Linux fanatic, and
apart from spending time
with his family, he enjoys playing
with technology, and spends his
days waiting for Blizzard to finally
release Diablo III.
 HOW-TO Program in C - Part 8
sequence will look like:
0,1,1,2,3,5,8,13,21,... and it is
FCM#17-23 - Program In C - Parts 1-7
immediately clear that this is 01. #include <stdio.h>
an ideal job for a computer to 02.
generate. But there's a catch: 03. typedef unsigned long long fibo_type;
04. #define FIBO_FORMAT "%10llu"
these numbers get very large, 05.
very quickly. The Fibonacci 06. void printFibo(fibo_type num)
sequence has some other 07. {
interesting properties and 08. printf(FIBO_FORMAT,num);
09. }
various other, more efficient 10.
Dev Graphics Internet M/media System algorithms to generate a 11. int main()
certain number. 12. {
13. int num=0;

Finding limits
14. fibo_type a=0,b=1,c
15.
CD/DVD HDD USB Drive Laptop Wireless 16. printf("%4d: ",++num); printFibo(a);
In Listing 1, a small
printf("\n");

C
17.
application is shown where the 18. printf("%4d: ",++num); printFibo(b);
omputers and main loop (lines 11 to 29) printf("\n");
mathematics have defines three variables a, b and 19.
c, which will contain the
20. c=a+b;
always been best 21. while(c>=b)
friends. Perhaps this previous, current and next 22. {
is the reason why so many number of the Fibonacci 23. printf("%4d: ",++num); printFibo(c);
bugs exist. To illustrate, this sequence. In each iteration the printf("\n");
numbers are shifted, and a
24. a=b; b=c; c=a+b;
article will work around a 25. }
common problem known as new next value is calculated. 26. printf("Stopped after %d digits\n",num);
overflow. As an example, we There is, however, one odd 27. printFibo(c); printf("\n");
will work with the so called thing - the condition of the 28. return 0;
while loop on line 21. It reads
29. }
Fibonacci sequence, which
starts with zero and one, and 'c>=b', but c equals b+a so Listing 1: Fibonacci.c
the next value in the sequence from a mathematical viewpoint
is calculated by adding the two this expression is worthless
previous digits. This means the since it will always be true.

full circle magazine #24 10 contents ^

PROGRAM IN C - PART 8
However, this application
isn't running in a mathematical
utopia, it is running inside a
computer, and this means that,
in the case of a 32 bit unsigned
integer, if you add one to
0xffffffff, the result will be 0x0.
This means an overflow has
occurred, the new value cannot
be expressed using only 32 bits
(0x100000000), and the result
has been calculated modulo-32
bits
(0x100000000&0xffffffff=0x0).
In other words, a wrap has
occurred. The same happens
when working with signed
values, but here you will
overflow the sign bit first, and
you will end up with a large
negative value.
On line 3 and 4 there is a
definition of a fibo_type and a
FIBO_FORMAT. These are used
to easily modify the application
to other datatypes. This way it
is possible to experiment
where the boundary lies when
using a signed value or a short.
In the case of an unsigned long
long, this application is able to
calculate 94 Fibonacci numbers.
One could also experiment
using floating point numbers,
which have access to a larger
range. But keep in mind that
one looses precision. This can
be even more dangerous since
the number appears to be
correct but in fact isn't (if in
doubt ask the people who
wrote the Ariane 5 rocket
software).
Conclusions so far: It's nice
that there are an infinite
number of integers. Wouldn't it
be nice if we could be able to
actually use all of them?
Breaking limits
Well, actually we can use
them all, but there will be a
price in efficiency. Adding two
32-bit values is bleeding fast,
in fact a simple assembly
instruction is able to do the
trick, but then again you're
stuck with the 32-bit limit (this
may vary depending on cpu
type, but there will be some
limit). But there's a work-
around. Instead of using an
integer we could use an array
and implement the addition
ourselves, simply by doing it
the same way we learned to do
it in primary school: and one
full circle magazine #24
digit at a time, bring carry into
the calculation, etc. For
addition and subtraction, this
can be done, but once working
with multiplication, division,
and square roots, things are
getting rather tricky, and it
gets very unlikely that they will
be implemented efficiently.
Adding two digits is as efficient
as adding two integers, so
adding two four-digit numbers
the manual way is at least four
times slower than the integer
version.
Now, luckily we live in an (at
least for a part) open world,
and we are not required to
reinvent the wheel ourselves.
There is a library called GMP
(GNU Multiple Precision
Arithmetic Library, see
http://gmplib.org), which offers
all this functionality and much,
much more, and all we need to
do for it is type sudo apt-get
install libgmp3-dev. This library
offers us a lot of functionality,
but, in this article, we'll only
scratch the surface a little. I
strongly encourage the reader
to take a look at the API
documentation at
http://gmplib.org/manual/ to
see the possibilities this library
11
can offer you.
Listing 2, which can be
compiled with the command:
gcc -Wall -lgmp Fibonacci2.c
-o Fibonacci2
shows an implementation of
the same algorithm, but now it
uses GMP. Lines 12-15 initialize
a container, and set the
container to a certain value.
Behind the scenes, GMP
allocates storage for you, and
performs all the needed
bookkeeping. Lines 18 to 25
show the main loop, which will
never terminate. Here the
mpz_add function is used to
add two integers and store the
result in an mpz_t. This
replaces the c=a+b. And
mpz_swap is used to get the
order right. We only use two
variables here and one swap,
instead of three variables and
two swaps we used in Listing 1.
The second part of the while
loop, lines 22-24, creates a
base-10 string representation
of the mpz_t, prints it and frees
the storage (note: there is
room for improvement here,
see exercises). Lines 26-30 are
unreachable code, but they
contents ^
PROGRAM IN C - PART 8
illustrate how the internal point data types in Fibonacci.c.
structure should be cleared. Do you get more numbers? Are
This clearly states how powerful they correct? Where do things
01. #include <stdio.h> this library is. From a start going wrong?
02. #include <stdlib.h> programmer's perspective, all
03. #include <string.h> we need to do is replace our • Skim through the GMP api
04. #include <gmp.h> initialization of our variables, documentation and get familiar
05.
06. int main() and replace the addition by a with the possibilities of the
07. { library call. Behind our backs, library.
08. int num=0; the library took care of
09. mpz_t f_1; everything. But keep in mind • Read the GMP manual, and
10. mpz_t f_2;
11. that these 'simple' additions search for help on mpz_get_str.
12. mpz_init(f_1); are in fact rather heavy Now, rewrite Fibonacci2 so that
13. mpz_init(f_2); computations, and it would be memory is not allocated and
14. mpz_set_ui(f_1,0); a bad idea not to use an integer freed every time, but is
15. mpz_set_ui(f_1,1);
16. printf("%10d: 0\n",++num); for num. reallocated when more digits
17. are required.
18. while(1) Now this application will give
19. { us a truly eternal (well actually
20. mpz_add(f_1,f_2,f_1);
21. mpz_swap(f_1,f_2); num will overflow after 2^31
22. char * res = mpz_get_str(NULL,10,f_2); Fibonacci digits) feed of
23. printf("%10d: %s\n",++num, res); Fibonacci numbers in a style
24. free(res); what would only envy The
25. }
26. Matrix.
27. mpz_clear(f_1);
28.
29.
mpz_clear(f_2);
return 0; Exercises
30. }
• Try running the application for
Elie De Brauwer
Listing 2: Fibonacci2.c all different data types in
Fibonacci.c, signed and
unsigned versions of char,
short, long and long long, and
try to pinpoint their limits.

• Try the same using floating

full circle magazine #24 12 contents ^