C Hints and Tips The preprocessor and other fun toys

Operators and Types Most C operators can work with many different types of numbers +, -, *, /, %, >>, ++, etc.. int, double, float, char, etc.. Understanding how the compiler interprets your instructions is crucial! it will perform some conversions, but they might not always make sense (to you!) Like the rest of programming, experience is essential

Type Conversions Types in C can be thought of as having a heirarchy char -> int -> float -> double ie, double is the ‘broadest’ type, char is the ‘narrowest’ C will convert variables to broader types in certain conditions when the other operand of the operator is of a broader type when passing to a function which takes a larger type It will NOT convert in other situations! some compilers will shrink values to fit into narrower types, but data loss may occur It will ONLY consider the current operator, NOT any future operators!! this means that unexpected results can be obtained in some very common circumstances..

Common Errors Consider the following code fragment: int a = 16 ; double d ; d = a / 3 ; What will the final value of d be?!? ? 5? something else? Keep in mind that ‘/’ and ‘=‘ are totally separate operators when determining what, if any, type conversions to perform on the operands of ‘a/3’, the ‘=‘ operator which will follow is ignored!

More Examples.. What will be the result of these statements? char c = ‘a’ ; int i = a << 8 ; double d = 15 / 3 ; d = 15 / 3.0 ;// is this different?! i = * 4 ;// will this work? You can write a simple program with printf statements after every line to display these values..

The C Pre-Processor Directives The C pre-processor is a program which is run on a C source file before compiling Its main function is to modify the program in certain ways removes comments substitutes certain identifiers includes other files It is a very powerful tool, and knowing how to use it is an essential C programming skill!

Using Pre-Processor Directives Unlike normal C statements, spacing is important for pre- processor directives each directive should be on a single line, with the first character always ‘#’ directives are terminated by a newline character, and should NOT have a ‘;’ at the end! The pre-processor is automatically run when you compile the program the output is sent straight to the ‘real’ compiler You can also run the pre-processor separately with the command ‘cpp’ test this on one of your C source files, and have a look at the result, it might explain a few things!

#include Directives The most commonly used pre-processor directive is #include inserts the named file at the current position <> brackets mean the file is in the system directories “” quotes mean that the filename is relative to the current directory Examples: #include includes the system header /usr/include/stdio.h #include “blah.h”includes the file blah.h in the current directory #include “headers/blah.c”includes the file blah.h in the headers subdirectory Almost all #include statements you will use will be system header files, so <> are used

#define Directive #define is used to declare constants and macros Syntax (constants): #define NAME replacement text for the remainder of the file, NAME is replaced with whatever follows on the #define line #define statements should be used for all constants for which a name is more meaningful than a value The macro form of #define is beyond the scope of this course..

#define Example #include #define ARRAY_SIZE 50 int main ( void ){ int ar[ARRAY_SIZE], i ; for ( i = 0 ; i < ARRAY_SIZE ; i++ ){ … } The value 50 is substituted for ARRAY_SIZE wherever it appears…

Why Use #define? Using constants is considered good programming practice, for a number of reasons: it makes your code much more readable changing the value requires on ONE change, instead of possibly hundreds throughout your program you do not have to remember the actual values when programming consider colour tables, where each colour has a number – it is MUCH easier to remember BLUE than a random pallete number.. A good rule of thumb: if you use a value more than once (with the same meaning), #define it! Many libraries (that you #include) will have many constants defined already: has M_PI defined!

#undef Directive The opposite of #define Clears a previously #defined constant or macro

#if Directive Simple control statement, allowing very basic comparisons to be made Three basic forms: #ifdef perform action if constant/macro exists #ifndef perform action if constant/macro does NOT exist #if CONST == VALUE perform action if constant has the given value The actions are all the lines after the #if directive, until the #endif line is encountered these can be C statements, other pre-processor directives, or anything else.. Basically, the lines between #if and #endif are only included if the condition of the #if directive are met

#if Example #include #define DEBUG 0 int main ( void ){ #if DEBUG == 1 printf ( “The program has started\n” ) ; #endif } The printf statement is ONLY run if DEBUG is equal to 1. In this example it is not, so nothing is printed! This is a very useful way to develop programs, as it allows for messages to be displayed when writing the code, then easily turned off for the ‘real’ program.

Warnings and Compiler Messages The C compiler is very forgiving many ‘errors’ are not treated as such, and compilation is allowed to continue In some cases, ‘warnings’ are generated indicate that your code has done something a little naughty, but not serious enough to warrant an error Warning messages should not be ignored they often mean you have made a mistake which will cause the program to crash when run, or do the wrong thing! the only warnings you can safely ignore are the ones you expect, when you know your code is correct