You are on page 1of 81

Introduction to C Programming 1.In 1972, C was developed at Bell Laboratories by Dennis Ritchie.


C is a simple programming language with a relatively simple to understand syntax and few keywords. C is useless.C itself has no input/output commands, doesn't have support for strings as a fundamental data type. There is no useful math functions built in.


4.C requires the use of libraries as C is useless by itself. This increases the complexity of the C.The use of ANSI libraries and other methods,the issue of standard libraries is resolved.

C Programming :: A Quick Hellow World Program Let's give a simple program that prints out "Hello World" to standard out. We'll call our program as hello.c. #include <stdio.h> main() { printf("Hello, world!\n"); return 0; }

Explanation of The Above Code:

#include <stdio.h> -This line tells the compiler to include this header file for compilation.

What is header file?They contain prototypes and other compiler/preprocessor directive.Prototypes are also called the basic abstract function definitions. Some common header files are stdio.h,stdlib.h, unistd.h and math.h.

main()- This is a function, in particular it is the main block. { } - These curly braces are equivalent to the stating that "block begin" and "block end".These can be used at many places,such as switch and if statement. printf() - This is the actual print statement which is used in our c program fraquently.we have header file stdio.h! But what it does? How it is defined? return 0-What is this? Who knows what is this

Seems like trying to figure out all this is just way too confusing.

Then the return 0 statement. Seems like we are trying to give something back, and it gives the result as an integer. Maybe if we modified our

main function definition: int main() ,now we are saying that our main function will be returning an integer!So,you should always explicitly declare the return type on the function.

Let us add #include <stdlib.h> to our includes. Let's change our original return statement to return EXIT_SUCCESS;. Now it makes sense! printf always returns an int. The main pages say that printf returns the number of characters printed.It is good programming practice to check for return values. It will not only make your program more readable, but at the end it will make your programs less error prone. But we don't really need it in this particular case.So we cast the function's return to (void). fprintf,exit and fflush are the only functions where you should do this. What about the documentation? We should probably document some of our code so that other people can understand what we are doing. Comments in the C89 standard are noted by this: /* */. The comment always begins with /* and ends with */.

An Improved Code of The Above Example #include <stdio.h> #include <stdlib.h> /* Main Function

* Purpose: Controls our program, prints Hello, World! * Input: None * Output: Returns Exit Status */ int main() { (void)printf("Hello, world!\n"); return EXIT_SUCCESS; } Note: The KEY POINT of this whole introduction is to show you the fundamental difference between understandability and correctness. If you lose understandability in an attempt to gain correctness, you will lose at the end. Always place the understandability as a priority ABOVE correctness. If a program is more understandable in the end,the chances it can be fixed correctly will be much higher. It is recommend that you should always document your program. You stand less of a chance of screwing up your program later,if you try to make your program itself more understandable. The advantages of C In other words,for writing anything from small programs for personal amusement to complex industrial applications,C is one of a large number of

high-level languages designed for general-purpose programming. C has many advantages:

Before C,machine-language programmers criticized high-level languages because,with their black box approach,they shielded the user from the working details of all its facilities and the computer. To give access to any level of the computer down to raw machine language,however, C was designed and because of this, it is perhaps the most flexible high-level language. To organize programs in a clear,easy,logical way,C has features that allow the programmer.For example,C allows meaningful names for variables without any loss of efficiency, yet it gives a complete freedom of programming style,a set of flexible commands for performing tasks repetitively (for, while,do) and including flexible ways of making decisions. C is also succinct. It permits the creation of tidy and compact programs. This feature can be a mixed blessing, however, and the C programmer must balance readability and simplicity. C allows commands that are invalid in some other languages. This is no defect, but a powerful freedom which, when used with caution, makes many things easily possible. It does mean that there are concealed difficulties

in C, but if you write thoughtfully and carefully, you can create fast, efficient programs.

With C, you can use every resource of your computer offers. C tries to link closely with the local environment, providing facilities for gaining access to common peripherals like printers and disk drives.

The C Compilation Model

Creating, Compiling and Running Your Program Creating the program First create a file containing the complete program, such as the above example. You can use any ordinary editor to create the file. One such editor is

