Datastructures

accessing the portion of array which is not initialised

ajitb4u — Mon, 29 Jun 2009 21:45:08 +0000

hey guys we may encountering the situations where we notice that an array of a particular size is declared and initialised and when we access its out of bound values may of us will be in the dilemma what will happen.

consider example:-

int a[6]={1,2};

here values of the arrays are

a[0]=1;
a[1]=2;
a[2]=0;
a[3]=0;
a[4]=0;
a[5]=0;

in the partially initialized arrays values of the arrays which are not initialized will be 0′s

now coming to point what i want to say is

1)if suppose if we print the a[6] or a[7]… if they are the valid locations , values stored in that locations will be printed otherwise garbage values will be printed.
2)if we want to store something in those location i.e if we try to give a[6]=7 etc then we are actually trying to access an invalid location.
which will lead to segmentation faults.

important note :-standard compilers which follows the ansi standards will produce the above results.

observe the output of the program

ajitb4u — Fri, 26 Jun 2009 16:11:16 +0000

#include”stdio.h”
int a[]={1,2,3};
int main()
{
int *f(void);
*f()=5;
printf(“%d %d %d”,a[0],a[1],a[2]);
}
int * f(void)
{
int i;
for(i=0;i<3;i++)
return a+i;
}

o/p:-

5 2 3

reason:– at i=0 in loop function is returned and it returns starting address of a whose value is eventually changed to 5.

reversing an array of strings

ajitb4u — Wed, 24 Jun 2009 16:38:29 +0000

/*************************************/
example:-
i/p:- hello how are you

o/p:- you are how hello

/*************************************/

#include”stdio.h”
#include”string.h”
int main()
{
char p[100],c;
int len,i,j;
printf(“enter the text that you want to be reversed:”);
gets(p);
len=strlen(p);
for(i=0;i {
c=p[i];
p[i]=p[len-i-1];
p[len-i-1]=c;
}
i=0;
while(i {
j=i;
for(j=i;j {
if(p[j]==32)
break;
}
j–;
for(;i {
c=p[i];
p[i]=p[j];
p[j]=c;
j–;
i++;
}
while(i {
i++;
if(p[i]==32)
break;
if(i==len-1)
break;
}
i++;
j=i;
}
puts(p);
}

accessing the array

ajitb4u — Mon, 22 Jun 2009 06:33:10 +0000

consider the following

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

what i want say is

if you want to access the array i mean if you want to retrieve the elements we will write if as a[i] where i={0,1,2,3}

but we can write the same as i[a];

for example

a[0] == 0[a];
a[1] == 1[a];
a[2] == 2[a];

as i already posted in the previous posts a[i] is internally understood by the compiler as the pointer value at *(a+i)

so even if we write i[a] it will be interpreted as *(i+a);

so both convey the same location

thus when we write

printf(“%d %d “,a[i],i[a]);

we get the same answer.

2D array structure and some points related to arrays

ajitb4u — Sat, 20 Jun 2009 15:13:35 +0000

1) if an array is declared and only some of its elements are initialized then all the remaining elements of it are initialized to ’0′ by default.

example:

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

a[0]=1;
a[1]=2;
a[2]=3;
a[3]=0; // initialized to ’0′ by default
a[4]=0;

i.e in an partially initialized arrays all the elements that are not initialized their values will be ’0′.

2D arrays:

consider the following

int a[2][3];

here a memory of 6 elements is created and ‘a’ will be pointing to first row and ‘a+1′ will be pointing to second row . if you want to access first element notations are
a[0][0] ==> **a

similarly

**(a+1) == a[1][0];

to be clear with is concept

int a[5][4][7];

**(*(a+2)+1) ==> a[2][1][0];

assuming for the above int a[5][4][7] size of int 4 bytes and starting address of ‘a’ is at 2000
&a+1 ==> 2560 i.e 2000+5*4*7*(size of int i.e 4)

observe the following

int a[2][3];

*(a+1) == *a+3 i.e second row first element address

arrays — sizes

ajitb4u — Fri, 19 Jun 2009 20:29:06 +0000

here we are going to see what are the sizes of the arrays that are intialized, declared.

consider the following:

assumption:

1)size of int is 4 bytes

2)starting address of a is 2000

int a[10];

when given sizeof(a) gives 10*4 = 40 as answer.

i have already said in previous post that a denotes starting address of the memory in the stacksegment. here what i want to say is size of and address are the two operators where when we give a is taken as whole array and not the the starting element address.

example:

&a+1 gives the location 2040 i.e memory next to total memory occupied by ‘a’.

when you give ‘a+1′ it gives you address of second element in the array.

when you give ‘a’ it gives address of address of first element in array.

conclusion:

1)so sizeof and address are two exceptions where when you give a it will be taken as entire array .

2) internally at all the places ‘a’ means pointer pointing to the first memory address of the array.

here is the small example to describe above

#include”stdio.h”
int main()
{
int a[10];
printf(“%d %d %d %d”,&a,&a+1,a,a+1);
return 0;
}

O/p:- assuming starting address of a is at 2000

2000 2040 2000 2004.

small notes on array

ajitb4u — Thu, 18 Jun 2009 18:29:24 +0000

array may be simply defined as collection of data of same types.

array and pointers are very much related

when u intilize an array memory is created in the stacksegment and the name with which array is created will be pointing to the first element of that memory.

example a[10] => array of 10 elements is created in the stack segment and ‘a’ will pointing to the first element of that memory.

when u read the data element a[i] it will be internally undetstood by the compiler as *(a+i) => value at( address of a + no of elemnts after which i is located multipled by the size of that data type ).

ex: a[10] is an array assume starting address of a is at 2000 and size of int is 4 bytes the

a[3] denotes *(a+3) => value at( 2000(address of a) + 3*4 ) => value at address 2012.

a small code to explain the above concept

#include
int main()
{
void temp(int);
void perm(int *);
void permarray(int []);
int a[]={9,8,7};
temp(a[1]);//here value of a[1] is passed
printf(“\n %d %d %d \n”,a[0],a[1],a[2]);
perm(&a[2]);//address of a[1] is passed
printf(“\n %d %d %d \n”,a[0],a[1],a[2]);
permarray(a);// array is passed :: actually address of a[0] is passed
printf(“\n %d %d %d \n”,a[0],a[1],a[2]);
return 0;
}
void temp(int x)// creates a variable x and chages its value to 5
{
x=5;
return;
}
void perm(int *p)//takes the adderess of a[2] changes its value at that address to 10
{
printf(“\n look at the passing argument in the main and the recevin argument in function “);
printf(“\n editing the value of the third elemnent :”);
*p=10;
return;
}
void permarray(int *x)// takes the address of the first variable of the array as the argument
{
printf(“\n look how array is passed and how it is received in fnc:”);
// look at the assignments statements
*x=1;
*(x+1)=2;
x[2]=3;
return;;
}

o/p:

9 8 7

look at the passing argument in the main and the recevin argument in function
editing the value of the third elemnent :
9 8 10

look how array is passed and how it is received in fnc:
1 2 3