File

• A data file(or simply file) is a collection of logically related information.
• Data files can be accessed for the purpose of reading data from them and writing data back into them.
• The data read from the files are assigned to the variables in the program and similarly, the values of variables from the source program are written into the files.
• There are two ways in which the data files are accessed for either reading data from or writing data into them. They are :

1. Sequential Access(or linear) – from beginning to end of file.
2. Random Access(or direct) – directly pointing to the specified location in a file.

File Declaration

• Any file that is accessed for reading or writing purpose must be declared.
• The syntax – FILE *pointer_to_file;

Opening a File

• Before performing any operation, a data file must be opened.
• The function fopen() is used for opening a file.
• On Success, fopen() returns a file pointer. Otherwise, it returns NULL.

Access Modes

• File access modes indicate the purpose of the file being opened.
• A file can be opened for reading data from a file or for writing data into a file. Sometimes we may be adding data to the end of the already existing file.

Closing a File

• The files that are opened for reading or writing purpose must be closed.
• The fclose() is used for closing a file.
• int fclose(pointer_to_file);
• This closes the file pointed to by the file pointer.
• Once it is closed we can reuse the file pointer for opening other files.
• On success, fclose() returns 0. Otherwise, it returns EOF(End of File) value.

Writing Data to Files

• fprintf() – to write the formatted data to the file.
• fputc() – to print a single character to the file.
• fputs() – to write a string(or array of characters) to the file.

Reading Data from Files

• fscanf() – to read the formatted data from the file.
• fgetc() – to read a single character from the file.
• fgets() – to read a string from the file.

Random Access Files

• C provides a set of functions for writing or reading data to or from the data file randomly.
• fseek() – Repositions the file pointer of a stream.
• ftell() – Returns the current file pointer.
• rewind() – Takes the control back to the beginning of the file.

• fseek() function – The function fseek() sets the file pointer associated with a stream to a new position.
• int fseek(FILE *stream, long offset, int where);
• On success, the fseek() function (if the pointer is successfully moved) returns 0. On failure, fseek() returns a non-zero value.

• ftell() function – The ftell() function returns the current file pointer for stream.
• long ftell(FILE *stream);
• The value returned by ftell() can be used in a subsequent call to fseek()
• On success, ftell() returns the current file pointer position. Otherwise, it returns -1L and sets errno(a variable indicating the type of error) to a positive value.

<<Previous Post

• Preprocessor Directives – These are statements which begin with the # symbol placed in the first coloumn.
• They are placed before the function main().
• There will be no smicolon at the end of such statements.
• Three types -

1. Macro substitution directives
2. File inclusion directives
3. Conditional compilation directives

Macro Substitution

• This is a process of replacing an identifier of a C program by a constant or a symolic constant.
• This can be accomplished by the directive #define.

File Inclusion

• This is a process of inserting the external files containing functions or macro definitions into a C program.
• This process eliminates the job of rewriting the functions or macro definitions.

Conditional Compilation Directives

• C preprocessor provides a conditional compilation directive which is used to select alternate segments of code in a C program depending upon the condition.
• The #ifdef, #else, #elis, #endif directives are used for conditional compilation of the program. These are also used with the #define, #ifndef and #undef directives.

<<Previous Post

Next Post>>

Advantages

• To point to different data structures.
• Manipulation of data at different memory locations is easier.
• To achieve clarity and simplicity.
• More compact and efficient coding.
• To return multiple values via functions.
• Dynamic Memory Allocation.

Operations used with pointers

• The address operator – &(ampersand)
• The indirection operator – *(asterix)
• An address operator gives the address of a variable(not constants or expression); while the indirection operator gives the value of the variable that the pointer is pointing to.
• Both the pointer variable and the variable to which pointer points to, must be declared.
• Also, a pointer variable must be assigned the address of the declared variable before it is used in the program.

Pointer Dereferencing

• This is a process of referencing the contents of the variables using pointers, indirectly.
• Steps involved - Address of a variable, whose value is to be referenced is assigned to a pointer. Then, this pointer points to the value.

