# incrementing unsigned char *image

In this post, we will see how to resolve incrementing unsigned char *image

## Question:

```void draw(unsigned char *image)
{
for (int y = 0; y < HEIGHT; y++)
{
for (int x = 0; x < WIDTH; x++)
{
if (someCondition)
{
int red = x * 256 / WIDTH;
int green = 255;
int blue = y * 256 / HEIGHT;

image[0] = (unsigned char)blue;
image[1] = (unsigned char)green;
image[2] = (unsigned char)red;
}
else
{
image[0] = 0;
image[1] = 0;
image[2] = 0;
}
image += 3;
}
}
}```
What does incrementing image+=3; actually do here. I’m trying to convert the same c++ code to C#, but unable to achieve this. I’m using byte[] image in C#, now how should I do image+=3 in C#. Is it scaling the image?

From the code it is evident that the pointer points to an element of an array of `unsigned char`:
```[ ][ ][ ][ ] ........... [ ]

^
|
image```
Next consider that `image[i]` is equivalent (really equivalent, that is how it is defined) to `*(image + i)`, ie it increments the pointer by `i` and dereferences it. You can write `image[0]` to get the element `image` points to. You can type `image[1]` to get the next element in the array.
Lets call the actual array `x` then you can access its elements via incrementing `image` like this:
```x[0]      x[1]     x[2]      x[3]          x[4]          x[5]
image[0]  image[1] image[2]
(image+3)[0]  (image+3)[1]  (image+3)[2]```
In other words, the author could have used some `offset` in the outer loop which increments by 3 in each iteration and then instead of `image[ i ]` they would have used `image[ i + offset ]`. Instead they choose to increment `image` which has the same effect.