textedit which is available on most UNIX systems. The filename must have extension ``.c'' (full stop, lower case c), e.g. myprog.c or progtest.c. The contents must have to obey C syntax. For example, they might be as in the above example,starting with the line /* /* end of the program */. Compilation There are many C compilers are present around. The cc is being the default Sun compiler. The GNU C compiler gcc is popular and also available for many platforms. PC users may also be familiar with Borland bcc compiler. There are also C++ compilers which are usually denoted by CC (note upper case CC.For example Sun provides GNU and CCGCC. The GNU compiler is also denoted by the command g++ Other C/C++ compilers also exist. All the above compilers operate in essentially the share many common command line options and same manner. However, the best source of each compiler is through online manual pages of your system: e.g. man cc. In the basic discussions of compiler operation,for the sake of compactness,we will simply refer to the cc compiler -- other compilers can simply be substituted in place of cc until and unless otherwise stated. Your program simply invoke the command cc to

Compile . The command must be followed by the name of the (C) program you wish to compile it. The compilation command is: cc program.c where program.c is name of the file. If there are obvious errors in your program (such as mistypings, misspelling one of the key words or omitting a semi-colon), the compiler will detect it and report them. It may possible that the compiler cannot detect logical errors. If the compiler option -o is used : the file listed after the -oor when the compiler has successfully digested your program, the compiled version, or executable, is left in a file called a.out It is convenient to use a -o and filename in the compilation as in cc -o program program.c which puts the compiled program into the file program ( any file you name following the "-o" argument) instead of putting it in the file a.out . Running the program The next stage is to run your executable

program.You simply type the name of the file containing it, in this case program (or a.out),to run an executable in UNIX. This executes your program able to print any results to the screen. At this stage there may be run-time errors, such as it may become evident that the program has produced incorrect output or division by zero. If so, you must return to edit your program source, and compile it again, and run it again. C is a High Level Language C is also called as a high-level language. To give a list of instructions (a computer program) to a computer,the high-level computer language is used. The native language of the computer is a stream of numbers called machine level language. As you might expect, the action resulting from a single machine language instruction is very primitive, and many thousands of them can be required to do something like substantial. A high-level language provides a set of instructions you can recombine creatively and give to the imaginary black boxe of the computer. The high-level language software will then translate these high-level instructions into the low-level machine language instructions Characteristics of C

We briefly list some of C's characteristics that have lead to its popularity as a programming language and define the language. Naturally we will be studying many of these aspects throughout our tutorial.

Extensive use of function calls Small size Loose typing -- unlike PASCAL Structured language Low level (BitWise) programming readily available Pointer implementation - extensive use of pointers for memory, array, structures and functions.

C has now become a widely used professional language for various reasons.

It It It It

has high-level constructs. produces efficient programs. can handle low-level activities. can be compiled on a variety of computers.

The main drawback of c is that it has poor error detection which can make it off putting to the beginner. However diligence in this matter can pay off handsomely since having learned the rules of the C we can break them. Not all languages allow this. This if done carefully and properly leads to the power of C programming.

C Program Structure A C program basically has the following form:

Preprocessor Commands Function prototypes -- declare function types and variables passed to function. Type definitions Variables Functions

We must have a main() function C assumes that function returns an integer type,if the type definition is omitted. NOTE: This can be a source of the problems in a program /* Sample program */ main() { printf( ``I Like C \n'' ); exit ( 0 ); } NOTE: 1. printf is a standard C function -- called from main. 2. C requires a semicolon at the end of the every statement. 3. \n signifies newline. Formatted output -- more later.

4. exit() is also a standard function that causes the program to terminate. Strictly speaking it is not needed here as it is the last line of main() and the program will terminate anyway.

Variables in C C has the following simple data types

Variables in C 1. Variables in C are memory locations with help of which we can be assigned values and are given names . 2. To store data in memory for later use,we use variables. 3. In C, a variable must have to be declared before it can be used. 4. You can declare Variables at the start of any block of code, but most are found at the start of each function. 5. Most local variables are destroyed on return from that function and created when the

function is called. 6. A declaration begins with the type, followed by the name of one or more than one variables.
The following code describe the declaration of variable:

int main() { int a; char b; return 0; }

C keeps a small set of keywords for its own use only.These keywords are given below: auto brea case k enum char const exter float n contin defaul do ue t for goto if stati c

doubl else e int long

regist retur short er n

signed sizeof

struc switc typed unsign union void t h ef ed

volatil whil e e

Identifiers in C Identifiers" or "symbols" are the names you supply for variables, types,labels, and functions in your

program. Identifier names must differ in case and spelling from any keywords. You cannot use keywords as the identifiers; they are reserved for special use only. You create an identifier by specifying it in the declaration of a variable,function,or type. In this example which is given below result is an identifier for an integer variable, and printf and main are identifier names for functions. Identifiers provide names for the given language elements:
o o o o o o o o

Functions Function parameters Macros and macro parameters Type definitions Objects Labels Enumerated types and enumerators Structure and union names

#include <stdio.h> int main() { int result; if ( result != 0 ) printf_s( "Bad file handle\n" ); }

Variable declarations Variables are of three different types which are as follows:
1. 2. 3.

Global Variable Local Variable Static Variable Global Variable: These variables can be accessed by any function of the program. By associating memory locations with variable names,they are implemented. If the function is recalled,they do not get recreated . Declare it outside of all the functions if you want to declare a global variable. The function will use the variable that was declared within it and ignore the global one,if a variable of the same name is declared both within a function and outside of it. Local Variable: Inside the specific function that creates them,these variables only exist. They are unknown to to the main program and to the other functions. In this case,they are normally implemented using a stack. Local variables cease to exist once if the function that created them is completed. Each time a function is executed or called,they are recreated. Variable declarations show up in three places:

Outside a function. These declarations declare global variables which are visible throughout the program (i.e. they have global scope). Use of global variables is always a big mistake. In the header of a function in the argument list . These variables are the parameters to the function. They are only visible inside the function body and their local scope), exist only from when the function is called to when the function returns (bounded extent---note that this is different from what happens in some garbage-collected languages like Scheme), and get their initial values from the arguments to the function when it is called. At the start of any block delimited by curly braces only. Such variables are exist only when the containing function is active (bounded extent) and visible only within the block (local scope again). The convention in C is generally to declare all such local variables at the top of a function; this is different from the convention in C++ or Java, which encourage variables to be declared when they are first time used

The following program demonstrate the use of global and local variables.

#include <stdio.h> int counter = 0; /* global because we are outside all blocks.*/ int func(void); main() { counter++; /* global because it has not been declared within this block */ printf("counter is %2d before the call to func\n", counter); func(); /* call a function. */ printf("counter is %2d after the call to func\n", counter); } int func(void) { int counter = 10; /* local variable because it has declared within this block */ */ printf("counter is %2d within func\n", counter); }

Using static variables Another important feature of the variable scoping is the static variable. In a local function scope,a static variable exists only , but it does not lose its value when program execution leaves this scope. Consider the example which is given below:

#include <stdio.h> main() { Test(); } function Test() { int a = 0; printf("a is %d within func\n", a) a++; } Since every time the function is called it sets a to 0 and prints "0",this function is quite useless . The a+ + which increments the variable serves no purpose since as soon as the function exits then a variable disappears. The a variable is declared static to make a useful counting function which will not lose track of the current count: #include <stdio.h> main() { Test(); } function Test() { static int a = 0; printf("a is %d within func\n", a) a++; }

Basic types There are 4 basic types of variable in C; they are: char, int, double and float Type name char Meaning The most basic unit addressable by the machine; typically a single octet. This is an integral type. The most natural size of integer for the machine; typically a whole 16, 32 or 64 bit addressable word. A single-precision floating point value. A double-precision floating point value.

int float double

Operators in C Overview of the C Operators The C operators fall into the following categories:

Postfix operators, which follow a single operand only. Unary prefix operators, which precede with a single operand. Binary operators, which take two operands and perform a variety of logical and arithmetic operations. The conditional operator (a ternary operator), which takes three operands and evaluates either

the second or third expression, depending on the evaluation of the first expression only. Assignment operators, which only assign a value to a variable. The comma operator, which gives guarantees left-to-right evaluation of comma-separated expressions.

To create more complex expressions,variables and constants can be used in conjunction with C operators. The following tables describes different operators available in c Operator Example Description/Meaning () [] -> . f() a[10] Function call Array reference

<S->A td Structure and union member <> selection s.a Structure and union member selection Value of a Negative of a Reference to object at address a Address of a One's complement of a The value of a after

+ [unary] +a - [unary] * [unary] -a *a

& [unary] &a ~ ++ ~a ++a

[prefix] ++ [postfix] -[prefix] -[postfix] sizeof sizeof a++ -a a-

increment The value of a before increment The value of a after decrement The value of a before decrement