Operations on Pointers

• A pointer variable holds the address of the other variables. This address can be incremented or decremented.
• However, the pointer variables cannot be multiplied or divided.
• A pointer variable can be assigned the address of other variable.
• If two pointer variables are pointing to the object of the same data type, then they can be assigned.
• A pointer variable can be assigned a NULL value(NULL = 0).
• An integer value can be added to and subtracted from a pointer variable.
• One pointer variable can be subtracted from another pointer variable, if both are pointing to the elements of the same array.
• If two pointer variables are pointing to the objects of the same data type, then they can be compared with one another.

Pointer Initialization

• As ordinary variables are initialized within the declaration part of a program, the pointer variables can also be initialized by assigning the addresses of another variables that are used in the program.
• data_type *ptr_var = expression;
• A pointer can also be initialized by assigning a NULL value.

Pointers and Functions

• Like other parameters, pointers can also be passed to functions.
• This is carried out by the call-by-reference parameter passing mechanism.

Call-by-Reference

• This is a mechanism by which the pointers can be passed as arguements to the functions.
• Thus, the data items of the calling program can be assessed by the called program(function).
• No value is copied when the pointers are passed as arguements, as in the call-by-value method.
• Another important point is that if the values are changed in the functions, this will modify the original contents of the original parameters.
• In the calling program, the function is invoked with the function name and addresses of the actual parameters enclosed within the parantheses.
• function_name(&var1,&var2,…&varn);
• In the parameter list of the called program each and every formal parameter(pointers) must be preceded by an indirection operator(*).
• data_type function_name(*var1,*var2,…*varn);

Pointers and Arrays

• Pointers can be used with arrays for efficient programming.
• One-dimensional Arrays
• The name of an array itself designates some memory location and that location in main memory is the address of the very first element of the array.
• &aarray[0] or simply array.
• The addressof the i-th element of the array - &array[i-1] or (array+(i-i))

Dynamic Memory Allocation

• This is a process of dynamically allocating memory to any variable that is being used in your C program.
• When the program is terminated, the dynamically allocated memory is deallocated.
• malloc(), calloc(), free().
• malloc() – This function is used to allocate the memory in bytes.
• malloc(nob);
• free() – This function frees a block of allocated memroy.
• free(p);

<<Previous Post

Next Post>>

• Each and every structure must be defined and declared before it appear in a C program.
• The body of the structure is terminated by a semicolon.

struct employee
{
int emp_code;
char name[20];
float salary;
};

• The general form of declaring structure variables is :

structure_type varlist;

• A structure within another structure is called an embedded structure.
• A structure may completely be defined within the other structure.
• There may be separate strucutres.The embedded structure is declared first and the other structure is declared next.
• Like initialization of array elements, structure members can be initialized.
• Each member of a structure is accessed with the dot operator.
• The dot operator has the highest priority than any other operator of C, and it’s associativity is from left to right.

• Whenever the same structure is to be applied to a group of people, items or applications we will have to use an array of structures.

• typedef(for type definition) statement – enables the programmer to define an alternate term to the basic data types.

Syntax – typedef old_data_type new_data_type;

• A union is a collection of heterogeneous data elements. They are similar to structures.
• However, there is a difference in the way the structure members and union members are stored. Each member within a structure is asigned its own memory location. But the union members, all share a common memory location. Thus, unions are used to save memory.
• An inividual member of a union can be accessed using the dot operator or ->(arrow) operator.

<<Previous Post

Next Post>>

• String is a one-dimensional array of characters.
• Each one-dimensional character array(string) ends with a null character. So an n-character array contains (n+1) array elements.
• C language provides many string handling functions which are defined in the header file .
• Like a numeric array, character arrays must be declared before they appear in a C program.
• There is no change in the syntaxof declaring stings except the change in the data type(char).

Reading Strings

• scanf() with the %s format specification
• gets() function
• getchar() funcation

Writing Strings

• printf() with the %s format specification
• puts() function
• putchar() function

