Code review for Image Flip algorithm in C

A few comments:

• you use signed/unsigned types inconsistently. Your width and height are unsigned, while all other integers are signed. If you are using unsigned types because the values can never be negative, then the same applies to all integers in the function and, by that reasoning, they should all be unsigned (size_t is a common type used for sizes). There are arithmetic errors that can occur with mixed signed and unsigned arithmetic, so you should turn on conversion warnings (eg -Wconversion for gcc).

• your naming is inconsistent. The function and the variable rowIndex use "camel-case", while the other variables don't.

• the return from malloc should not be cast in C (C++ requires casting).

• source_offset and target_offset should be defined at the point of first use (ie. within the loop). There is no performance penalty for defining a variable within a loop in C.

• there is no check for success from malloc

Here is a slightly simplified version of the function

void flip_vertically(unsigned char *pixels, const size_t width, const size_t height, const size_t bytes_per_pixel)
{
    const size_t stride = width * bytes_per_pixel;
    unsigned char *row = malloc(stride);
    unsigned char *low = pixels;
    unsigned char *high = &pixels[(height - 1) * stride];

    for (; low < high; low += stride, high -= stride) {
        memcpy(row, low, stride);
        memcpy(low, high, stride);
        memcpy(high, row, stride);
    }
    free(row);
}

You can see that I have changed some types, shortened variable names (it is a short function so short names are appropriate) and simplified the way buffer offsets are calculated to just addition/subtraction.

Just a quick addition to something these already great answers stated but somewhat glossed over. Originally this question had the C++ tag in it. I'm assuming because of this line:

unsigned char* temp_row = (unsigned char*) malloc(row_stride);

that you are compiling this C code as C++ code. Don't do that. While the languages seem very similar and the compiler you are using will probably allow it, it is a bad habit to form. One of the main reasons not to do this is that you won't get certain warnings that you would normally get by compiling this as C code, meaning right now there could be certain vulnerabilities and bugs in your application.

I speak from personal experience.

Just some quick things:

• unsigned int width doesn't need to be const since it's passed-by-value. But that's not really significant as the compiler will optimize away the const if needed.

• Prefer size_t for types representing sizes. It's also useful for loop counters as you'll be able to loop through any size of data supported by your computer. However, you'll receive type-matching warnings if your counter and size types are not both signed or unsigned. In this case, using int (which is a signed type) will cause such warnings if the size type is unsigned.