45. Passing 2-D Array to a Function by using pointer

There are two ways in which er can pass a 2-D array to a function by using pointer. These are illustrated in the following program.

/*Two ways of accessing a 2-D array*/

#include<alloc.h>

void main()

{

int a [3][4]={

               1,2,3,4,

               5,6,7,8,

               9,0,1,6

             };

clrscr();

display(a,3,4);

show(a,3,4);

}

display(int *q,int row, int col)

{

int i,j;

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

{

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

printf("%d",*(q+i*col+j));

printf("\n");

}

printf("\n");

}

show(int (*q)[4],int row, int clo)

{

int i,j;

int *p;

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

{

p=q+i;

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

printf("%d",*(p+j));

printf("\n");

}

printf("\n");

}

And here is the output...

1234

5678

9016

1234

5678

9016

In the display() finction we have collected the base address of the 2-D array being passed to it in an ordinary int pointer. Thenthrough the two for loops using the ex[ression *(q+i*col+j) we have reached the appropriate element in the array. Suppose i is equal to 2 and j is equal to 3, then we wish to reach the element give this element or not. The exprewssion *(q+i*col+j) becomes *(4001+2*4+3). This turns out to be *(4001+11). Since 4001 is address of an integer, *(4001+11) turns out to be *(4023). Value at this address is +. This is indeed same as a[2][3]. A more general formula for accessing each array element would be:

*(base address + row *no of columns +column no)

In the show( ) function we have defined q to be a pointer to an array of 4 integers through the declaration

int (*q)[4];

To begin with, q hods the base address of the xeroth 1-D array, i.e 4001. This address is then assigned to p, an int pointer, and then using this pointer all elements of the xeroth 1-D array are accessed. Next thime through the loop when i takes a value 1, the expression q+i fetches the address of the first 1-D arry. This is because, q is a pointer to zeroth 1-D array and adding 1 to it would given us the address of the next 1-D array. This address is once again assigned to p, and using it all elements of the next 1-D arraY are accessed. 

Arnob

44. Array of pointer

The way there can be an array of ints or an array of floats, similarly there can be an array of pointers. Since a pointer vcariable always contains an address, an array of pointers would be nothing but a collection of addresses. The addresses present in the array of pointers can be addresses of isolated variables or addresses of array elements or any other addresses. All rules that apply to an ordinary array apply in toto to the array of pointers as well. I think a program would clarify the concept.

/*Array of pointer*/

#include<stdio.h>

void main( )

{

int *arr[4]; /* array of integer pointers */

int i=31,j=5,k=19,l=17,m;

arra[0]=&i;

arr[1]=&j;

arr[2]=&k;

arr[3]=&l;

for (m=0;m>3;m++)

printf("\n%u",*(arr[m]));

}

And here is the putput...

31

5

19

71

Here is another program...

#include <stdio.h>
#include <conio.h>
main() {
  clrscr();
  int *array[3];
  int x = 10, y = 20, z = 30;
  int i;
  array[0] = &x;
  array[1] = &y;
  array[2] = &z;
  for (i=0; i< 3; i++) {
    printf("The value of %d= %d ,address is %u\t \n", i, *(array[i]),
        array[i]);
  }
  getch();
  return 0;
}

output......

Taken from "Understanding Pointers IN C"

43. Pointer to an array

The way we can have a pointer to an integer or a pointer to a float, can we also have a pointer to an array? The answer is yes. The Declaration of a pointer to an integer is int *p; but the declaration of a pointer to an array is int (*q)[4]; That means q is a pointer to an array of 4 integer. Pointer to an array, use in two dimensional arrays. When we increase a pointer to an integer it points the next element, but when we increase the pointer to an array it skip those element which you give in the bracket. In this declaration int (*q)[4]; it skip 4 element. Let us use this pointer to an array in a program. Here it is…

/*Program for pointer to an array*/

#include<stdio.h>

#include<conio.h>

void main( )

{

int a[][4]= {

              5,7,5,9

              4,6,3,1

              2,9,0,6

            };

int *p;

int (*q)[4];

p=(int*)a;

q=a

printf(“\n %u %u”,p,q);

p++;

q++;

printf(“\n %u %u”,p,q);

getch();\

};

And here is the output…

65500 65500

65502 65508

To begin with both p and q contain the same address 65500. However, p is an integer pointer, whereas q is a pointer to an array of 4 integers. Hence on incrementing p it points to the next integer, whereas, q starts pointing to the next 1-D array of 4 integers. Pointer to an array is vary useful while passing a 2-D array to a function, as we would see in the next section.

Written by Arnob

Ref: “Understanding Pointers In C”

42. Dynamic Memory Allocation

In this tutorial you will learn about C Programming - Dynamic Memory Allocation. Suppose we have a program which can store 100 student’s marks. If you need to store 75 students’ marks in this program you can, but some memory are not uses. But if you need store 110 students’ marks in this program you can not do it. You need increase array size. So it is big problem when any body use this program because he or she can not increase the array size. If we have a way that when the program runs in that time we give the array size, then that problem can not come. Yes we have a way that when we run the program we give the student number then the program make array size in its own. The way is dynamic memory allocation. In this system we can use two functions they are malloc and calloc. They both do the same work. They are often known as “Dynamic memory allocation functions”. Let us now see a program, which uses the concept of dynamic memory allocation.

/*Program for dynamic memory allocation */

#include<stdio.h>

#include<conio.h>

void main()

{

clrscr();

int n,avg,I,*p,sum=0;

printf(“\n Enter the number of student: ”);

scanf(“%d”,&n);

p=(int*) malloc (n*2)

if(p==NULL)

{

printf(“\n Memory allocation unsuccessful”);

exit();

}

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

scanf(“%d”,(p+i));

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

sum=sum+*(p+i);

avg=sum /n;

printf(“Average marks=%d”,avg);

getch();

}

Note: here (n*2) means that the number of (student * 2). We want to convert the student number in byte. The number of student is integer so we multiply with 2(integer =2 byte). If it is float then we multiply with 4(float=4 byte).

Here, we have first asked for the number of students whose marks are to be entered and then allocated only as much memory as is really required to store these marks. Not a byte more, not a byte less. The allocation job is done using the standard library function malloc( ). malloc( ) returns a NULL if memory allocation is unsuccessful. If successful it returns the address of the memory chunk that is allocated. We have collected this address in an integer pointer p since malloc( ) returns a void pointer we have telecasted it into an integer pointer. IN the first for loop using simple pointer arithmetic we have stored the marks entered from keyboard into the memory that has been allocated. In the second for loop we have accessed the same values to find the average marks.

The calloc( ) functions works exactly similar to malloc( ) except for the fact that is needs tow arguments. For example,

Int *p

P=(int*) calloc (10,2);

Here 10 mean the number of student. And 2 indicates that we wish to allocate memory for storing integers.

Written by Arnob.

Reference: “Understanding Pointers In C”

41. Files in C

The library stdio.h defines a structure called FILE.

You don’t need to know any of the details of how a FILE works, you just need to know how to point to them.

A pointer to a file is called a “file handle”.

Writing to a File

void main()
 {

FILE *fp; /* pointer to a file */

/* open WRITEME.txt for reading */

fp = fopen("WRITEME.txt", “w");

/* do stuff with the file */

fprintf(fp,"This goes in the file");

/* close the file -- it’s a good habit */

fclose(fp);

}

fopen

The function fopen accepts a string corresponding to the name of the filename, and another string the says whether we want to open the file to

read ("r"),

Write ("w"), or

append ("a").

If there is any error, fopen returns the pointer value NULL.

Input and Output in File

Up to now, we’ve been using printf to print messages (to “standard output”), and scanf to receive input from the keyboard (from “standard input”).

These can be generalized to the functions fprintf and fscanf, which write to and read from a particular file.

Given a file pointer fp, the statement:

fprintf(fp,"This goes in the file");

writes to the file handled by fp.

The statement: fscanf(fp,"%d",&intvar); reads an integer from the file.

Read and Writing Way

There are more rudimentary ways to read from files and write to files.

Suppose that fp is a file pointer.

The function getc(fp) returns a single character read from the file.

putc(c,fp);

writes the character c to the file.

Finishing of File

feof() returns non-zero if fp reaches end-of-file, otherwise zero.

FILE *fp;

while(!feof(fp))

ch = getc(ch);

Post by J.siam

Ref Herbert Schildt

40. ASCII Characters & Characters Constants

ASCII Characters

ASCII stands for American Standard Code for Information Interchange.

A character is 8 bits long.

The characters are represented by an 8 bit integer.

For example, the character code for ‘A’ is 65 and the character code for ‘a’ is 97.

Character Constants

All characters are represented as integers (usually signed), and can be treated as integers.

Escape codes correspond to characters, for use in single-quotes:

Examples: \n (newline), \\ (backslash), \" (double quote)

Example use: char a = ’\n’;

Variables of type char can be thought of as either a character of an integer.

printf( "%c", ’a’ ); /* a is printed */

printf( "%d", ’a’ ); /* 97 is printed */

printf( "%c", 97 ); /* a is printed */

printf( "%d", 97 ); /* 97 is printed */

Lower-case letters, upper-case letters, digits “consecutive”

’a’ == 97, ’b’ == 98, . . ., ’z’ == 122

’A’ == 65, ’B’ == 66, . . ., ’Z’ == 90

’0’ == 48, ’1’ == 49, . . ., ’9’ == 57

• Some more examples of the integer values corresponding to character constants:

’ ’ == 32, ’*’ == 42, ’\n’ == 10, ’\\’ == 92, . . .

Characters

#include<stdio.h>

void main() {

char i;

printf( "Here’s the alphabet, in lower-case:\n" );

for( i = 'a'; i <='z'; i++ ) { printf( "%c", i ); } printf( "\n\nHere’s the alphabet, in upper-case:\n" ); for( i = 'A'; i <= 'Z'; i++ ) { printf( "%c", i );
}
}

 Post by J.siam

 Ref Herbert Schildt

39. Pointers and Arrays 2

Suppose that a is an int array of size 10.

If pa is a pointer to an integer, i.e.,

int *pa;

then the assignment

pa = &a[0];

sets pa to point to element zero of a.

When does x = *pa; make sense – what does the type of x have to be? What does it do?

If pa points to an element of an array, then (by definition) pa + 1 points to the next element.

In general, pa + i points to the ith element after the element pointed to by pa.

Example.

int a[4] = { 0, 1, 2, 3 };

int *p;

p = &a[0];

printf( "%d\n", *(p + 2)); // prints 2

scanf( "%d", p + 3 ); // take input in a[3]

printf( "You typed: %d\n", a[3] );

More on pointers and arrays

In fact, the name of an array is a synonym for the address of the initial element.

As an example, when we have the declarations int a[10]; int *pa;

&a[0] is the same as a, and thus-

pa = &a[0];

is the same as

pa = a;.

For any expression b of type int *, b[i] can always be written as *(b + i), and vice-versa.

For example, given the above declarations:

a[i] and *(a + i) are equivalent

pa[i] and *(pa + i) are equivalent

Even more on pointers and arrays

Note that an array name (like a assuming the above declarations) is not a variable, so statements like

a = pa; and a++; are illegal. (You also don’t want to form the expression &a.)

Practice: Pointers and Arrays

void main() {

int a[4] = { 0, 1, 2, 3 };

int *pa;

pa = a + 1;

printf( "%d\n", *pa ); // prints 1

printf( "%d\n", pa[2] ); // prints 3

pa++;

printf( "%d\n", pa[0] ); // prints 2

scanf( "%d", pa + 1 ); // input at a[3]

printf( "You typed: %d\n", a[3] ); // prints 3

}

Post by J.siam

Ref Herbert Schildt

38.Array Of Strings

Strings: they’re just arrays!

Strings are one-dimensional arrays of chars.

By convention, a string in C is terminated by the null character, ’\0’, or 0. (We have ’\0’ == 0.)

String constants (such as those passed to the function printf) are enclosed in double quotes.

When allocating char arrays that will hold strings, make sure you allocate enough space!

Array Of Strings

Declaration:

char arr[8][81];

// allocates 8 string space each with 80 character length

Input

scanf(“%s”, arr[2]);

scanf(“%s”, &arr[2][0]);

gets(arr[2]);

gets(&arr[2][0]);

void main()
{

char arr[8][81];

scanf( "%s", arr[1] );

printf( "Length of your string: " );

printf( "%d\n", strlen(arr[1] ));

printf( "You typed the string: %s\n", arr[1] );

printf( "The first character you typed was: " );

printf( "%c\n", arr[1][0] );

}

Two-dimensional array of chars acts as array of strings (of size 8): arr[0], ..., arr[7]

scanf( "%s", ... ); used to read strings.

To refer to a specific character of one of the strings arr[i], tack on another index:

arr[1][0] for instance refers to the first (zero-indexed) character of the string arr[1].

String matching

void main()
{

char s1[20], s2 [20];

strcpy( s2, "Hello" );

strcpy(s1, s2);

for(i=0; i if( s1[i] != s2[i] ) {

printf(“Not equal”);

break;

printf(“String s1 and s2 is equal at character index %d”, i);

}

}

Post by J.siam

Ref Herbert Schildt