• A two-dimensional character array is an array of one-dimensional character arrays.
• This means that a two-dimensional character array consists of strings as its individual elements.
• Like two-dimensional numeric arrays, two-dimensional character arrays must be declared before they are used in the program and should also be initialized.

String Handling Functions

• C supports a number of string handling functions.
• These functions are defined in the header file <string.h>.

strcmp() function – This function compares two strings character by character(ASCII comparison) and returns one of the three values {-1,0,1}.
Syntax – strcmp(string1,string2);

strcpy() function – This function is used to copy one string to the other.
Syntax – strcpy(string1,string2);

strcat() function – This function is used to concatenate two strings. That is, it appends one string at the end of the specified string.
Syntax – strcat(string1,string2);

strlen() function – This returns the number of characters in the string(i.e. string lenght). Here, the string length does not include the NULL character.
Syntax – strlen(string);

strncmp() function – This compares the first n characters of two input strings.
Syntax – strncmp(string1,string2,n);

strncpy() function – This copies first n characters of the second string to the first string.
Syntax – strncpy(string1,string2,n);

strncat() function – This appends first n characters of the second string at the end of the first string.
Syntax – strncat(string1,string2,n);

strlwr() function – This function is used to convert any uppercase letters present in a string to its equivalent lowercase.
Syntax – strlwr(string);

strupr() function – It converts any lowercase letters that appear in the input string to the uppercase.
Syntax – strupr(string);

Implementation of String Functions

• String Concatenation – String concatenation is a process of appending one string to the end of another string.

1. Read two strings and call them as string1 and string2.
2. Traverse the first string to its end.
3. Attach the second string to the end of the first string.
4. Set the last character of the resultant string to a null character(\0).

char *stringcat (char str1[], char str2[])
{
int i, j, pos;
for (i=0;str1[i]!= ‘\0′; i++)
{
;
}
pos=i;
for (i=pos; str1[i]!= ‘\0′; i++)
{
str1[i] = str2[j++];
}
str1[i] = ‘\0′;
return (str1);
}

• String comparison – This is a process of comparing two strings to check whether they are equal or not.

1. Read two strings and call them as string1 and string2.
2. Find the length of each string.
3. Set the counter to zero.
4. Start comparing the first character of both strings and if they are equal then increment the counter and continue for the subsequent characters until the corresponding characters differ or till the end of the strings is reached.
5. Return zero, if they are equal; 1 if the string1 is greater than the second; and -1 the string1 is less than the string2.

int stringcomp (char str1[], char str2[], strlenght1, strlength2)
{
int i = 0, flag = 0;
while ((i < strlength1) && (i < strlength2))
{
if (str1[i] == str2[i])
{
i++;
continue;
}
if (str1[i] < str2[i])
{
flag = -1;
break;
}
if (str1[i] > str2[i])
{
flag = 1;
break;
}
}
return (flag);
}

• String length – This is a process of finding the number of characters present in a given string.

1. Read a string.
2. Set the counter to zero.
3. Start traversing the string character-by-character and increment the counter everytime a new character is encountered.
4. Repeat step 3, until all the characters are traversed in the string.

nt stringlen (char string[])
{
int i, length = 0;
for (i=0; string[i]!= ‘\0′;i++)
{
length = length + 1;
}
return (length);
}

<<Previous Post

Next Post>>

• Functions – A function is a set of instructions to carryout a particular task.
• The function, after it’s executions, returns a single value.
• Classified into standard functions and user-defined functions.

• Function Definition – Defining a function means writing an actual code for the function which performs a specific and identifiable task.
• Two ways – Non-ANSI style and ANSI style.
• Non-ANSI function definition -

type name_of_function(parameter_list)
parameter definition;
{
variable declaration; /*within the function*/
statement1;
statement2;
.
.
.
return(value_computed);
}

• ANSI style -

type name_of_the_function(parameter definition)
{
variable declaration; /*within the function*/
statement1;
statement2;
.
.
.
return(value_computed);
}

• ‘return‘ – It is a means of communication from the called function to the calling function.
• There may be one or more return statements.
• When a return statement is encountered, the control is transferred to the calling function.

