FILE *fp;
| Function | description |
|---|---|
| fopen() | create a new file or open a existing file |
| fclose() | closes a file |
| getc() | reads a character from a file |
| putc() | writes a character to a file |
| fscanf() | reads a set of data from a file |
| fprintf() | writes a set of data to a file |
| getw() | reads a integer from a file |
| putw() | writes a integer to a file |
| fseek() | set the position to desire point |
| ftell() | gives current position in the file |
| rewind() | set the position to the begining point |
fopen() function is used to create a new file or to open an existing file.*fp = FILE *fopen(const char *filename, const char *mode);
FILE *fp), which will hold the reference to the opened(or created) file.| mode | description |
|---|---|
| r | opens a text file in reading mode |
| w | opens or create a text file in writing mode. |
| a | opens a text file in append mode |
| r+ | opens a text file in both reading and writing mode |
| w+ | opens a text file in both reading and writing mode |
| a+ | opens a text file in both reading and writing mode |
| rb | opens a binary file in reading mode |
| wb | opens or create a binary file in writing mode |
| ab | opens a binary file in append mode |
| rb+ | opens a binary file in both reading and writing mode |
| wb+ | opens a binary file in both reading and writing mode |
| ab+ | opens a binary file in both reading and writing mode |
fclose() function is used to close an already opened file.int fclose( FILE *fp );Here fclose() function closes the file and returns zero on success, or EOF if there is an error in closing the file. This EOF is a constant defined in the header file stdio.h.
getc() and putc() are simplest functions used to read and write individual characters to a file.#include<stdio.h>
#include<conio.h>
main()
{
FILE *fp;
char ch;
fp = fopen("one.txt", "w");
printf("Enter data");
while( (ch = getchar()) != EOF) {
putc(ch,fp);
}
fclose(fp);
fp = fopen("one.txt", "r");
while( (ch = getc()) != EOF)
printf("%c",ch);
fclose(fp);
}
#include<stdio.h>
#include<conio.h>
struct emp
{
char name[10];
int age;
};
void main()
{
struct emp e;
FILE *p,*q;
p = fopen("one.txt", "a");
q = fopen("one.txt", "r");
printf("Enter Name and Age");
scanf("%s %d", e.name, &e.age);
fprintf(p,"%s %d", e.name, e.age);
fclose(p);
do
{
fscanf(q,"%s %d", e.name, e.age);
printf("%s %d", e.name, e.age);
}
while( !feof(q) );
getch();
}
fwrite(data-element-to-be-written, size_of_elements, number_of_elements, pointer-to-file);
const char *mytext = "The quick brown fox jumps over the lazy dog";
FILE *bfp= fopen("test.txt", "wb");
if (bfp) {
fwrite(mytext, sizeof(char), strlen(mytext), bfp) ;
fclose(bfp) ;
}
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
extern int errno;
main( )
{
char *ptr = malloc( 1000000000UL); //requesting to allocate 1gb memory space
if ( ptr == NULL ) //if memory not available, it will return null
{
puts("malloc failed");
puts(strerror(errno));
exit(EXIT_FAILURE); //exit status failure
}
else
{
free( ptr);
exit(EXIT_SUCCESS); //exit status Success
}
}
| Function | Description |
|---|---|
| malloc() | allocates requested size of bytes and returns a void pointer pointing to the first byte of the allocated space |
| calloc() | allocates space for an array of elements, initialize them to zero and then return a void pointer to the memory |
| free | releases previously allocated memory |
| realloc | modify the size of previously allocated space |
int *x; x = (int*)malloc(50 * sizeof(int)); //memory space allocated to variable x free(x); //releases the memory allocated to variable x
struct employee
{
char *name;
int salary;
};
typedef struct employee emp;
emp *e1;
e1 = (emp*)calloc(30,sizeof(emp));
int *x; x=(int*)malloc(50 * sizeof(int)); x=(int*)realloc(x,100); //allocated a new memory to variable x
| calloc() | malloc() |
|---|---|
| calloc() initializes the allocated memory with 0 value. | malloc() initializes the allocated memory with garbage values. |
| Number of arguments is 2 | Number of argument is 1 |
Syntax :
(cast_type *)calloc(blocks , size_of_block);
|
Syntax :
(cast_type *)malloc(Size_in_bytes);
|
int main( int argc, char *argv[])Here argc counts the number of arguments on the command line and argv[ ] is a pointer array which holds pointers of type char which points to the arguments passed to the program.
#include <stdio.h>
#include <conio.h>
int main( int argc, char *argv[] )
{
int i;
if( argc >= 2 )
{
printf("The arguments supplied are:\n");
for(i=1;i< argc;i++)
{
printf("%s\t",argv[i]);
}
}
else
{
printf("argument list is empty.\n");
}
getch();
return 0;
}
int x = 1, y = 2; int *ip; ip = &x;It is worth considering what is going on at the machine level in memory to fully understand how pointer work. Consider Fig. 9.1. Assume for the sake of this discussion that variable x resides at memory location 100, y at 200 and ip at 1000. Note A pointer is a variable and thus its values need to be stored somewhere. It is the nature of the pointers value that is new.y = *ip;x = ip;*ip = 3;
int *ip; *ip = 100;
int *ip; int x; ip = &x; *ip = 100;
float *flp, *flq; *flp = *flp + 10; ++*flp; (*flp)++; flq = flp;
#include <stdio.h> int main () { int var = 20; /* actual variable declaration */ int *ip; /* pointer variable declaration */ ip = &var; /* store address of var in pointer variable*/ printf("Address of var variable: %x\n", &var ); /* address stored in pointer variable */ printf("Address stored in ip variable: %x\n", ip ); /* access the value using the pointer */ printf("Value of *ip variable: %d\n", *ip ); return 0; }
Address of var variable: bffd8b3c Address stored in ip variable: bffd8b3c Value of *ip variable: 20
#include <stdio.h> int main () { int *ptr = NULL; printf("The value of ptr is : %x\n", ptr ); return 0;
Download tutorial : https://pdos.csail.mit.edu/6.828/2014/readings/pointers.pdf
printf() function, the header file <stdio.h> should be included.#include <stdio.h>
int main()
{
/* If you write printf() statement without including header file, this program will show error. */
printf("Catch me if you can.");
} main() function (which is also a library function). This program is called at program starts.sqrt() function which is defined under header file "math.h"#include <stdio.h>
#include <math.h>
int main(){
float num,root;
printf("Enter a number to find square root.");
scanf("%f",&num);
root=sqrt(num); /* Computes the square root of num and stores in root. */
printf("Square root of %.2f=%.2f",num,root);
return 0;
}add to add integers and display sum inmain() function./*Program to demonstrate the working of user defined function*/
#include <stdio.h>
int add(int a, int b); //function prototype(declaration)
int main(){
int num1,num2,sum;
printf("Enters two number to add\n");
scanf("%d %d",&num1,&num2);
sum=add(num1,num2); //function call
printf("sum=%d",sum);
return 0;
}
int add(int a,int b) //function declarator
{
/* Start of function definition. */
int add;
add=a+b;
return add; //return statement of function
/* End of function definition. */
}
return_type function_name(type(1) argument(1),....,type(n) argument(n));
int add(int a, int b); is a function prototype which provides following information to the compiler:add()int.int are passed to function.main() function.function_name(argument(1),....argument(n));
add(num1,num2); from main(). This make the control of program jump from that statement to function definition and executes the codes inside that function.return_type function_name(type(1) argument(1),..,type(n) argument(n))
{
//body of function
}
return_type function_name(type(1) argument(1),....,type(n) argument(n))
int add(int a,int b) in line 12 is a function declarator.
return (expression);
return a; return (a+b);
add() function is returned and that value is stored in variable sum in main() function. The data type of expression in return statement should also match the return type of function.
