Today we mainly talk about the cognition of arrays .

Today, everyone should also be happy .

Catalog

Memory allocation in array

Is the memory allocation of the array the same as that of the pointer ？ Is it also increasing from low address to high address ？

So what happens if you create a variable set in the form of an array ？

&a[0] and &a difference

sizeof Use

  Understand the next pointer +1 Size

General pointer

What if forced conversion happens ？

What if it's a pointer above level 2 ？

  Array elements +1 Result

Why is the address of the first element the same as that of the whole element ？

Left and right values of array names

First, the array name can be used as the right value , Look at an example ：

Can variable names be lvalues ?

Next up ：

Memory allocation in array

Is the memory allocation of the array the same as that of the pointer ？ Is it also increasing from low address to high address ？

    int a = 10;
	int b = 20;
	int c = 30;
	
	printf("&a = %p\n", &a);
	printf("&b = %p\n", &b);
	printf("&c = %p\n", &c);

Every address here is from Decreasing from high to low Of , In essence, it's because a First in stack , First create , And because of The storage structure of the stack area leads to , In this regard, we will talk about stack frame in detail later , Here is a simple diagram for you to understand ：（ First use the high address of the stack area ）

So what happens if you create a variable set in the form of an array ？

Let's say char An example of an array of types ：

#define NUM 10
int main()
{
	char arr[NUM] = { 0 };
	for (int i = 0; i < 10; i++)
	{
		printf("arr[%d] = %p\n", i, &arr[i]);
	}
	return 0;
}

We can see that The address of the array is incremented , It is different from the above method of creating variables . Because the space of the array is linearly continuous and increasing , When opening up space, it is to open up space as a whole and release it as a whole , And when opening up , yes The first element is the lowest address .

&a[0] and &a difference

sizeof Use

First, let's add sizeof The rest of the knowledge ：

sizeof(a): yes sizeof Put the array name separately in the , Represents the size of the entire array .

sizeof(&a)： At this time, the address of the whole array is taken out .

sizeof(&a[0])： What is taken out is the address of the first element of the array .

  Understand the next pointer +1 Size

First of all, why do you want to talk about this ？ Because we'll be right later Add... To the address of the array 1 Influence .

General pointer

	char *a = NULL;
	short *b = NULL;
	int *c = NULL;
	double *d = NULL;

	printf("%d\n",a);
	printf("%d\n\n",a+1);
	
	printf("%d\n", b);
	printf("%d\n\n", b + 1);

	printf("%d\n", c);
	printf("%d\n\n", c + 1);
	
	printf("%d\n", d);
	printf("%d\n\n", d + 1);

  This is the result and the relative pointer plus one , This is related to the pointer type . Add one... To the pointer , The essence is to add the size of the type pointed to .（ Do not consider forced type conversion ）. 

What if forced conversion happens ？

If there is a forced conversion , It depends on the type of forced conversion .

What if it's a pointer above level 2 ？

int main()
{

	double ******d = NULL;
	printf("%d\n", d);
	printf("%d\n\n",d + 1);
	return 0;
}

Multi level pointer +1 The back will only move backward 4 Bytes , Because the pointer variables of level 2 and above , It's all addresses , The address in 32 All of you are 4 Bytes , So it only moves backward 4 Bytes .

  Array elements +1 Result

After talking about the step size of the above pointer , It's better to understand the problem of array step size .

Look at an example ：

    char a[NUM] = { 0 };

	printf("%p\n", &a[0]);
	printf("%p\n", &a[0]+1);

	printf("%p\n", &a);
	printf("%p\n", &a+1);

First we can see , The address of the first element of the array is the same as that of the whole array . First element address +1, It's backward +1 The size of the first element type , The address of the entire array +1, Is to move the entire array size backward . Essentially different types , Because the type of the first element is different from that of the whole array .

Why is the address of the first element the same as that of the whole element ？

The first thing to know is , All address fetching operations , Whether it's plastic surgery , floating-point , Or structure , Including arrays , Are the smallest of many address values . Then the address of the first element of the array is the lowest , Then take the address of the first element , And the address of the whole element , But they are of different types ,+1 The results are different .

Left and right values of array names

First, the array name can be used as the right value , Look at an example ：

    char arr[NUM] = { 0 };
	char *p = arr;

	printf("%p\n", p);
	printf("%p\n", arr);
	
	return 0;

  Here we can see that the variable name is the right value , Is to assign the first element address to the variable p 了 , That's ok （ Out-of-service &arr, Different types ）

Can variable names be lvalues ?

    int arr[NUM] = { 0 };
	arr = { 1, 2, 3, 4, 5 };

 j

  First , Variables should have space , Arrays are no exception , There is also space , however Array names cannot be lvalues , Because in C In language , Array cannot be assigned as a whole , Can only be initialized as a whole . therefore , Can't assign a value , You can't do lvalue .

Next up ：

In the next issue, we'll talk about pointers and arrays ” close “ Relationship

The next issue is more exciting ~！~！~！