• The point where the name of the function appears in any function is called function reference. This is also called as a function call.
• When a function is called in any function or a program the execution of the calling function temporarily suspends and the control transfers to the called function. After the required computations are made in the function, the control returns to the calling function along with the computed value.

• Arguements and Parameters – are the variables used in a program and a function respectively.

• Variables used in the function call are called arguements.
• These are written within the parantheses followed by the name of the function.
• They are also called actual parameters, as they are accepted in the main program(or a calling function).

• Variables used in the function definition are called parameters.
• They are also referred to as formal parameters, because they are not the accepted values.
• They receive the values from the calling function. The parameters must be written within the parantheses followed by the name of the function in the function definition.

• The number of arguements should be equal to the number of parameters.
• There must be 1 to 1 mapping between arguements and parameters, i.e they should be in the same order and should have the same data type.
• Same variables can be used as arguements and parameters.

Category of functions -

• arguements with return value
• no arguements, no return value
• arguements but no return value
• no arguements but return value

• An array name in C represents the address of the first element in that array. So, arrays are passed to functions as pointers.
• We can pass either an entire array as an arguement or it’s individual elements.

• Both the calling function and the called function are using their own variables. The existence of these variables is restricted to the calling function or to the called functions.This is known as scope of the variables.
• Based on this scope, the variables can be classified into – local variables and global variables.
• Variables whose existence is known to only to the main program or functions are called local variables.
• Variables whose existence is known to both the main() function as well as other functions are called global variables.
• Local variables are declared within the main program or a function. But the global variables are declared outside the main() and the other functions.

• Storage classes are used to define the scope(visibility) and the life-time of the variables and/or functions.
• Four storage classes in C – auto, static, extern, register.

• static Variables – These variables hold their values throughout the execution of a program.
• Two types – Internal static variables, External static variables.
• Internal static variables are declared inside a function.
• They are identical to automatic variables in the function scope except that they retain their values throughout the program.
• External static variables are declared outside of all functions including the mian() function.
• They are global variables but are declared with the keyword static.
• The external static variables cannot be used across multi-file program.
• Static variables are initialised only once during the compile-time.
• The initial values to be assigned must be always constants but not expressions.
• If nothing is initialized to a static variable, by default, it is assigned a zero.

• register Variables – Variables whose values are stored in the CPU registers.
• Since the values are stored in the CPU registers, they are accessed quickly and hence programs are executed faster.
• Like automatic variables, the register variables are also local variables.
• Declaring with the keyword register, it does not guarantee that they are actually register variables. It is valid only when the requested CPU register is available.

• Function declaration – means specifying the function as a variable depending on the return value.
• Functions may be written before or after the main(). If the functions are written before the main() then function declaration is not required. But, the functions which are written after the main() function would require function declaration.
• Two styles – Non-ANSI style and ANSI style.
• Non-ANSI style – type_of_return_value name_of_function();
• ANSI style – type_of_return_value name_of_function(dt1 p1,dt2 p2,…,dtn pn);

• The process of transmitting the values from one function to other is known as parameter passing.
• Two methods – call by value, call by reference.

• Call by value – When the values of the arguements are passed from a calling function to a called function, the values are copied into the called function.
• If any changes are made to the values in the called function, there will not be any change in the original values within the calling function.

• Call by reference – In this method, the actual values are not passed, instead their addresses are passed to a calling function. Here, no values are copied as the memory locations themselves are referenced.
• If any modification is made to the values in the called function, then the original values will get changed within the calling function.

• Recursion – is a technique that defines a function in terms of itself.
• A function which calls itself.
• Factorial calcualtion – coomon use of recursion.

<<Previous Post

Next Post>>

• An array can be defined as an ordered list of homogeneous data elements.
• These elements may be of type int, float, char or double.
• All these elemets are stored in consecutive memory locations.
• An array is described by a single name or an identifier.
• And each element in an array is referenced by a subscript(or an index) enclosed in a pair of square brackets.
• The subscript indicates the position of an individual data item in an array.
• The subscipt must be an unsigned positive integer.
• Because of these subscripts, sometimes an array is called as a subscripted variable.

