C Programming Language Tutorial - Introduction

This C programming language tutorial covers the fundamentals of C, including variable data types, control flow statements, arithmetic, logical, relational operators, C function declaration and definition, arrays, pointers, structures, unions, typedefs, enums, and more.

C Variable Data Types

The following table summarizes C variable data types, their corresponding C keyword, size (in bytes), and range.

Control Flow Statements in C

Here are some of the control flow loops and selection statements in C, similar to those found in other programming languages:

For Loop

for (initial; condition; increment) {
  Statements (one or multiple);
}

For example:

for (i = 0; i < 10; i++) {
  // Code to be executed
}

While and Do-While Loops

while (condition check) {
  Statements;   // one or many
}

do {
  Statements;   // one or many
} while(condition check);

If-Else Statement

if (conditioncheck1) {
  // Statements (one or many)
} else if(conditioncheck2) {
  // Statements (one or many)
} else if(conditioncheck3) {
  // Statements (one or many)
} else {
  // Statements (one or many)
}

Switch Statement

switch (condition) {
  case condition1:
    // statements
    break; // Optional: exits the switch statement
  case condition2:
    // statements
    break;
  case condition3:
    // statements
    break;
  default:
    // statements
}

One can insert a break statement in each case to bring program control out of that particular case.

Break Statement

The break statement brings program control out of the loop or function it has been called in.

Continue Statement

Inside a switch statement, and when called in a loop (while, for), the continue statement causes the next iteration of the loop to execute.

Operators - Arithmetic, Logical, Relational

Arithmetic Operators

• Addition: +
• Subtraction: -
• Multiplication: *
• Division: /
• Modulus: %
• Increment: ++
• Decrement: --

Relational Operators

• Equal: ==
• Greater than: >
• Less than: <
• Greater than or equal to: >=
• Less than or equal to: <=
• Not equal: !=

Logical Operators

• AND: &&
• OR: ||
• NOT: !

Bitwise Logical Operators

• & Bitwise AND
• | Bitwise inclusive OR
• ^ Bitwise exclusive OR
• << Left shift
• >> Right shift
• ~ One’s complement

Compound Assignment Operators

a += b can be written for a = a + b. += is called a compound assignment operator for addition. A few operators are outlined below:

• Addition: +=
• Subtraction: -=
• Bitwise AND assignment: &=
• Bitwise left shift: <<=

Member and Pointer Operators

• Array subscript: a[0]
• Indirection (Object pointed to by a): *a
• Reference (address of a): &a
• Structure dereference (member b of object pointed to by a): a->b
• Structure reference (member b of object a): a.b

Other Operators

• Function call: a(a1, a2)
• Comma: a, b
• Ternary Condition: a ? b : c
• Sizeof: sizeof(a)
• Type cast: (type)a

C Function Declaration/Definition

• Functions:
  • Modules in C
  • Programs combine user-defined functions with library functions
  • The C standard library has a wide variety of functions
• Function calls:
  • Invoking functions:
    • Provide function name and arguments (data)
    • Function performs operations or manipulations
    • Function returns results
• Function call analogy:
  • Boss asks worker to complete task
  • Worker gets information, does task, returns result
• Information hiding: boss does not know details

Any file with the .c extension is considered a C file. Any C file contains functions and variables as per the C program structure.

Function Declaration

return_value function_name(arg_1, ..., arg_n);

Function Definition

return_value function_name(arg_1, ..., arg_n) {
  /* C statements and local variables if any, should end with semicolon(;) */
}

Function Prototype Declaration Example

double cube_number(int number);

number is the argument, which is of int type. There may be more than one argument. The function name is cube_number, which calculates the cube of a number and returns a value of type double.

More than one value can be passed to a function as arguments, or more than one value can be returned from a function using a concept called “pass by reference.” What we have seen above is “pass by value.”

In “pass by reference,” a pointer is used as an argument to a function, or a pointer is used as a return variable. A pointer points to the starting address of either an array, structure, or union, and hence all the elements can be accessed easily.

Array