sizeof (t1) Size in bytes of object with type t1 sizeof e Size in bytes of object having the type of expression e a plus b a minus b a times b a divided by b Remainder of a/b a, right-shifted b bits a, left-shifted b bits 1 1 1 1 1 if if if if if a a a a a < b; 0 otherwise > b; 0 otherwise <= b; 0 otherwise >= b; 0 otherwise equal to b; 0 otherwise

a+b + [binary] a-b - [binary] a*b * [binary] a/b /% a%b >> << < > <= >= == != a >> b a << b a a a a a a <b >b <= b >= b == b != b

1 if a not equal to b; 0 otherwise Bitwise AND of a and b Bitwise OR of a and b

& [binary] a & b | a|b


Bitwise XOR (exclusive OR) of a and b Logical AND of a and b (yields 0 or 1) Logical OR of a and b (yields 0 or 1) Logical NOT of a (yields 0 or 1) Expression e1 if a is nonzero; Expression e2 if a is zero a, after b is assigned to it a plus b (assigned to a) a minus b (assigned to a) a times b (assigned to a) a divided by b (assigned to a) Remainder of a/b (assigned to a) a, right-shifted b bits (assigned to a) a, left-shifted b bits (assigned to a) a AND b (assigned to a) a OR b (assigned to a) a XOR b (assigned to a) e2 (e1 evaluated first)

&& || !

a && b a || b !a


a ? e1 : e2

= += -= *= /= %= >>= <<= &= |= ^= ,

a=b a += b a -= b a *= b a /= b a %= b a >>= b a <<= b a &= b a |= b a ^= b e1,e2

Precedence of C Operators

Category Postfix Unary Multiplicative Additive Shift Relational Equality Bitwise XOR Bitwise OR Logical AND Logical OR Conditional Assignment Comma

Operator () [] -> . ++ - -

Associativity Left to right

+ - ! ~ ++ - - (type) Right to left * & sizeof */% +<< >> < <= > >= == != ^ | && || ?: Left to right Left to right Left to right Left to right Left to right Left to right Left to right Left to right Left to right Left to right Right to left

Bitwise AND &

= += -= *= /= %= Right to left >>= <<= &= ^= |= , Left to right

Branching Statement in C Branching The C language programs follows a sequential form of execution of statements. Many times it is required

to alter the flow of sequence of instructions. C language provides statements that can alter the flow of a sequence of instructions. These statements are called as control statements. To jump from one part of the program to another,these statements help. The control transfer may be unconditional or conditional. Branching Statemnt are of following categories:
1. 2. 3. 4. 5.

If Statement The If else Statement Compound Relational tests Nested if Statement Switch Statement

If Statement If statement is the simplest form of the control statement. It is very frequently used in allowing the flow of program execution and decision making. The If structure has the following syntax if(condition) statement; The command says that if the condition is true then perform the following statement or If the condition is fake the computer skips the statement and moves on to the next instruction in the program

The following program calculate the absolute value of an integer using if statement: Calculate the absolute value of an integer */ # include < stdio.h > //Include the stdio.h file void main ( ) // start of the program { int numbers; // Declare the variables printf ("Type a number:"); // message to the user scanf ("%d", & number); // read the number from standard input if (number < 0) // check whether the number is a negative number number = - number; // If it is negative then convert it into positive. Printf ("The absolute value is % d \n", number); // print the value }

The If else Statement The if else is actually just an extension of the general format of if statement. If the result of the condition is true, then program statement 1 is executed else program statement 2 will be executed. The syntax of the If else statement is as follows: If (condition) Program statement 1;

Else Program statement 2;

The following program find whether a number is negative or positive using if statement: #include < stdio.h > //include the stdio.h header file in your program void main ( ) // Start of the main { int num; // declare variable num as integer printf ("Enter the number"); //message to the user scanf ("%d", &num); // read the input number from keyboard if (num < 0) // check whether number is less than zero. Printf ("The number is negative") // If it is less than zero then it is negative. Else // else statement. Printf ("The number is positive"); //If it is more than zero then the given number is positive. }

Compound Relational tests To perform compound relational tests,C language provides the necessary mechanisms. A compound relational test is simple one or more simple relational tests joined together by either the the logical OR operators or logical AND. These operators are

represented by character pairs && // respectively. To form complex expressions in C,the compound operators can be used. The syntax of the Compound Relational tests is as follows: a> if (condition1 && condition2 && condition3) b>if (condition1 // condition2 // condition3)

Nested if Statement The if statement may itself contain another if statement is called as nested if statement. The syntax of the Nested if Statement is as follows if (condition1) if (condition2) statement-1; else statement-2; else statement-3;

The following example print the given numbers along with the largest number using nested if statement. #include < stdio.h > //includes the stdio.h file to your program main ( ) //start of main function { int a,b,c,big; //declaration of variables printf ("Enter three numbers"); //message to the

user scanf ("%d %d %d", &a, &b, &c); //Read variables a,b,c, if (a>b) // check whether a is greater than b if true then if(a>c) // check whether a is greater than c big = a ; // assign a to big else big = c ; // assign c to big else if (b>c) // if the condition (a>b) fails check whether b is greater than c big = b ; // assign b to big else big = c ; // assign C to big printf ("Largest of %d,%d&%d = %d", a,b,c,big); } //print the given numbers along with the largest number.

Switch Statement The switch-case statement is a multi-way decision making statement. Unlike the multiple decision statement that can be created using if-else, the switch statement evaluates the conditional expression and tests it against the numerous constant values.During execution,the branch corresponding to the value that the expression matches is taken. The value of the expressions in a switch-case statement must have to be an ordinal type i.e. integer, char, short, long, etc.Double and Float are

not allowed. The syntax of switch statement is as follows : switch( expression ) { case constant-expression1: statements1; [case constant-expression2: statements2;] [case constant-expression3: statements3;] [default : statements4;] } O/P: #include<stdio.h> main() { int n=7; switch(n) { case 0: printf("You typed zero.\n"); break; case 3: case 5: case 7: printf("n is a prime number\n"); break; case 2: printf("n is a prime number\n"); case 4: case 6: case 8: printf("n is an even number\n");

break; case 1: case 9: printf("n is a perfect square\n"); break; default: printf("Only single-digit numbers are allowed\n"); break; } }

Looping Statement in C Looping By using special loop keywords,you can loop (jumping for those assembly junkies) through your code. These include following categories:
1. 2. 3.

for loop while loop do while.

For Loop The for statement allows for the controlled loop. The syntax for for loop is as follows: for (start condition; continue condition; reevaluation) program statement;