• Arrays classified into – one-dimensional array and multi-dimensional arrays.
• The dimensionality of an array is determined by the number of subscripts present in the given array.
• An array must be declared before it appears in a C program. At the same time, the size of an array must be specified.

• One-dimensional array – This is a linear list of a fixed number of data items of the same type.
• Similar to a row or a coloumn matrix.
• Also called a single-dimensional array or a one-subscripted variable.
• Syntax – data-type arrayname[size];

• Subscript must be an unsigned positive integer constatnt or an expression.
• Subscript of subscript is not allowed.
• C does not perform bounds checking for an array.
• In C, the subscript value ranges from 0 to one less than the maximum size.

• The total amount of memory that can be allocated to a one-dimensional array is computed as -

Total size = size * [sizeof(data_type)];

• Initialization of a one-dimensional aray

Syntax – data_type array_name[size] = {element1,element2,…,elementn};

• Multi-dimensional arrays – If the number of subscripts is more than one then such arrays are called multi-dimensional arrays.
• Two-dimensional(2-D) array, three-dimensional(3-D) array, and so on.

• Two-dimensional array – It is an ordered table of homogeneous elements.
• Generally referred to a matrix of some rows and some coloumns.
• Also called a two-subscripted variable.
• Syntax – data_type array_name[rows][coloumns];
• Row-major order and Coloumn-major order.

• Initialization of a two-dimensional array

Syntax – data_type array_name[size1][size2]={e1,e2,…,en};

<<Previous Post

Next Post>>

• while-statement – This is used to execute a set of statements repeatedly as long as the specified condition is true.
• Referred to as pretest loop.
• Syntax -

while (logexp)
{
statement;
}

• do-while statement – This is used to execute a set of statements repeatedly until the logical test results in false.
• this is called the post-test loop. Because the test for repetition is made at the end of each pass.
• Syntax -

do
{
statement;
}
while (logexp);

• At least once, the body of do-while is executed.
• The body of do-while must contain either implicitely or explicitely statements to modify the variable involved in the logexp.

• for-statement – This statement is used when the programmer knows how many times a set of statements is executed.
• Syntax -

for (expression1;expression2;expression3)
{
statement;
}

• Nested-for statement – If there are many data items to be processed against a set of elements repeatedly, then a single for statement is not adequate. Then, we must use the nested-for loop.
• If one for statement is completely placed within the other, it is known as the nested-for statement.
• Syntax -

for(exp11;exp12;exp13)
{
for(exp21;exp22;exp23)
{
statement1;
statement2;
}
}

Jumps in loops -

1. break statement – This is used to teminate a loop and exit from a particular switch case label.
2. continue statement – This is used as the bypasser. The control does not come out of the loop, instead it skips the remaining statements within the body of that loop and transfers to the beginning of the loop.

<<Previous Post

Next Post>>

• Control structures – define the order of execution of statements.

• Conditional control statements – involves both decision making and branching.

1. if-statement.
2. if-else statement.
3. Nested-if-statement.
4. switch statement.

• if-statement – used to execute a statement or a set of statements conditionally.
• Also called a one-way branching.
• Syntax -

if (condition)
{
statement;
}

• if-else statement – The if statement is used to execute only one action. If there are two statements to be executed alternatively, then if-else statement is used.
• Two-way branching.
• Syntax -

if (condition)
{
statement1;
}
else
{
statement2;
}

• Nested-if statement – If there are more than two alternatives to select, then the nested-if statements are used.
• Enclosing an if statement within another if statement is called the nested-if statement.
• Syntax -

if (condition1)
{
if (condition2)
{
statement1;
}
else
{
statement2;
}
}
else if (condition3)
{
statement3;
}
else
{
statement4;
}

• There are many ways to nest one if-else within the other.

• switch statement – The switch statement provides a multiple way of branching.
• It allows the user to select any one of the several alternatives, depending on the value of an expression.
• Syntax -

