C Programming Basics Notes for Beginners

C is a general purpose programming language and it was developed by Dennis Ritchie in 1972. These Programs are simply set of instructions given by a programmer to the computer in high level language. The program execution process consists of two steps , first  it uses a compiler to translate/convert the high level program into machine code then execute the instruction set.

C has wide features −

Easy to learn its fundamental concepts and as a beginner level entity in programming.

It follows structured programming approach scheme.

It produces efficient programs that accomplish a given task.

It can handle low-level activities.

It can be compiled on a variety of computer platforms.

C was invented to write an operating system called UNIX.

C is a successor of interpreted B language which was introduced around the early 1972, in At&T Bell Laboratories which was then standardized by the American National Standards Institute.

The UNIX OS was totally written in C.

Today C is the most widely used and popular System Programming Language.

As in all programming or real world entity to express with we need a algorithm which means a series of simple written English statements, i.e steps to move forward for task. for example a screenshot of it.

A flowchart is a formalized graphic representation that represents an algorithm, workflow or process, showing the steps as boxes of various kinds, and their order by connecting them with arrows. This diagrammatic representation shows a solution model to a given problem.

1.    In While loop the condition is tested first and then the statements are executed if the condition turns out to be true. whereas, In do-while the statements are executed firstly i.e first time and then the conditions are tested, if the condition turns out to be true then the statements are executed again.

2.    A do-while is used for a block of code that must be executed at least once i.e, do-while loop runs at least once even though the condition given is false whereas, while loop do not run in case the condition given is false.

3.    In a while loop the condition is first tested and if it returns true then it goes in the loop

In a do-while loop the condition is tested at the last.
4.    While loop is entry control loop, where as do-while is exit control loop.

6.    Syntax: while loop  :

while (condition)
{
Statements;
}

7.    Syntax: do while loop  :

Do
{
Statements;
}while(condition);

An array is a collection of similar data items, i.e all of the same datatype, accessed using a common name. A one-dimensional array is like a list; A two dimensional array is like a table would be considered as row and columns.

One-dimensional array is declared as follows:

type array-name[size] = { list of values };

example:

int marks[4]={ 67, 87, 56, 77 };   //integer array initialization

Program:

#include<stdio.h>

#include<conio.h>

void main()

{

 int i;

 int arr[]={2,3,4};    //Compile time array initialization

 for(i=0 ; i<3 ; i++)

{

 printf(“%dt”,arr[i]);

 }

 getch();

}

Output :2  3  4

Two-dimensional array is declared as follows,

type array-name[row-size][column-size]

Example : int a[3][4];

Program:

#include<stdio.h>

#include<conio.h>

void main()

{

 int arr[3][4];

 int i,j,k;

 printf(“Enter array element”);

 for(i=0;i<3;i++)

 {

  for(j=0; j < 4; j++)

  {

   scanf(“%d”,&arr[i][j]);

  }

 }

 for(i=0; i < 3; i++)

 {

  for(j=0; j < 4; j++)

  {

   printf(“%d”,arr[i][j]);

  } }

getch();

}

Structure is a user-defined data type in C which allows you to use dissimilar datatypes such as combination of (int,float,char) to store a particular type of record or segment. Structure helps to construct a complex datatype.

The only difference is that array is used to store collection of similar datatypes while structure can store collection of any type(dissimilar) of data.

struct keyword is used to define a structure. struct define a new data type which is a collection of different type of data.

Syntax :

struct structure_name

{

 //Statements

};

Example of Structure

struct TextBook

{

 char names[15];

 int price;

 int pages;

};

1) Declaring Structure variables separately

struct Student

{

 char[20] name;

 int age;

 int seatno;

} ;

struct Student St1 , St2;   //declaring variables of Student

2) Declaring Structure Variables with Structure definition

struct Student

{

 char[20] name;

 int age;

 int seatno;

} St1, St2;

Structure members can be accessed and assign the values in number of ways. In order to assign a value to a structure member, the member name must be linked with the structure variable using      dot[.]operator also called period or member access operator.

struct TextBook

{

 char names[15];

 int price;

 int pages;

} b1 , b2 ;

b1.price=200;      //b1 is variable of TextBook type and price is member of TextBook

Program :

#include<stdio.h>

#include<conio.h>

struct employer

{

 char ename[10];

 int revenue;

};

struct employer emp[5];

int i,j;

void inquire()

{

 for(i=0;i<3;i++)

 {

  printf(“nEnter %d employer recordn”,i+1);

  printf(“nEmployer namet”);

  scanf(“%s”,emp[i].ename);

  printf(“nEnter employer revenuet”);

  scanf(“%d”,&emp[i].revenue);

 }

 printf(“nDisplaying Employer recordn”);

 for(i=0;i<3;i++)

 {

  printf(“nEmployer name is %s”,emp[i].ename);

  printf(“nRevenue is %d”,emp[i].revenue);

 }}

void main()

{

 clrscr();

 inquire();

 getch();

}

Nesting of structures, are also implemented in C language.

Example :

struct student

{

 char[30] name;

 int age;

   struct address

    {

     char[50] area;

     char[50] city;

     int pincode;

    };

};

Static variable is accessible in C, throughout the life time of the program. At the time of  the program execution, static variables allocations takes place first. In a scenario where one variable is to be used by all the functions (which is accessed by main () function), then the variable need to be declared as static in a C program.

A block of memory may be allocated using the function malloc malloc(). The malloc function reserves a block of memory of specified size and returns a pointer of type void(). This means we can assign the base address of the block to any type of pointer

                                      Syntax –     P = (cast type*)malloc(byte size);