An array stores elements of a similar data type in consecutive memory locations.

Single Dimensional Array

#define arr_size 10
int array[arr_size] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

Multi Dimensional Array

#define no_rows 4
#define no_cols 3
int array[no_rows][no_cols] = {
  { 1, 2, 3 },
  { 4, 5, 6 },
  { 7, 8, 9 },
  { 10, 11, 12 }
};

Pointer

A pointer stores the address of some data type element viz. int, float, char, char string, structure, union, array or any C function. Hence, using a pointer directly, the respective data type can be accessed once the pointer is initialized for the same.

typename *ptr;

typename can be any C variable type that the pointer will point to.

For Example:

int *p1;    // p1 is the pointer and points to int variable data type

Pointer Initializing

int employee_number;
int arr[10];
int *ptr1, *ptr2;

ptr1 = &employee_number;
ptr2 = arr;    // array name itself points to the memory address and no & required

Structure

A structure contains one or more variables of different types. It helps in easy management as different variable types are assigned by one common structure name. All the structure variables are stored consecutively in memory. A structure can hold another structure also as a member.

struct emp_record {
  char name[10];
  int number[12];
  float Salary;
};

Here the structure name is emp_record, and name, number, salary are structure member variables/elements.

In order to access structure members, a variable to the structure is to be declared as mentioned below. It can be a simple structure variable or a pointer variable to the structure.

struct emp_record employee;  // employee is the instance for the structure emp_record
struct emp_record *ptr;  // ptr is the pointer to the structure emp_record

Structure member elements can be accessed using the . operator if the instance is non-pointer. Can be accessed using the -> operator if the instance is a pointer to the structure.

For example:

employee.name OR employee.number OR employee.Salary
ptr->name OR ptr->number OR ptr->Salary

ptr = &employee;   // pointer needs to be initialized with structure's memory location address

Union

A union is similar to a structure; the difference is in allocating size in memory and the keyword used here in the union in place of struct.

union emp_record {
  char name[10];
  int number[12];
  float Salary;
};

If the above declaration and instance for the same are of structure, then it allocates about 26 bytes (10 for name, 12 for number, and 4 for float) in memory. If the same declaration and instance are for the union, it allocates size as of the maximum size of the member variable (here it is number and hence the size allocated will be 12 bytes for this union).

Here, the size allocated in memory is used by one member variable at a time.

Typedef

Typedef is the keyword that creates a synonym for some variable type. It is mainly used to create a synonym for structure/union. Hence, it makes it easy to call a structure by one simple, easy-to-remember name rather than calling the entire structure/union all the time. Hence, it minimizes lines of code in a C program.

For example:

typedef struct {
  char name[10];
  int number[12];
  float Salary;
} emp_record;

Hence, here emp_record is the synonym identifier of the following lines of code.

struct {
  char name[10];
  int number[12];
  float Salary;
};

Enum Type

enum employee_num {Rahul, Ramesh, Roopesh};

As per this enum specifier, C assigns automatically: Rahul=0, Ramesh=1 and Roopesh=2

The starting value can be pre-configured as below

enum employee_num {Rahul=100, Ramesh, Roopesh};

Conditional Expression

C provides a short way of representing a single if-else statement as follows.

if(a > b)
  z = a;
else
  z = b;

Above can be represented by a single conditional expression,

z = (a > b) ? a : b;

Here if a > b is TRUE then z = a and if a > b is FALSE then z = b.

Preprocessor Directive

Preprocessor statements execute prior to the actual compilation of the C program. All the preprocessor directives in the C language begin with # (which is a pound sign). One must have seen the #include preprocessor directive, which includes C header files in all C programs.

Another common preprocessor directive is the #define directive, which replaces any character string with some value or string.

For Example:

#define pi 3.1428
#define CITY_NAME "BANGALORE"

Another preprocessor directive is #ifdef and #endif

#ifdef MACRO_N
  stat1
  stat2
  -----
  statN
#endif

As shown, MACRO_N is defined using the #define directive. Here, based on MACRO_N, a set of statements are compiled prior to the other ones.