switch (expression)
{
case label1 : block1;
break;
case label2 : block2;
break;
.
.
.
case labelmax : blockmax;
break;
case default : dblock;
break;
}

• The expression is of type int or char.
• Depending on the value of an expression, execution branches to a particular case label and then all the statements belonging to that case label are executed.
• The break statement indicates the end of a particular case label and thereby the switch statement is terminated.
• The case default is executed, when the value of an expression is not matched with any of the case labels.
• The semicolons should not be placed at the end of switch (expression).

• goto-statement – an unconditional control statement.
• To transfer the control from one point to another in a C program.
• Syntax -
  

  goto label;

• Forward jump and backward jump.
• Bachward jump will form a loop.
• The use of goto statement in a structured programming language like C should be avoided. Use if and only if it is unavoidable.
• The goto statement may create an infinite loop where the computer enters a permanent loop. The careful and cautious design would resolve such situations.
• A program may contain any number of goto statements.
• No two statements can have the same label.

<<Previous Post

Next Post>>

• An operator that acts upon only one operand is known as a unary operator.
• Egs – unary minus, logical NOT, bitwise complementation.

• Binary operators act upon two operands.
• Classified into four – arithmetic operators, logical operators, relational operators, bitwise operators.

• Arithmetic operators are used to perform basic arithmetic operations such as addition, subtraction, multiplication and division.
• An expression involving arithmetic operators is called an arithmetic expression.

• Increment operator – used to increment the value of an integer quantity by one.
• Represented by ‘++’.
• Decrement operator – used to reduce the value of an integer by one.
• Represented by ‘- -’.

Program 1

/*Program to illustrate the basic arithmetic operations*/
#include<stdio.h>
void main()
{
int n1,n2; /*variable declaration*/
int sum,diff,prod,quotient,remainder;
n1=5;
n2=3;
sum=n1+n2;
diff=n1-n2;
prod=n1*n2;
quotient=n1/n2;
remainder=n1%n2;
printf(“SUM = %d\n”,sum);
printf(“DIFFERENCE = %d\n”,diff);
printf(“PRODUCT = %d\n”,prod);
printf(“QUOTIENT = %d\n”,quotient);
printf(“REMAINDER = %d\n”,remainder);
}

Program 2

/*Program to illustrate the use of an increment operator*/
#include<stdio.h>
void main()
{
int a=3,b=6;
printf(“a = %d\n”,a++);
printf(“b = %d\n”,++b);
}

Program 3

/*Program to illustrate the use of a decrement operator*/
#include<stdio.h>
void main()
{
int m=6,n=8;
printf(“m = %d\n”,- -m);
printf(“n = %d\n”,n- -);
}

• Relational operators – used to compare two operands given in an expression.
• Result in either a TRUE(non-zero,1) or a FALSE(0) value.
• Six relational operators – <, <=, >, >=, ==, !=.
• A relational expression can be defined as a meaningful combination of operands and relational operators.

Program 4

/*Program to check whether given two integers are equal*/
#include<stdio.h>
void main()
{
int x=2,y=2;
if (x= =y)
printf(“x and y are equal\n”);
}

Program 5

/*Program to compare two values*/
#include<stdio.h>
void main()
{
float m=2.333, n=0.0232;
if (m>n)
printf(“m is greater than n\n”);
}

• Logical operators – This class of C operators is used to make decisions.
• AND, OR, NOT.
• The result of these operators is either TRUE or FALSE.
• The logical operators are used to connect one or more relational expressions.
• Expresions involving the logical operators are called the logical expressions.

Program 6

/*Program to illustrate the logical ANDing and ORing operations*/
#include<stdio.h>
void main()
{
int a,b,c;
a = 4;
b = 3;
c = a && b;
b = a || b || c;
a = a && b || c;
printf(“%d,%d,%d”,a,b,c);
}

• Bitwise operators – To perform the bitwise operations, C provides six bitwise operators.

