Algorithm: Step 1: START Step 2: READ A, B Step 3: sum ← A + B Step 4: WRITE sum Step 5: STOP Flowchart

The process of converting data item from one data type to another data type is called type casting.
Conversion rank procedure is:

Type casting can be classified into two types as:

1. Implicit Type Casting
2. Explicit Type Casting


1. Implicit Type Casting: If the operands are of different data types, the lower data type is automatically converted into the higher data type by the compiler before the operation proceeds.  Such conversion is known as implicit type casting.  Implicit type casting is also known as automatic type conversion.
In implicit type casting, the result is in higher data type and there is no loss of data.

Example: int i,j;
float p;
double d,r;
r= i*j + p/j +  p*d;
int*int + float/int + float *double
int + float + double
float + double
double

2.  Explicit Type Casting: Users can also be convert the data items from one data type to another data type.  Such conversion is known as explicit type casting.

For explicit type casting, the target data type placed within in parenthesis before the data item.

The general format of explicit type casting is:

Syntax: (TargetDataType) Expression;

Here,
Expression may be a constant, variable, or any expression.

In explicit type casting, there may be a loss of data which converting from higher data type into lower data types.

Example:

int x=14, y=3;
float z;

z = x/y; z = (float) x/y;

z = 14/3; z = 14.000000/3;
z = 4.000000; z = 4.666667

/* EXAMPLE PROGRAM FOR TYPE CASTING */

#include<stdio.h>
#include<conio.h>
main()
{
int x,y,z,total;
float avg;
clrscr();
printf("\nEnter Three Values:");
scanf("%d%d%d",&x,&y,&z);
total=x+y+z;
avg=(float)total/3;
printf("\nAverage Result:%f",avg);
}

malloc()		calloc()
malloc allocate the memory at runtime		calloc allocate the memory at runtime
The name malloc stands for memory allocation.		The name calloc stands for contiguous allocation.
malloc() takes one argument that is, number of bytes.		calloc() take two arguments those are number of blocks and size of each block.
malloc() initializes the allocated memory with garbage values.		calloc() initializes the allocated memory with 0 value.
Syntax : int * ptr = (casttype *) malloc(n * sizeof(int));	Syntax: int * ptr = (casttype *) calloc(n, sizeof(int));
Ex:  int n=5;                  10bytes	Ex:  int n=5;     2bytes     2bytes        2bytes          2bytes          2bytes
The malloc() function allocate single block of memory		The calloc() function allocate multiple blocks of memory

	STRUCTURE	UNION
Allocation of memory	Members of structure do not share memory. So A structure need separate memory space for all its members i.e. all the members have unique storage.	A union shares the memory space among its members so no need to allocate memory to all the members. Shared memory space is allocated i.e. equivalent to the size of member having largest memory.
Members access	Members of structure can be accessed individually at any time.	At a time, only one member of union can be accessed.
Keyword	To define Structure, ‘struct’ keyword is used.	To define Union, ‘union’ keyword is used.
Initialization	All members of structure can be initialized.	Only the first member of Union can be initialized.
Size	Size of the structure is > to the sum of the each member’s size.	Size of union is equivalent to the size of the member having largest size.
Syntax	struct struct_name { datatype member _1;datatype member _2; .................................datatype member_n; }struct_variable_name;	union union_name {datatype member_1; datatype member_2; ———-datatype member_n; }union_variable_name;
Change in Value	Change in the value of one member can not affect the other in structure.	Change in the value of one member can affect the value of other member.

ARRAY	POINTER
1. Array is a collection of homogeneous data elements that are stored in successive memory locations.	1. Pointer is a variable that holds address of another variable.
2. The general form of array declaration is : Syntax    :   Datatype ArrayName[size]; Example :  int x[10];	2. The general form of a pointer variable declaration is : Syntax    :   Datatype *PtrVaribale; Example :  int *ptr;
3. The general form of initializing a array is: Syntax   : Datatype Array[size]={List of values}; Example: int x[4] = {2,5,1,7};	3. The general form of initializing a pointer variable is: Syntax   :   PtrVariable = &Variable; Example:  int x, *p;                   p = &x;
4. For an array, compiler allocates memory space based on the size of the array. Example:   int x[5]; Here, compiler allocates 10 bytes of memory for the variable x.	4. For any type pointer variables compiler allocates only 2 bytes of memory. Example:  int *p;     char *q; For p compiler allocates 2 Bytes and for q also compiler allocates 2 Bytes memory.
5. sizeof(arrayname) gives the number of bytes of the memory occupied by the array.	5. sizeof(pointervaraible) returns only 2 bytes.
6. For arrays only static memory allocation is possible.	6. For pointer variables dynamic memory allocation is possible.
7. Arrays can’t be resized.	7. Pointer allocation can be resized using realloc() function.
8. It cannot be reassigned.	8. It can be reassigned.
9. /* Example Program */ #include<stdio.h> #include<conio.h> main() {      int x[5]={2,4,6,1,3},i;      clrscr();      printf(“\nArray Elements Are=”);      for(i=0;i<5;i++)      printf(“    %d”,x[i]); }	9. /* Example program for Pointer */ #include<stdio.h> #include<conio.h> main() {     int x = 10, *p=&x;     clrscr();     printf(“\nResult = %d”,*p); }