The foollowing program shows the use of for loop which prints number from 0 to 10 * Sample program using a for statement */ #include <stdio.h> int main(void) { int count; for (count = 1; count <=10; count = count + 1) printf("%d", count); printf(\n); return 0; } O/P: 1 2 3 4 5 6 7 8 9 10

While Loop For repeating C statements whiles a condition is true,the while provides a the necessary mechanism. The syntax for while loop is as follows: while (condition) program statement; The foollowing program shows the use of while loop

which prints number from 0 to 10 /* Sample program including the while loop */ #include <stdio.h> int main(void) { int loop = 0; while (loop <=10) { printf("%d", loop); ++loop } return 0; }

The do while statement The do {} while statement allows a loop to continue whilst a condition evaluates as TRUE (non-zero value). The loop will exacute at least once The syntax is as follows do { /* do stuff */ } while (statement);

The following program reverse a number using do while loop /* Demonstration of the do..while loop */ #include <stdio.h> int main(void) { int value, r_digit; printf(Enter a number to be reversed.\n); scanf(%d, &value); do { r_digit = value % 10; printf("%d", r_digit); value = value / 10; } while (value != 0); printf(\n); return 0; }

Difference between while and do while loop The do statement is similar to the while statement except that its termination condition is at the end of the body of the loop only. Thus, you want to use a do statement,if you want to perform the body of the loop at least once, regardless of the condition.

C Storage Class Storage Class Storage classes include following categories:

1. 2. 3. 4.

auto extern register static.

auto The auto keyword is used to place the specified variable into the stack area of memory. In most variable declaration,this is usually implicit one, e.g. int i; extern The extern keyword is used to specify variable access the variable of the same name from some other file. In modular programs,this is very useful for sharing variables. register The register keyword gives suggest to the compiler to place the particular variable in the fast register

memory located directly on the CPU. Most compilers these days (like gcc) are so smart that suggesting registers could actually make your program more slower. static It is also used to declare the variables to be private to a certain file only when declared with global variables. static can also be used with functions, making those functions visible only to file itself.The static keyword is used for extending the lifetime of a particular variable. The variable remains even after the function call is long gone (the variable is placed in the alterable area of memory),if you declare a static variable inside a function,. The static keyword can be overloaded.

Functions in C What is a Function? A function is a block of statement that has a name and it has a property that it is reusable i.e. it can be executed from as many different points in a C Program as required. A function is a self contained block of statements that perform a coherent task of the same kindFunction helps to groups a number of program statements into a unit and gives it a name. This unit can be invoked from the other parts of a program.It

is not possible by computer program to handle all the tasks by it self. Instead its requests other program like entities - called functions in C - to get its tasks done. In a C Program,the name of the function is unique and is Global. It meams that a function can be accessed from any location with in a C Program.when the function is called,we pass information to the function called arguments specified.And the function either returns some values to the point it was called from or returns nothing Structure of a Function There are two main parts of the functions. The function header and the function body. The following syntax shows th syntax of using function in c: return_ data_type function name (arguments, arguments) data _type _declarations of arguments; { function body }

Function Header int sum(int x, int y) It has three main parts The function name i.e. sum 2. The parameters of the function enclosed in the paranthesis
1. 3.

Return value type of the function i.e. int

Function Body What ever is written with in { } is the body of the function. The following example shows the use of functions which prints factorial of a number: * Program to calculate a specific factorial number */ #iinclude <stdio.h> void calc_factorial (int); // ANSI function prototype void calc_factorial (int i) { int I, factorial_number = 1; for (I=1; I <=n; ++i) factorial_number *= I; printf("The factorial of %d is %d\n", n,

factorial_number); } int main(void) { int number = 0; printf("Enter a number\n"); scanf("%d", &number); calc_factorial (number); return 0; }

The C Preprocessor

The C Preprocessor is a separate step in the compilation process, but not part of the compiler. C Preprocessor is just a text substitution tool and we'll refer to the C Preprocessor as the CPP.

The C Preprocessor

All preprocessor lines always begin with #. This listing is from Weiss pg. 104. The unconditional directives are as follows:

o o

#define - Define a preprocessor macro #include - Insert a particular header from another file #undef - Undefine a preprocessor macro

The conditional directives are as follows:

o o o o o o

#ifndef - If this macro is not defined #ifdef - If this macro is defined #if - Test if a compile time condition is true #elif - #else an #if in one statement #else - The alternative for #if #endif - End preprocessor conditional

Other directives include:


## - Token merge, creates a single token from two adjacent ones # - Stringization, replaces a macro parameter with a string constant

Some examples of the above is given below: #define MAX_ARRAY_LENGTH 20 The above code will tell the CPP to replace instances of MAX_ARRAY_LENGTH with 20. To increase readability,use #define for constants. #include <stdio.h> #include "mystring.h"

The above code tells the CPP to get stdio.h from System Libraries and add the text to this file. The next line tells CPP to get mystring.h from the local directory and then add the text to the file. #undef MEANING_OF_LIFE #define MEANING_OF_LIFE 42

The above code tells the CPP to undefine MEANING_OF_LIFE and define it for 42. #ifndef IROCK #define IROCK "You wish!" #endif

The above code tells the CPP to define IROCK only if IROCK isn't defined already. #ifdef DEBUG /* Your debugging statements here */ #endif

Thed above code tells the CPP to do the following

statements if DEBUG is defined.If you pass the -DDEBUG flag to gcc,this is useful .

Input/Output Functions in C The Standard Input Output File To perform,input and output to files or the terminal,UNIX supplies a standard package.To use them,this contains most of the functions which will be introduced in this section,along with definitions of the datatypes required.Your program must include these definitions by adding the line to use these facilities. #include <stdio.h> near start of the program file. If you do not do this, the compiler may complain about undefined datatypes or functions. Character Input / Output If you will not press the return key then they'll not start reading any input, and they'll not print characters on the terminal until there is a whole line to be printed. This is the lowest level of output and input. It provides very precise control, but is usually too fiddly to be useful also. Most computers perform buffering of inputs and outputs. These include :
1. 2.

getchar putchar

getchar getchar always returns the next character of keyboard input as an int. The EOF (end of file) is returned,if there is an error . It is usual to compare this value against EOF before using it. So error conditions will not be handled correctly,if the return value is stored in a char, it will never be equal to EOF. The following program is used to count the number of characters read until an EOF is encountered. EOF can be generated by typing Control - d. #include <stdio.h> main() { int ch, i = 0; while((ch = getchar()) != EOF) i ++; printf("%d\n", i); }

putchar putchar puts its character argument on the standard output (usually the screen). The following example program converts any typed input into capital letters.It applies the function toupper from the character conversion library ctype.h to each character in turn to do this.

