- C language
- Basic grammar
- here
Pointer operation
The C language has a function called pointer operation that can advance the position of an address based on the width of the data type.
This is often used in practice to advance the position of each element of an array one by one, so first pointer and arrays.
Relationship between arrays and pointers in C
In C, accessing the elements of an array is syntactic sugar for pointer arithmetic. First of all, please feel that you can access the memory area allocated by calloc function as an array.
#include <stdint.h> #include <stdio.h> #include <stdlib.h> int main (void) { // Represent an array using pointers int32_t nums_length = 10; int32_t * nums = calloc (sizeof (int32_t), nums_length); // Assign to an array element nums [2] = 5; // Output array elements printf("nums [2]:%d\n", nums [2]); // Set element values using pointer operations * (nums + 2) = 7; // Output array elements printf("nums [2]:%d\n", nums [2]); // Output element values using pointer operations printf("* (num2 + 3):%d\n", * (nums + 2)); free (nums); }
Output result.
nums [2]: 5 nums [2]: 7 * (nums + 2): 7
See that "nums [2]" is syntactic sugar for "* (nums + 2)".
nums represents the start address of memory allocated by calloc.
The entity is acquired by "* (nums + 2)". The acquisition of the entity is explained in pointer.
Take a look at pointer operations
Pointer operation advances the address by multiplying the specified value by the value in units of the size that can be obtained by sizeof operator.
The operation "nums + 2" seems to add 3, but since num2 is a int32_t type, it is actually "sizeof (" int32_t) * 3 ”will increase.
Let's actually output it. The address can be output with the "%p" format specifier. It is output in hexadecimal.
#include <stdint.h> #include <stdio.h> #include <stdlib.h> int main (void) { // Represent an array using pointers int32_t nums_length = 10; int32_t * nums = calloc (sizeof (int32_t), nums_length); printf("nums:%p\n", nums); printf("nums + 1:%p\n", nums + 1); printf("nums + 2:%p\n", nums + 2); printf("nums + 3:%p\n", nums + 3); free (nums); }
This is the output result in my environment. Since the size of int32_t obtained by the sizeof operator is 4, the address increases in units of this.
nums: 0x4538010 nums + 1: 0x4538014 nums + 2: 0x4538018 nums + 3: 0x453801c
Also try int64_t to see the difference.
#include <stdint.h> #include <stdio.h> #include <stdlib.h> int main (void) { // Represent an array using pointers int64_t nums_length = 10; int64_t * nums = calloc (sizeof (int64_t), nums_length); printf("nums:%p", nums); printf("nums + 1:%p, nums + 1); printf("nums + 2:%p, nums + 2); printf("nums + 3:%p, nums + 3); free (nums); }
This is the output result. Since the size of int64_t obtained by the sizeof operator is 8, the address will increase in units of this.
nums: 0x6c39010 nums + 1: 0x6c39018 nums + 2: 0x6c39020 nums + 3: 0x6c39028
Is there any reason to use pointer arithmetic when it can be accessed as an array?
Well, not much. I think the array is more intuitive and readable.
Pointer operation sample
As a sample for frequent use, I will write a thing to access the characters contained in the string in order.
Since the character string in C language ends with "\ 0", I sometimes write that the pointer points to the character position and processes in order.
#include <stdint.h> #include <stdio.h> int main (void) { // string const char * message = "Hello World!"; // Get the address at the beginning of the string const char * ch_ptr = message; // Repeat until the value pointed to by the pointer becomes \ 0 while (* ch_ptr! ='\ 0') { // 1 character output printf("%c", * ch_ptr); // Advance the pointer ch_ptr ++; } printf("\ n"); }
This is the output result.
Hello World!