These two are different programs for declaring a 2D array
1)i think they are same because both are 2D array?
2)can we access both using a[i][j] and p[i][j]?
3)Why *a or a are same and p or *p are different
#include<stdio.h>
#include<stdlib.h>
int main(){
int a[100][100];
printf("%d\n",a);
printf("%d\n",*a);
int **p=malloc(sizeof(int*)*100);
for(int i=0;i<100;i++){
p[i]=malloc(sizeof(int)*100);
}
printf("%d",p);
printf("%d",*p);
}
the big difference is that in case with a[100][100] the compiler knows the full size of the array and allocates a contiguous memory region on a stack (as in your case) or in static area. When accessing an array element, the compiler is free to calculate its address based on the array dimensions and use a single reference to access it. like this
[0,0][0,1][0,2]...[0,99][1,0][1,1][1,2]...[99,0]...[99,99]
+-------0------...-----+----- 1 -------...+----- 99 -----+
In case of the dynamic allocation, which you used, the memory is allocated contiguously only for a single dimension of the array. So, you allocate 100 pointers, every one of each points to a single dimensional array of integers. Those arrays can be placed at arbitrary memory locations. As a result, the compiler has to do at least 2 references in this case, use first index to get a pointer to the second array, than use the second index to get the element in the second array.
pointers[index0] : [0][1][2]..[99]
/ | \
/ | |
V V V
[0] [0] [0]
[1] [1] [1]
... ... ...
some addition about a and *a. In 'c' when the name of the array is used in a pointer like context, it is interpreted as an address of the array. So, in printf a points to the beginning of the two-dimensional array. *a for same reason is supposed to provide you an address of the first column. Which in this case is the same as the start or the array. **a will point you to the very first array element a[0][0]. And by the way, it is better to use %p there instead of %d for pointers.
You can see that for the dynamic array p gives you the address of the array of pointers, whether *p gives you the value of its first element p[0] which by itself is a pointer to the column. The addresses are definitely different.
But in both cases you can use a[i][j] and p[i][j] to access array elements.
They are not the same. The first (int a[100][100]) is a single variable that is a compound object. The other (int **p) is a collection of arrays that you are using as a data structure for matrices.
If you want to have an actual 2D array in dynamic storage, this is how you do it:
#include <stdlib.h>
int main()
{
int (*m)[100][100];
m = malloc(sizeof *m);
for (int i = 0; i < 100; i++)
for (int j = 0; j < 100; j++)
(*m)[i][j] = 0;
}
Of course, the syntax is a bit weird, and you would rather have a dynamic matrix with variadic number of columns and rows, which is why you would prefer to declare a matrix pointed by int **p.
The reason why a and *a give the same output is because both decay to a pointer to the first element of a, which is a[0][0]. On the other hand, p is a pointer itself, and *p is the contents of the variable pointed by p. They are just as different as they would be if you did this:
int d = 0;
int *p = &d;
printf("%p\n", p);
printf("%d\n", *p);
Now back to your int **p.
Yes, you can access both int a[][100] and int **p with double indexing. However, there is a fundamental difference in the way the compiler treats a[i][j] and p[i][j].
In a[i][j], each a[i] is an array of 100 integer objects. So in order to access the i-th element, and then the j-th element, the compiler has to acess the i*100+j-th element from a[0][0]. This access can be performed in a single step with some index arithmetic.
In v[i][j], each v[i] is a pointer which may point to objects far from each other in memory. In order to acess the element v[i][j], the compiler must first follow p to the array *p, then find the i-th element in this array, which is a pointer to the array p[i]. And then with some pointer arithmetic it will find the j-th element of this array.
a is the address of the array in memory, its value depends on how your compiler and operating system layout memory. *a is the value in memory at that location, again depending on your operating system this is either random or set to some pre-determined value. Similarly for p and *p
For ease of debugging most operating systems set memory to some deliberate fixed value. Unix typically sets malloc() memory to zero. Windows has a range of default contents depending on how the memory was allocated see: When and why will an OS initialise memory to 0xCD, 0xDD, etc. on malloc/free/new/delete?
malloc to initialise the memory allocated, but calloc does.
a declared as int a[100][100];. For this a, *a is not the value in memory at a or any other address. Nominally, *a is the first element of a. That first element is an array of 100 int. In most uses, that array will be automatically converted to a pointer to its first element.malloc does not typically set memory to zero on Unix implementations. When the operating system gives a process memory, it typically sets to zero (if it is not being mapped from a file). The primary purpose for that is to erase any data from other processes, for security, rather than for debugging ease. Consequentially, most of the memory provided by malloc may be zero the first time it is provided. However, after it is used, freed, and reallocated, it is not generally zero. The link you point to is for debugging mode, not normal operation.
int.mallocreturn value of typevoid*and is even undesirable.a, you are really declaring 100 arrays. In this case, it seems that your compiler allocated space for 10,000 ints contiguously. But, when you do the dynamic allocation of p, you have not done that. That's why yourprintfs yield different outputs. Also, note that you should use the%pformat specified with pointers.printf("%p\n", (void*)a);in the first case.ais a 2-D array and treats it so. In the second case the compiler knows thatpis a pointer to an array of pointers, and does the right, but different, thing. Essentially,ais a 1-D array and the compiler figures out the indexing because the memory is contiguous, but in the case ofpthe memory layout is quite different.