#include <ctype.h> /* For definition of toupper */ #include <stdio.h> /* For definition of getchar, putchar, EOF */ main() { int ch; while((ch = getchar()) != EOF) putchar(toupper(ch)); } Formatted Input / Output These includes following: 1.printf 2.scanf

printf This offers more structured output than the putchar. Its arguments are, in order; a control string, which controls what get printed, followed by a list of values to be substituted for entries in the control string. The prototype for the printf() is:

int printf(const char *format, ...);

To print,printf takes in a formatting string and the actual variables . An example of printf is: int x = 5; char str[] = "abc"; char c = 'z'; float pi = 3.14; printf("\t%d %s %f %s %c\n", x, str, pi, "WOW", c); With the use of the formatting line,you can format the output.You can change how the particular variable is placed in output,by modifying the conversion specification, . For example printf("%10.4d", x); The . allows for the precision.To floats as well,this can be applied.The number 5 is on the tenth spacing as the number 10 puts 0005 over 10 spaces. You can also add - and + right after % to make the number explicitly output as +0005. Note that the value of x does not actually change. In other words,you will not get output using %-10.4d will not output -0005. %e is useful for outputting floats using the scientific notation. %le for doubles and %Le for the long doubles. To grab things from input,scanf() is used. Beware though, scanf isn't greatest function that C has to offer. Some people brush off the scanf as a broken function that shouldn't be used often. The prototype for scanf is:

Last example will create a rectangle with rounded corner: int scanf( const char *format, ...); To read of data from the keyboard,scanf allows formatted . Like printf it has a control string,followed by the list of items to be read. However scanf wants to know the address of items to be read, since it is a function which will change that value. Therefore the names of variables are preceeded by the & sign. Character strings are an exception to this. Since a string is already a character pointer, we give the names of the string variables unmodified by a leading &. Control string entries which match values to be read are preceeded by the percentage sign in a similar way to their printf equivalent. Looks similar to printf, but doesn't completely behave like the printf does. Take the example: scanf("%d", x); For grabbing things from input. Beware though, scanf isn't the greatest function that C has to offer,scanf() is used. The following is the example which shows the use of scanf: int x, args; for ( ; ; ) { printf("Enter an integer bub: "); if (( args = scanf("%d", &x)) == 0) { printf("Error: not an integer\n"); continue; } else {

if (args == 1) printf("Read in %d\n", x); else break; } }

File I/O Functions in C C File Handling - File Pointers Use a new datatype called a file pointer to with C files . This type is written as FILE *, and defined within stdio.h. A file pointer called output_file is declared in a statement is as follows: FILE *output_file;

Function Name fopen() fclose getc() putc() fprintf() fscanf()

Operation Creates a new file for use Opens a new existing file for use Closes a file which has been opened for use Reads a character from Writes a character to a file Writes a set of data values to a file Reads a set of data values from a

file getw() putw() fseek() ftell() rewind() Reads a integer from a file Writes an integer to the file Sets the position to a desired point in the file Gives the current position in the file Sets the position to the begining of the file

Opening a file pointer using fopen() To open streams,fopen() is used.For opening files for input, this is most often used. Before it can access it,your program must open a file . This function returns the required file pointer. The value NULL will be returned,if the file cannot be opened for any reason. fopen's prototype is as follows: FILE *fopen (const char *path, const char *mode); fopen takes in the path to the file as well as the mode and to open the file with. Take for the following example: iFILE *Fp; Fp = fopen("/home/johndoe/input.dat", "r"); For reading,this will open the file in /home/johndoe/input.dat . You will usually use fopen as given below: if ((output_file = fopen("output_file", "w")) ==

NULL) fprintf(stderr, "Cannot open %s\n", "output_file");

fopen takes two arguments, both are strings, the first is the name of the file to be opened, the second is an access character, which is usually one of the following:
1. 2. 3. 4. 5.

"r"-Opening the file for reading "a"-Opening the file for appending "w"-Opening the file for writing "w+"-open for the writing and reading (existing file will be overwritten) "r+"-open for the reading and updating (file must already exist) "a+"-open for the appending and reading (file may or may not exist)


The following code fragmentis used to get the text from the first <title> element:

FILE *output_file;

Closing a file pointer using fclose() You would use fclose() to close the stream, . The prototype for fclose is given below: int fclose( FILE *stream );

File I/O :: fgets()

The alternatives to scanf/fscanf is fgets. The prototype is as follows: char *fgets(char *s, int size, FILE *stream); fgets stores it into *s pointer and reads in size - 1 characters from the stream. The string is always automatically null-terminated. If it reaches an EOF or newline,fgets stops reading in characters.

File I/O :: sscanf() The sscanf library call is handy to scan a string for a format.The prototype is as follows: int sscanf(const char *str, const char *format, ...); sscanf takes a character pointer instead of a file pointer and works much like fscanf. Instead of scanf/fscanf,using the combination of fgets/sscanf you can avoid the "digestion" problem (or bug, depending on who you talk to :)

File I/O :: fprintf() It is sometimes useful also to output to the different streams. fprintf() allows us to do exactly the same thing The prototype for fprintf is as follows: int fprintf(FILE *stream, const char *format, ...); fprintf takes in a special pointer called a file pointer, signified by the FILE *. It then accepts argument and

a formatting string and. The only difference between printf and fprintf is that fprintf can redirect output to a particular stream. These streams can be stderr,stdout,or a file pointer. More on the file pointers when we get to fopen. An example is given below: fprintf(stderr, "ERROR: Cannot malloc enough memory.\n"); This output the error message to standard error.

File I/O :: fscanf() fscanf() is basically a streams version of the scanf. The prototype for fscanf is as follows: int fscanf( FILE *stream, const char *format, ...); File I/O :: fflush() If the program crashes, sometimes the stream isn't written. You can do this by using fflush() function. Sometime it is necessary to forcefully flush a buffer to its stream. The prototype for fflush is as follows: int fflush(FILE *stream); Not very difficult to use, specify the stream to fflush. The program which is given below displays use of a file operations. The the program writes it and data enter through the keyboard. Character by character, to file input. The end of the data is indicated by entering an EOF character, which is control-z. the file input is closed at this signal only.