Calloc() is also a memory allocation function which is generally used to allocate memory for array and structure. malloc() is used to allocate a single block of storage space, calloc() allocates multiple blocks of storage, each of same size and initializes them with zero.

                                      Syntax –     P = (cast type*)calloc(n,array size)

The call by reference method of passing arguments to a function copies the address of an argument into the formal parameter. Inside the function, the address is used to access the actual argument used in the call. It means the changes made to the parameter affect the passed argument.

To pass a value by reference, argument pointers are passed to the functions just like any other value. So accordingly you need to declare the function parameters as pointer types as in the following function swap(), which exchanges the values of the two integer variables pointed to, by their arguments.

/* function definition to swap the values */

void swap(int *x, int *y) {

   int temp;

   temp = *x;    /* save the value at address x */

   *x = *y;      /* put y into x */

   *y = temp;    /* put temp into y */

   return;

}

A pointer is a variable whose value is the address of another variable, i.e., direct address of the memory location. Like any variable or constant, you must declare a pointer before using it to store any variable address. The general form of a pointer variable declaration is

type *var-name;

Steps how to use Pointers

(a) We define a pointer variable,

(b) assign the address of a variable to a pointer and

(c) finally access the value at the address available in the pointer variable. This is done by using unary operator * that returns the value of the variable located at the address specified by its operand.

Recursion is the process of repeating items in a self-similar way. In programming languages, if a program allows you to call a function inside the same function, then it is called a recursive call of the function.

void recursion() {

   recursion(); /* function calls itself */

}

int main() {

   recursion();

}

The C programming language supports recursion, i.e., a function to call itself.

Recursive functions are very useful to solve many mathematical problems, such as calculating the factorial of a number, generating Fibonacci series, etc.

Example for recursion

#include <stdio.h>

int factorial(unsigned int i)

{

   if(i <= 1)

{      return 1;

   }

   return i * factorial(i – 1);

}

int  main() {

   int i = 15;

   printf(“Factorial of %d is %dn”, i, factorial(i));

   return 0;}

Strings are actually one-dimensional array of characters terminated by a nullcharacter ”. Thus a null-terminated string contains the characters that comprise the string followed by a null.

#include <stdio.h>

#include <string.h>

int main () {

   char str1[12] = “Hello”;

   char str2[12] = “World”;

   char str3[12];

   int  len ;

   /* copy str1 into str3 */

   strcpy(str3, str1);

   printf(“strcpy( str3, str1) :  %sn”, str3 );

   /* concatenates str1 and str2 */

   strcat( str1, str2);

   printf(“strcat( str1, str2):   %sn”, str1 );

   /* total lenghth of str1 after concatenation */

   len = strlen(str1);

   printf(“strlen(str1) :  %dn”, len );

   return 0;

}

A storage class defines the scope (visibility) and life-time of variables and/or functions within a C Program. They precede the type that they modify. We have four different storage classes in a C program –

The auto storage class is the default storage class for all local variables.

{

   int mount;

   auto int month;

}

The example above defines two variables with in the same storage class. ‘auto’ can only be used within functions, i.e., local variables.

The static storage class instructs the compiler to keep a local variable in existence during the life-time of the program instead of creating and destroying it each time it comes into and goes out of scope. Therefore, making local variables static allows them to maintain their values between function calls.

In C programming, when static is used on a class data member, it causes only one copy of that member to be shared by all the objects of its class.

The extern storage class is used to give a reference of a global variable that is visible to ALL the program files. When you use ‘extern’, the variable cannot be initialized however, it points the variable name at a storage location that has been previously defined.

The extern modifier is most commonly used when there are two or more files sharing the same global variables or functions

An operator is a symbol that tells the compiler to perform specific mathematical or logical functions. C language is rich in built-in operators and provides the following types of operators −

The following table shows all the arithmetic operators supported by the C language. Assume variable A holds 10 and variable B holds 20 then

The following table shows all the relational operators supported by C. Assume variable A holds 10 and variable B holds 20 then

Following table shows all the logical operators supported by C language. Assume variable A holds 1 and variable B holds 0, then −

Bitwise operator works on bits and perform bit-by-bit operation. The truth tables for &, |, and ^ is as follows −

The following table lists the assignment operators supported by the C language

Besides the operators discussed above, there are a few other important operators including sizeof and ? : supported by the C Language.

A function is a group of statements that together perform a task. Every C program has at least one function, which is main(), and all the most trivial programs can define additional functions.

A function declaration tells the compiler about a function’s name, return type, and parameters. A function definition provides the actual body of the function.

Defining a Function

The general form of a function definition in C programming language is as follows −

return_type function_name( parameter list ) {

   body of the function

}

A function definition in C programming consists of a function header and a function body. Here are all the parts of a function −

•        Return Type − A function may return a value. The return_type is the data type of the value the function returns. Some functions perform the desired operations without returning a value. In this case, the return_type is the keyword void.

•        Function Name − This is the actual name of the function. The function name and the parameter list together constitute the function signature.

•        Parameters − A parameter is like a placeholder. When a function is invoked, you pass a value to the parameter. This value is referred to as actual parameter or argument. The parameter list refers to the type, order, and number of the parameters of a function. Parameters are optional; that is, a function may contain no parameters.

•        Function Body − The function body contains a collection of statements that define what the function does.

Example

/* function returning the max between two numbers */

int max(int num1, int num2) {

   /* local variable declaration */

   int result;

   if (num1 > num2)

      result = num1;

   else

      result = num2;

   return result;

}

If a function is to use arguments, it must declare variables that accept the values of the arguments. These variables are called the formal parameters of the function.

Formal parameters behave like other local variables inside the function and are created upon entry into the function and destroyed upon exit.

While calling a function, there are two ways in which arguments can be passed to a function −