通过指针索引分配值

Question

I am writing a program that needs optimization. I have a pointer of n integers and need to save them in different arrays but sharing the memory. My question is:

Is this

int* ptr = (int*)malloc(sizeof(int)*10);
int** ptr2 = (int**)malloc(sizeof(int*)*10);
for (int i = 0; i < 10; ++i) {
    ptr[i] = i;
    ptr2[i] = &ptr[i];
}

equivalent to this?

int* ptr = (int*)malloc(sizeof(int)*10);
int* ptr2 = (int*)malloc(sizeof(int)*10);
for (int i = 0; i < 10; ++i) {
    ptr[i] = i;
    ptr2[i] = ptr[i];
}

I mean, in the second case the value of *(ptr[i]) is copied into *(ptr2[i]) or ptr[i] and ptr2[i] point to the same memory address?

-- EDIT --

The reason I ask is I have a png image saved in an uint8_t* data with R, G and B pixels contiguous, so for example, for the first pixel (R, G, B) = (data[0], data[1], data[2]) , for the second pixel, (R, G, B) = (data[3], data[4], data[5]) and so on. So I need to separate the three channels by storing the values in three different arrays, for obvious reasons I want to share the memory of the values used in the data array and the ones used in the r_channel , g_channel and b_channel . So I don't know if I should declare each channel as uint8_t* or uint8_t** and assign its pixels like shown in the code snippets I posted as examples.

Answer 1

In the following code ptr is an array of integers(dynamically created) and is storing the values from 0 to 10, ptr2 is a integer pointer array where each element ( int * ) points to an element ( int ) of ptr.

 int* ptr = (int*)malloc(sizeof(int)*10); int** ptr2 = (int**)malloc(sizeof(int*)*10); for (int i = 0; i < 10; ++i) { ptr[i] = i; ptr2[i] = &ptr[i]; } 

The following code creates a copy of ptr in ptr2.

 int* ptr = (int*)malloc(sizeof(int)*10); int** ptr2 = (int**)malloc(sizeof(int*)*10); for (int i = 0; i < 10; ++i) { ptr[i] = i; ptr2[i] = &ptr[i]; } 

So in example 2 if the value of an element in ptr changes it won't get reflected in ptr whereas in example 1 if value in ptr changes it would automatically get reflected in prt2 since elements in ptr2 are pointing directly to ptr elements.

If you just want to access the data you can do that using pointer arithmetics eg for nth pixel R = data[3*n+0]; G = data[3*n+1]; B = data[3*n+2]; R = data[3*n+0]; G = data[3*n+1]; B = data[3*n+2];

But if you intend to store it in memory creating a copy seems more logical as it would require less space, since sizeof(uint8_t) <= sizeof(uint8_t *)