#include< stdio.h > main() { file *f1; printf("Data input output"); f1=fopen(Input,w); /*Open the file Input*/ while((c=getchar())!=EOF) /*get a character from key board*/ putc(c,f1); /*write a character to input*/ fclose(f1); /*close the file input*/ printf("\nData output\n"); f1=fopen(INPUT,r); /*Reopen the file input*/ while((c=getc(f1))!=EOF) printf("%c",c); fclose(f1); } Pointers in C What is Pointer? In c,a pointer is a variable that points to or references a memory location in which data is stored. In the computer,each memory cell has an address that can be used to access that location so a pointer variable points to a memory location we can access and change the contents of this memory location via the pointer. Pointer declaration: A pointer is a variable that contains the memory

location of another variable in shich data is stored. Using pointer,you start by specifying the type of data stored in the location. The asterisk helps to tell the compiler that you are creating a pointer variable. Finally you have to give the name of the variable. The syntax is as shown below. type * variable name

The following example illustrate the declataion of pointer variable int *ptr; float *string;

Address operator: Once we declare a pointer variable then we must point it to something we can do this by assigning to the pointer the address of the variable you want to point as in the following example: ptr=&num; The above code tells that the address where num is stores into the variable ptr. The variable ptr has the value 21260,if num is stored in memory 21260 address then The following program illustrate the pointer declaration

/* A program to illustrate pointer declaration*/ main() { int *ptr; int sum; sum=45; ptr=&sum printf ("\n Sum is %d\n", sum); printf ("\n The sum pointer is %d", ptr); }

Pointer expressions & pointer arithmetic: In expressions,like other variables pointer variables can be used. For example if p1 and p2 are properly initialized and declared pointers, then the following statements are valid. y=*p1**p2; sum=sum+*p1; z= 5* - *p2/p1; *p2= *p2 + 10; C allows us to subtract integers to or add integers from pointers as well as to subtract one pointer from the other. We can also use short hand operators with pointers p1+=; sum+=*p2; etc., By using relational operators,we can also compare pointers like the expressions such as p1 >p2 , p1==p2 and p1!=p2 are allowed.

The following program illustrate the pointer expression and pointer arithmetic /*Program to illustrate the pointer expression and pointer arithmetic*/ #include< stdio.h > main() { int ptr1,ptr2; int a,b,x,y,z; a=30;b=6; ptr1=&a; ptr2=&b; x=*ptr1+ *ptr2 6; y=6*- *ptr1/ *ptr2 +30; printf("\nAddress of a +%u",ptr1); printf("\nAddress of b %u",ptr2); printf("\na=%d, b=%d",a,b); printf("\nx=%d,y=%d",x,y); ptr1=ptr1 + 70; ptr2= ptr2; printf("\na=%d, b=%d,"a,b); }

Pointers and function: In a function declaration,the pointer are very much used . Sometimes,only with a pointer a complex function can be easily represented and success. In a function definition,the usage of the pointers may be classified into two groups.

Call by reference

2.Call by value. Call by value: We have seen that there will be a link established between the formal and actual parameters when a function is invoked. As soon as temporary storage is created where the value of actual parameters is stored. The formal parameters picks up its value from storage area the mechanism of data transfer between formal and actual parameters allows the actual parameters mechanism of data transfer is referred as call by value. The corresponding formal parameter always represents a local variable in the called function. The current value of the corresponding actual parameter becomes the initial value of formal parameter. In the body of the actual parameter,the value of formal parameter may be changed. In the body of the subprogram,the value of formal parameter may be changed by assignment or input statements. This will not change the value of the actual parameters. /* Include< stdio.h > void main() { int x,y; x=20; y=30; printf("\n Value of a and b before function call =%d %d",a,b);

fncn(x,y); printf("\n Value of a and b after function call =%d %d",a,b); } fncn(p,q) int p,q; { p=p+p; q=q+q; }

Call by Reference: The address should be pointers,when we pass address to a function the parameters receiving . By using pointers,the process of calling a function to pass the address of the variable is known as call by reference. The function which is called by reference can change the value of the variable used in the call. /* example of call by reference*? /* Include< stdio.h > void main() { int x,y; x=20; y=30; printf("\n Value of a and b before function call =%d %d",a,b); fncn(&x,&y); printf("\n Value of a and b after

function call =%d %d",a,b); } fncn(p,q) int p,q; { *p=*p+*p; *q=*q+*q; }

Pointer to arrays: an array is actually very much similar like pointer. We can declare as int *a is an address,because a[0] the arrays first element as a[0] and *a is also an address the form of declaration is also equivalent. The difference is pointer can appear on the left of the assignment operator and it is a is a variable that is lvalue. The array name cannot appear as the left side of assignment operator and is constant. /* A program to display the contents of array using pointer*/ main() { int a[100]; int i,j,n; printf("\nEnter the elements of the array\n"); scanf(%d,&n); printf("Enter the array elements"); for(I=0;I< n;I++) scanf(%d,&a[I]); printf("Array element are");

for(ptr=a,ptr< (a+n);ptr++) printf("Value of a[%d]=%d stored at address %u",j+=,*ptr,ptr); }

Pointers and structures We know the name of an array stands for address of its zeroth element the same concept applies for names of arrays of structures. Suppose item is an array variable of the struct type. Consider the following declaration: struct products { char name[30]; int manufac; float net; item[2],*ptr; this statement ptr as a pointer data objects of type struct products and declares item as array of two elements, each type struct products. Pointers on pointer A pointer contains garbage value until it is initialized. Since compilers cannot detect the errors may not be known until we execute the program remember that even if we are able to locate a wrong result,uninitialized or wrongly initialized pointers it may not provide any evidence for us to suspect problems in pointers. For example the expressions

such as *ptr++, *p[],(ptr).member

Arrays in C What is an Array?

Arrays are collection of similar items (i.e. ints, floats, chars) whose memory is allocated in a contiguous block of memory. Pointers and arrays have a special relationship. To reference memory locations,arrays use pointers. Therefore, most of the times, array and pointer references can be used interchangeably.

Declaration of arrays Arrays must be declared before they are used like any other variable. The general form of declaration is: type variable-name[SIZE]; The type specify the type of the elements that will be contained in the array, such as int,float or char and the size indicate the maximum number of elements that can be stored inside the array.

The following example illustrate the use of array: float height[50]; Declares the height to be an array containing the 50 real elements. Any subscripts 0 to 49 are all valid. In C the array elements index or subscript begins with the number zero. So height [0] refers to first element of the array. (For this reason, it is easier to think of it as referring to element number zero, rather than as referring to first element). The declaration int values[10]; would reserve the enough space for an array called values that could hold up to 10 integers. Refer to below given picture to conceptualize the reserved storage space. values[0] values[1] values[2] values[3] values[4] values[5] values[6] values[7] values[8] values[9]

Initialization of arrays: We can initialize the elements in an array in the same way as the ordinary variables when they are declared. The general form of initialization off arrays

is: type array_name[size]={list of values}; The values in the list care separated by commas, for example the statement int number[3]={0,0,0}; The initialization of arrays in c suffers two drawbacks 1. There is no convenient way to initialize only selected element. 2. There is no shortcut method to initialize large number of element

The following program to count the no of positive and negative numbers /* Program to count the no of positive and negative numbers*/ #include< stdio.h > void main( ) { int a[50],n,count_neg=0,count_pos=0,I; printf("Enter the size of the array\n"); scanf(%d,&n); printf("Enter the elements of the array\n"); for I=0;I < n;I++) scanf(%d,&a[I]); for(I=0;I < n;I++) { if(a[I]< 0)

count_neg++; else count_pos++; } printf("There are %d negative numbers in the array\n",count_neg); printf("There are %d positive numbers in the array\n",count_pos); }

