Operators and Operator Precedence

The operators in C are similar to the operators in Pascal, as shown below:

The / operator performs integer division if both operands are integers and floating point division otherwise. For example:

void main()  
{    
    float a; 
    a=10/3;    
    printf("%f\n",a);  
} 

This code prints out a floating point value since a is declared as type float, but a will be 3.0 because the code performed an integer division.

Operator precedence in C is also similar to that in Pascal. As in Pascal, parentheses control precedence. See tutorial 14 for more information on precedence, which becomes somewhat complicated in C once pointers are introduced.

Typecasting

C allows you to perform type conversions on the fly. You do this especially often when using pointers. Typecasting also occurs during the assignment operation for certain types. For example, in the code above, the integer value was automatically converted to a float.

You do typecasting in C by placing the type name in parentheses and putting it in front of the value you want to change. Thus, in the above code, replacing the line a=10/3; with a=(float)10/3; produces 3.33333 in a because 10 is converted to a floating point value before the division.

Types

You declare named, user-defined types in C with the typedef statement. The following example shows a type that appears often in C code:

#define TRUE  1  
#define FALSE 0 
typedef int boolean; 
 
void main()  
{    
    boolean b; 
    
    b=FALSE;    
    blah blah blah  
} 

This code allows you to declare Boolean types in C programs.

If you do not like the word float” for real numbers, you can say:

typedef float real;

and then later say:

real r1,r2,r3;

You can place typedef statements anywhere in a C program as long as they come prior to their first use in the code. You do not have to group them together as in Pascal, and you need no special word to mark the beginning of the block as in Pascal.

Records

Records in C and Pascal are very similar, as shown below. First, consider a Pascal record.

type    
    rec=record      
        a,b,c:integer;      
        d,e,f:real;    
    end;  
var    
    r:rec; 

In C, the same code looks like this:

struct rec  
{    
    int a,b,c;    
    float d,e,f;  
}; /* Note semicolon */ 
 
struct rec r; 

As shown here, whenever you want to create records of the type rec, you have to say struct rec. This line is very easy to forget, and you get many compiler errors because you absent-mindedly leave out the struct. You can compress the code into the form:

struct rec  
{    
    int a,b,c;    
    float d,e,f;  
} r; 

where the type declaration for rec and the variable r are declared in the same statement.

You access fields of records exactly as in Pascal, using a period (.), for example, r.a=5;.

You can declare a typedef for a record. For example, if you do not like saying struct rec r every time you want to declare a record, you can say:

typedef struct rec rec_type; 

and then declare records of type rec_type by saying:

rec_type r; 

Arrays

You declare arrays by inserting an array size after a normal declaration, as shown below:

int a[10];        /* array of integers */  
char s[100];      /* array of characters (a C string) */  
float f[20];      /* array of reals */  
struct rec r[50]; /* array of records */ 

Incrementing

Exercises

1. Try out different pieces of code to investigate typecasting and precedence. Try out int, char, float, and so on.
2. Create an array of records and write some code to sort that array on one integer field.

C error to avoid

1. As described above, using the / operator with two integers will often produce an unexpected result, so think about it whenever you use it.