1. & – Bitwise AND
2. | – Bitwise OR
3. ^ – Exclusive-OR(XOR)
4. ~ – 1′s complement
5. << – Left shifting of bits
6. >> – Right shifting of bits

Program 7

/*Program to illustrate the bitwise operators*/
#include<stdio.h>
void main()
{
unsigned int x,y;
x=128;
y=32;
x=x>>1;
printf(“After right-shifting by 1, x = %d\n”,x);
y=y<<2;
printf(“After left-shifting by 2, y = %d\n”,y);
}

• Conditional operator – This is used to test the relationship between two variables.
• It is used in conjunction with a relational expression.
• Syntax – <expression>?<value1>:<value2>;

Program 8

/*Program to illustrate the conditional operator*/
#include<stdio.h>
void main()
{
int a=4,b=5,result1,result2;
result1=a>b?a:b;
printf(“The result1 = %d\n”,result1);
result2=a<b?a:b;
printf(“The result2 = %d\n”,result2);
}

Special operators of C

• Comma operator
• sizeof() operator
• Address operator
• Dereferencing operator
• Dot operator
• Arrow operator

Program 9

/*Program to illustrate the use of the comma operator in inter-changing the values of two variables*/
#include<stdio.h>
void main()
{
int a,b,temp;
b=(a=20,a+10);
printf(“a = %d and b = %d(before)\n”,a,b);
temp=a,a=b,b=temp;
printf(“a = %d and b = %d(after)\n”,a,b);
}

• The sizeof() operator returns the size(i.e, number of bytes) of an operand.
• It is a function and therefore has to be written in lowercase letters.

Program 10

/*Program to illustrate the use of sizeof() operator*/
#include<stdio.h>
void main()
{
int x;
float y;
char ch=’y';
x=10;
y=1000;
printf(“size of x = %d\n”, sizeof(x));
printf(“size of y = %d\n”, sizeof(y));
printf(“size of ch = %d\n”, sizeof(ch));
printf(“size of double = %d\n”, sizeof(double));
}

Precedence, Associativity of all C operators – Table

• Shorthand assignment operators – a compact way of writing assignment statements in an expression.

Program 11

/*Program to illustrate the comapct representation of arithmetic operators*/
#include<stdio.h>
void main()
{
int x=3,y=4,z=1;
x+=y;
y-=x;
z*=x;
printf(“%d\n”,x);
printf(“%d\n”,y);
printf(“%d\n”,z);
}

• In some applications, we may often want to change the data type of the variables. This process is known as data type conversion.
• Also called type casting.
• Syntax – (data type)variable

• Preporcessor directives – C preprocessor is a collection of special statements called the preprocessor directives.
• The preprocessor directives are executed before the C program is compiled.
• Usually written at the beginning of the pogram. However, it is not mandatory.
• There is no semicolon at the end of the preprocessor directives.

Program 12

/*Program to illustrate the use of sqrt(),sin(),cos() and tan()*/
#include<stdio.h>
#include<math.h>
void main()
{
float x,y,sq,sinx,cosx,tanx;
x=4.0;
y=30.0;
sq=sqrt(x);
y=30*(3.142/180.0); /*convert to radians*/
sinx=sin(y);
cosx=cos(y);
tanx=tan(y);
printf(“Square root of x = %f\n”,sq);
printf(“Sine value of y = %f\n”,sinx);
printf(“Cosine value of y = %f\n”,cosx);
printf(“Tangent value of y = %f\n”,tanx);
}

Program 13

/*Program to illustrate the use of abs(),log10(),pow() & exp()*/
#include<stdio.h>
#include<math.h>
void main()
{
float x,y,xpy,lg,xp;
int z,az;
x=2.0;
y=3.0;
z=-4;
az=abs(z);
lg=log10(x);
xp=exp(y);
xpy=pow(x,y);
printf(“Absolute value of z = %d\n”,az);
printf(“Logarithm of x = %d\n”,lg);
printf(“e to the power y = %f\n”,xp);
printf(“x to the power y = %f\n”,xpy);
}

<<Previous Post

Next Post>>