Multi dimensional Arrays: Often there is a need to store and manipulate two dimensional data structure such as the matrices & tables. Here array has two subscripts. One subscript denotes row & the other the column. The declaration of two dimension arrays is as follows: data_type array_name[row_size][column_size]; int m[10][20]; The following program illustrate addition two matrices & store the results in the 3rd matrix /* example program to add two matrices & store the results in the 3rd matrix */ #include< stdio.h > #include< conio.h > void main() { int a[10][10],b[10][10],c[10][10],i,j,m,n,p,q; clrscr(); printf("enter the order of the matrix\n"); scanf("%d%d",&p,&q);

if(m==p && n==q) { printf("matrix can be added\n"); printf("enter the elements of the matrix a"); for(i=0;i < m;i++) for(j=0;j <n;j++) scanf(%d,&a[i][j]); printf("enter the elements of the matrix b"); for(i=0;i < p;i++) for(j=0;j <q;j++) scanf(%d,&b[i][j]); printf("the sum of the matrix a and b is"); for(i=0;i <m;i++) for(j=0;j <n;j++) c[i][j]=a[i][j]+b[i][j]; for(i=0;i < m;i++) { for(j=0;j <n;j++) printf(%d\t,&a[i][j]); printf(\n); } }

Dynamic Memory Allocation in C What is Dynamic Memory Allocation? Dynamic Memory Allocation is defined as the dynamically allocation of space for variables at runtime. It is wasteful when dealing with array type

structures to allocate so much space when it is declared Five ANSI Standartd Function Used in Dynamic Memory Allocation ANSI C provides five standard functions that will help you allocate memory on the heap which are as follows:
1. 2. 3. 4. 5.

sizeof() malloc() calloc() realloc() free()

The following table describe the five different standard functions that helps you allocate memory dynamically Function Task sizeof malloc The sizeof() function returns the memory size of the requested variable Allocates memory requests size of bytes and returns a pointer to the Ist byte of allocated space Allocates space for an array of elements initializes them to zero and returns a pointer to the memory


free realloc

Frees previously allocated space Modifies the size of previously allocated space.

sizeof() The sizeof() function returns the memory size of requested variable. This call should be used in the conjunction with the calloc() function call, so that only the necessary memory is allocated, rather than a fixed size. Consider the following, struct date { int hour, minute, second; }; int x; x = sizeof( struct date );

malloc() A block mf memory may be allocated using the function called malloc. The malloc function reserves a block of memory of specified size and return a pointer of type void. This means that we can assign it to any type of the pointer. It takes the following form: ptr=(cast-type*)malloc(byte-size); ptr is a pointer of type cast-type the malloc returns a

pointer (of cast type) to an area of memory with the size byte-size. The following is the example of using malloc function x=(int*)malloc(100*sizeof(int));

calloc() Calloc is another memory allocation function that is normally used to request the multiple blocks of storage each of same size and then sets all bytes to zero. The general form of calloc is: ptr=(cast-type*) calloc(n,elem-size); The above statement allocates contiguous space for n blocks each size of the elements size bytes. All bytes are initialized to zero and a pointer to the first byte of allocated region is returned. If there is not enough space a null pointer is also returned. realloc() The memory allocated by using calloc or malloc might be insufficient or excess sometimes in both the situations we can change the memory size already allocated with the help of the function called realloc. This process is called the reallocation of memory. The general statement of reallocation of memory is : ptr=realloc(ptr,newsize);

free() Compile time storage of a variable is allocated and released by the system in accordance with its storage class. With the dynamic runtime allocation, it is our responsibility to release the space when it is not required at all.When the storage is limited,the release of storage space becomes important . When we no longer need the data we stored in a block of memory and we do not intend to use that block for the storing any other information, Using the free function,we may release that block of memory for future use. free(ptr); ptr is a pointer that has been created by using calloc or malloc. The following program illustrate the reallocation of memory using realloc() and malloc() /*Example program for reallocation*/ #include< stdio.h > #include< stdlib.h > define NULL 0 main() { char *buffer; /*Allocating memory*/ if((buffer=(char *) malloc(10))==NULL) {

printf("Malloc failed\n"); exit(1); } printf("Buffer of size %d created \n",_msize(buffer)); strcpy(buffer,Bangalore); printf(\nBuffer contains:%s\n,buffer); /*Reallocation*/ if((buffer=(char *)realloc(buffer,15))==NULL) { printf("Reallocation failed\n"); exit(1); } printf("\nBuffer size modified".\n); printf("\nBuffer still contains: %s\n",buffer); strcpy(buffer,Mysore); printf("\nBuffer now contains:%s\n",buffer); /*freeing memory*/ free(buffer); }

Strings in C What is a String?

A string is combination of characters. Any set or sequence of characters defined within double quotation symbols is a constant string. In c it is required to do some meaningful operations on the strings

Initializing Strings The initialization of a string must the following form which is simpler to the one dimension array char month1[ ]={j,a,n,u,a,r,y};

The following example shows the use of string: /*String.c string variable*/ #include < stdio.h > main() { char month[15]; printf ("Enter the string"); gets (month); printf ("The string entered is %s", month); } Note: Character string always terminated by a null character \0. A string variable is always declared as an array & is any valid C variable name. The general form of declaration of a string variable is Reading Strings from the terminal: The function scanf with %s format specification is needed to read the character string from the terminal itself. The following example shows how to read strings from the terminals: char address[15];


