There are 32 keywords that, when combined with the formal C syntax, form the C

language as defined by the ANSI C. Note that 5 new keywords have been introduced
into the new C9X standard (read draft) - these are not covered here yet.

All keywords use lowercase letters. In C, uppercase and lowercase are different, for
instance, else is a keyword, ELSE is not a keyword though.

An alphabetical summary of each of the keywords is as follows:

auto double int struct

break else long switch
case enum register typedef
char extern return union
const float short unsigned
continue for signed void
default goto sizeof volatile
do if static while

auto
auto is used to create temporary variables that are created upon entry into a block of and
destroyed upon exit. For example:

#include <stdio.h>
#include <conio.h>

int main(void)
{

for(; ;)
{

if (getche() == 'a')
{
 auto int t;

for (t=0; t<'a'; t++)

printf("%d ", t);

break;
}

return 0;

In this example, the variable t is created only if the user strikes an a. Outside the if block,
t is completely unknown, and any reference to it would generate a comile-time syntax
error. The use of auto is completely optional since all local variables are auto by default.

In many cases it is used simply to make the program more readable. That is because if
you see that a variable or string literal has an auto keyword in front of it, you can tell that
the variable or string literal is a local variable or string literal and not a global one. It can
be used to simply tell the reader whether the variable or string literal is local or global -
the compiler doesn't normally use it.

break
break is used to exit from a do, for, or while loop, bypassing the normal loop condition. It
is also used to exit from a switch statement. An example of break in a loop is shown
here:

while (x < 100)

{
x = get_new_x();
 if (kbhit()) break; /* key hit on keyboard */
process(x);
}

Here, if a key is pressed, the loop will terminate no matter what the value of x is. In a
switch statement, break effectively keeps program execution from "falling through" to the
next case. (refer to the lesson covering the switch statement for details).

case
case is covered in conjunction with switch.

char
char is a data type used to declare character variables. For example, to declare ch to be
character type, you would write:

char ch;

In C, a character is one byte long. This means if you were to assign a string to a variable
type char, than only the first character will be assigned and the remaining characters will
not be used.

const
The const modifier tells the compiler that the contents of a variable cannot be changed. It
is also used to prevent a function from modifying the object pointed to by one of its
arguments. To declare a variable as a constant use:

const int pass = 65;

continue
continue is used to bypass portions of code in a loop and forces the conditional
expression to be evaluated. For example, the following while loop will simply read
characters from the keyboard until an M or F gender is specified:
#include <stdio.h>
#include <conio.h>
#include <stdio.h>
#include <ctype.h>

int main(void)
{
char gender;

while (gender = getche())

{

gender = toupper(gender);

if (gender != 'M' && gender != 'F' )

{
printf("Incorrect gender, please type again\n");
continue;
}

break;

return 0;
}

default
default is used in the switch statement to signal a default block of code to be executed if
no matches are found in the switch. See the switch section for more info.
do
The do loop is one of three loop constructs available in C. The general form of the do
loop is

do
{
statement block
} while (condition);

If only one statement is repeated, the braces are not necessary, but they add clarity to
the statement. he do loop repeats as long as the condition is true. The do loop is the only
loop in C that will always have at least one iteration because the condition is tested at
the bottom of the loop. A common use of the do loop is to read disk files. This code will
read a fine until and EOF (end of file) is encountered.

do
{
ch = getc(fp);
if (!eof(fp)) printf("%c", ch);
while (!eof(fp));

double
double is a data type specifier used to declare double-precision floating-point variables.
double is the data type specifier needed when a value of the mathematical equivalent
(scientific notation) of standard form, needs to be declared. To declare d to be of type
double you would write the following statement:

double d;

else
see the if section.
enum
The enum type specifier is used to create enumeration types. An enumeration is simply a
list of named integer constants. For example, the following code declares an
enumeration called color that consists of three constants: red, green, and yellow:

#include <stdio.h>

enum color {red, green, yellow};

enum color c;

int main(void)
{
c = red;

if (c==red) printf("is red\n");

return 0;

extern
The extern data type modifier tells the compiler that a variable is defined elsewhere in
the program. This is often used in conjunction with separately compiled files that share
the same global data and are linked together. In essence, it notifies the compiler of a
variable without redefining it.

As an example, if first were declared in another file as an integer, the following

declaration would be used in subsequent files:

extern int first;

float
float is a data type specifier used to declare floating point variables. To declare f to be of
type float you would write:

float f;

for
The for loop allows automatic initialization of instrumentation of a counter variable. The
general form is

for (initialization; condition; increment)

{
statement block
}

If the statement block is only one statement, the braces are not necessary. Although the
for allows a number of variations, generally the initialization is used to set a counter
variable to its starting value. The condition is generally a relational statement that checks
the counter variable against a termination value, and the increment increments (or
decrements) the counter value. The loop repeats until the condition becomes false.

The following code will print hello ten times:

for (t=0; t<10; t++) printf("Hello\n");

goto
The goto causes program execution to jump to the label specified in the goto statement.
The general form of the goto is

goto label;
..
..
..
label;
All labels must end in a colon and must not conflict with keywords or function names.
Furthermore, a goto can branch only within the current function, and not from one
function to another.

The following example will print the message right but not the message wrong:

goto lab1;
printf("wrong");
labl1:
printf("right");

if
The general form of the if statement is:

if (condition)
{
statement block 1
}
else
{
statement block 2
}

If single statements are used, the braces are not needed. The else is optional. The
condition may be any expression. If that expression evaluates to any value other than 0,
then statement block 1 will be executed; otherwise, if it exists, statement block 2 will be
executed. The following code fragment can be used for keyboard input and to look for a
'q' which signifies "quit."

ch = getche();

if (ch == 'q')
 {
printf("Program Terminated");
exit(0);
}
else proceed();

int
int is the type specifier used to declare integer variables. For example, to declare count
as an integer you would write

int count;

long
long is a data type modifier used to declare long integer and long double variables. For
example, to declare count as a long integer you would write

long int count;

register
The register modifier requests that a variable be stored in the way that allows the fastest
possible access. In the case of characters or integers, this usually means a register to
the CPU. To declare i to be a register integer, you would write:

register int i;

return
The return statement forces a return from a function and can be used to transfer a value
back to the calling routine. For example, the following function returns the product of its
two integer arguments.

int mul(int a, int b)

{
return a*b;
 }

Keep in mind that as soon as return is encountered, the functions will return, skipping
any other code in the function.

short
short is a data type modifier used to declare small integers. For example, to declare sh to
be a short integer you would write

short int sh;

signed
The signed type modifier is most commonly used to specify a signed char data type.

sizeof
The sizeof keyword is a compile-time operator that returns the length of the variable or
type it precedes. If it precedes a type, the type must be enclosed in parenthesis. For
example:

printf("%d", sizeof(short int));

will print 2 for most C implementations.

The sizeof statement's principal use is in helping to generate portable code when that
code depends on the size of the C built-in data types.

static
The static keyword is a data type modifier that causes the compiler to create permanent
storage for the local variable that it precedes. This enables the specified variable to
maintain its value between function calls. For example, to declarelast_time as static
integer, you would write:

static int last_time;

static can also be used on global variables to limit their scope to the file in which they are
declared.

struct
The struct statement is used to create aggregate data types, called structures that are
made up of one or more members. The general form of a structure is:

struct struct-name
{
type member1;
type member2;
..
..
..
type member N;
} variable-list;

The individual members are referenced using the dot or arrow operators.

switch
The switch statements is C multi-path branch statement. It is used to route execution in
one of several ways. The general form of the statement is:

switch(int-expression)
{
case constant1: statement-set 1;
break;
case constant2: statement-set 2;
break;
..
..
..
 case constantN: statement-set N;
break;
default: default-statements;
}

Each statement-set may be one or many statements long. The default portion is optional.
The expression controlling the switch and all case constants must be of integral or
character types.

The switch works by checking the value of int-expression against the constants. As soon
as a match is found, the set of statements is executed. If the break statement is omitted,
execution will continue into the next case. You can think of the cases as labels.
Execution will continue until a break statement is found or the switch ends. The following
example can be used to process a menu selection:

ch = getche();

switch(ch)
{
case 'e': enter();
break;
case '1': list();
break;
case 's': sort();
break;
case 'q' : exit(0);
break;
default: printf("Unknown Command\n");
printf("Try Again\n");
}

typedef
The typedef statement allows you to create a new name for an existing data type. The
general form of typedef is:

typedef type-specifier new-name;

For example, to use the word 'balance' in place of 'float', you would write

typedef float balance;

union
The union keyword creates an aggregate type in which two or more variables share the
same memory location. The form of the declaration and the way a member is accessed
are the same as for struct. The general form is:

union union-name
{
type member1;
type member2;
..
..
..
type memberN;
} variable-list;

unsigned
The unsigned type modifier tells the compiler to create a variable that holds only
unsigned (i.e., positive) values. For example, to declare big to be an unsigned integer
you would write

unsigned int big;

void
The void type specifier is primarily used to declare void functions (functions that do not
return values). It is also used to create void pointers (pointers to void) that are generic
pointers capable of pointing to any type of object and to specify an empty paramater list.

volatile
The volatile modifier tells the compiler that a variable may have its constants altered in
ways not explicitly defined by the program. Variables that are changed by the hardware,
such as real-time clocks, interrupts, or other inputs are examples.

while
The while loop has the general form:

while(condition)
{
statement block
}

If a single statement is the object of the while, the braces may be omitted. The loop will
repeat as long as the condition is true. The while tests its condition at the top of the
loops. Therefore, if the condition is false to begin with, the loop will not execute at all.
The condition may be any expression. An example of a while follows. It reads characters
until end-of-file is encountered.

t = 0;

while(!feof(fp))
{
s[t] = getc(fp);
}

back to top