Do I need to use `uint8_t` to do arithmetics on a `uint8_t` pointer?

Question

I have an array of unsigned 8 bit integer, however the length of this array can be higher than 255. I want to use pointer arithmetics instead of array indexing. Can someone explain me if the following code is acceptable or not? My doubt is that the ind variable has a different type with respect to buff and this might be seen as bad programming.

#include <stdio.h>
#include <stdint.h>

int main(){
    uint8_t buff[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int16_t ind;
    
    ind = 1;
    
    printf("%u\n", *(buff + 1));
    printf("%u\n", *(buff + ind));
}

Godbolt shows a small difference between *(buff + 1) and *(buff + ind) but it seems to work.

Answer 1

Most types are converted to int before doing arithmetics (especially for pointer arithmetics), so whether you use uint8, uint16 or uint32 for ind has little consequence.

what you are doing is adding something to the pointer, which is an address (on 32 or 64 bits), meaning the type pointed by it (uint8_t in your case) has absolutely no effect on the type of the pointer.

However, do remember that the size of the object pointed matters a lot in pointer arithmetics, since it will not move byte per byte but object by object.

uint8_t *char_ptr = 0x1000;
uint32_t *int_ptr = 0x1000;

char_ptr += 1;
int_ptr += 1;

printf("0x%x", char_ptr); // 0x1001
printf("0x%x", int_ptr);  // 0x1004

 

Answer 2

array indexing is already pointer arithmetic as buff[i] is defined as *(buff+i). But the former is easier to read (and understand).

I also do not understand that whole 255 limit as the maximum value for an array index has nothing to do with the type of the array, only with its size.

An array index is always of type size_t which is an unsigned integer type able to hold any possible array index. If you use any other integer type as the index, the compiler will silently convert that value to a size_t.

So no you do not need to use uint8_t to do arithmetic on a uint8_t*.

Answer 3

Can someone explain me if the following code is acceptable or not?

It's OK but it would be more correct to use size_t instead of int16_t. This is the integer type used to describe the size of things, including arrays. Whereas int16_t is a small, signed type.

---

I want to use pointer arithmetics instead of array indexing

Why? The only thing you achieve with that is to make the code less readable. Array indexing is the same as pointer arithmetic, it is just "syntactic sugar". Please study Do pointers support “array style indexing”?.

---

As a side note, the correct printf format specifier for uint8_t is PRIu8 from inttypes.h, not %u. So your code should be changed to:

printf("%" PRIu8 "\n", buff[1]);

or

printf("%u\n", (unsigned int)buff[1]);