String operations (string.h) language recognizes that strings are terminated by null character and is a different class of array by letting us input and output the array as a unit. To array out many of the string manipulations,C library supports a large number of string handling functions that can be used such as: 1. Length (number of characters in the string). 2. Concatentation (adding two are more strings) 3. Comparing two strings. 4. Substring (Extract substring from a given string) 5. Copy(copies one string over another) strlen() function: This function counts and returns the number of characters in a particular string. The length always does not include a null character. The syntax of strlen() is as follows: n=strlen(string); Where n is the integer variable which receives the value of length of the string. The following program shows to find the length of the string using strlen() function

/*writr a c program to find the length of the string using strlen() function*/ #include < stdio.h > include < string.h > void main() { char name[100]; int length; printf("Enter the string"); gets(name); length=strlen(name); printf("\nNumber of characters in the string is= %d",length); } strcat() function: when you combine two strings, you add the characters of one string to the end of the other string. This process is called as concatenation. The strcat() function is used to joins 2 strings together. It takes the following form: strcat(string1,string2) string1 & string2 are the character arrays. When the function strcat is executed string2 is appended to the string1. the string at string2 always remains unchanged.

strcmp function:

In c,you cannot directly compare the value of 2 strings in a condition like if(string1==string2) Most libraries however contain the function called strcmp(),which returns a zero if 2 strings are equal, or a non zero number if the strings are not the same. The syntax of strcmp() is given below: Strcmp(string1,string2)

strcmpi() function This function is same as strcmp() which compares 2 strings but not case sensitive. Strcmp(string1,string2)

strcpy() function: To assign the characters to a string,C does not allow you directly as in the statement name=Robert; Instead use the strcpy() function found in most compilers the syntax of the function is illustrated below. strcpy(string1,string2);

strlwr () function: This function converts all characters in a string from uppercase to lowercase The syntax of the function strlwr is illustrated below strlwr(string);

strrev() function: This function reverses the characters in a particular string. The syntax of the function strrev is illustrated below strrev(string);

The following program illustrate the use of string functions: /* Example program to use string functions*/ #include < stdio.h > #include < string.h > void main() { char s1[20],s2[20],s3[20]; int x,l1,l2,l3; printf("Enter the strings"); scanf("%s%s",s1,s2); x=strcmp(s1,s2); if(x!=0) {printf("\nStrings are not equal\n"); strcat(s1,s2); } else printf("\nStrings are equal"); strcpy(s3,s1); l1=strlen(s1); l2=strlen(s2); l3=strlen(s3);

printf("\ns1=%s\t length=%d characters\n",s1,l1); printf("\ns2=%s\t length=%d characters\n",s2,l2); printf("\ns3=%s\t length=%d characters\n",s3,l3); }

Structures and Unions in C What is a Structure?

Structure is a method of packing the data of different types. When we require using a collection of different data items of different data types in that situation we can use a structure. A structure is used as a method of handling a group of related data items of different data types.

Syntax of Using Structure structure definition: general format: struct tag_name { data type member1; data type member2; .... ...

Example of Using Structure: struct lib_books { char title[20]; char author[15]; int pages; float price; }; To holds the details of four fields namely title, author pages and price,the keyword struct declares a structure. These are the members of the structures. Each member may belong to same or different data type. The tag name can be used to define the objects that have the tag names structure. The structure we just declared is not a variable by itself but a template for the structure. We can declare the structure variables using the tag name any where in the program. For example the statement, struct lib_books book1,book2,book3; declares the book1,book2,book3 as variables of type struct lib_books each declaration has four elements of the structure lib_books. The complete structure declaration might look like this The complete structure declaration might look like this struct lib_books {

char title[20]; char author[15]; int pages; float price; }; struct lib_books, book1, book2, book3;

Get the Length of a Node List The node list is always keeps itself up-to-date. If an element is deleted or added, in the node list or the XML document, the list is automatically updated. The node list has a useful property called the length. The length property return the number of node in a node list. The following code fragment get the number of <title> elements in "bookdetails.xml": struct lib_books { char title[20]; char author[15]; int pages; float price; }; struct lib_books, book1, book2, book3; The following program shows the use of structure /* Example program for using a structure*/ #include< stdio.h > void main() { int id_no; char name[20]; char address[20];

char combination[3]; int age; }newstudent; printf("Enter the student information"); printf("Now Enter the student id_no"); scanf(%d,&newstudent.id_no); printf(Enter the name of the student); scanf(%s,&new; printf(Enter the address of the student); scanf(%s,&new student.address); printf(Enter the cmbination of the student); scanf(%d,&new student.combination); printf(Enter the age of the student); scanf(%d,&new student.age); printf(Student information\n); printf(student id_number= %d\n,newstudent.id_no); printf(student name=%s\n,; printf(student Address= %s\n,newstudent.address); printf(students combination= %s\n,newstudent.combination); printf(Age of student=%d\n,newstudent.age); }

Union: However the members that we compose a union all share the same storage area within the computers memory where as each member within a structure is

assigned its own unique storage area. Thus unions are used to observe memory. They are useful for the application involving multiple members. Where values need not be assigned to all the members at any time. Unions like structure contain members whose individual data types may differ from one another also. Like structures union can be declared using the keyword union as follows: Last example will create a rectangle with rounded corner: union item { int m; float p; char c; } code; The notation for accessing a union member that is nested inside a structure remains the same as for the nested structure.In effect,a union creates a storage location that can be used by one of its members at a time. When a different number is assigned to a new value the new value supercedes the previous members value. Unions may be used in all the places where a structure is allowed. How to print 1 to 100 without using any conditional loop? Recursion is solution of this problem.

DisplayInfo(Int val = 1) { Printf("%d ", val); if(val == 100) return; else DisplayInfo(++val); } Posted by: Paresh Contact Author for(i=1;i<=100;i++) { printf(/n"%d",i); } Posted by: amitabh ranjan Contact Author DisplayInfo(Int val = 1) { Printf("%d ", val); if(val == 100) return; else DisplayInfo(++val); } Posted by: Saktipada Upadhyaya Contact Author

int a=1; l:if(a<=100) { printf("%d",a); goto a; } Posted by: mani krishna How pointer variables are intialised? int a; int *p; int p=&a; tihs is initialization n if its not initialized itscalled as dangling pointer ================================ ======== pointer variable is initialised as datatype *variablename (declaration eg:int *ptr,x; in this it is initialised as ptr=&x; main() { int *a;//declaration of pointer variable printf("%d",sizeof(a)); }

Assigning the address of a variable to the the pinter variable is nothing but the initialisation of pointer. eg. int x=10,*p = &x; or int x=10, *p; p = &x; ================================ ========================= int *p,a=1; p=&a; The pointer must have same data type as that of variable whose address is stored into it.