How to use pointers properly in C?

Question

I have this code that is supposed to find the smallest integer in an array. I am learning how to use pointers in C, and my code will not compile, but I do not know why. Rather than just the answer, I'd like to know why I am doing wrong or how is my thought process wrong.

I thought that *p_min will return the value inside the address.

The errors I get:

error: invalid type argument of ‘unary *’ (have ‘int’)

Warning: return makes pointer from integer without a cast

p is declared outside the function as int *p;

Code:

int *find_smallest(int a[], int N)
{
    int *p_min;

    for (p = &a[0]; p < &a[N]; p++)
    {
        if (*p[1] < *p[0]) {
            p_min = &p[1];
            return *p_min;
        } else {
            p_min = &p[0];
            return *p_min;
        }
    } 
}

Answer 1

Not really sure what you're doing with the comparison logic. The most straightforward approach is to start with the first element, then check the rest sequentially, keeping the index of the smaller one. My code would be something like this:

int *find_smallest(int a[], int N)
{
    /* Make sure the input is valid */
    if (a && N > 0)
    {
        int i, N_min = 0;
        /* Check the rest of the elements */
        for (i = 1; i < N; i++)
        {
            /* If this one is lower, save the index */
            if (a[i] < a[N_min])
                N_min = i;
        }
        /* Return pointer to minimum */
        return a + N_min;
    }
    /* Return NULL to indicate an error */
    return NULL;
}

Answer 2

• *p[1] < *p[0] should be *(p+1) < *p or p[1] < p[0].
• The return type should be int.
• You unconditionally return after one pass of the loop.
• You never declared p.
• Note that &a[i] can be written a+i.
• You should be comparing p[0] (aka *p) and *p_min, not p[0] and p[1].
• p[1] might even be beyond the end of the array!
• You don't initialize p_min.
• There's no reason to have int* p_min; instead of int min;.

Fixed:

int find_smallest(int a[], int N) {
    int min = a[0];  // Assumes a[] will have at least one element.
    for (int* p=a; p<a+N; ++p) {
        if (*p < min) min = *p;
    } 

    return min;
}

Or just:

int find_smallest(int a[], int N) {
    int min = a[0];  // Assumes a[] will have at least one element.
    for (int* p=a; N--; ++p) {
        if (*p < min) min = *p;
    } 

    return min;
}

Alternatively, one could use an index instead of a pointer.

int find_smallest(int a[], int N) {
    int min = a[0];  // Assumes a[] will have at least one element.
    for (int i=0; i<N; ++i) {
        if (a[i] < min) min = a[i];
    } 

    return min;
}

Or just:

int find_smallest(int a[], int N) {
    int min = a[0];  // Assumes a[] will have at least one element.
    for (int i=N; i--; ) {
        if (a[i] < min) min = a[i];
    } 

    return min;
}

Answer 3

There are lots of problems (and places to improve on) this code. It's very confusing, so I'm not entirely sure what you're trying to do, but I'll point out some places you should start.

• Just a warning, if you want to modify the array, find_smallest(int a[], int N) will not do*, You need something like find_smallest(int (*a)[], int N);, which you would then access like (*a)[some_index].
• Your function says it's returning a int *, but the two returns I see have int values.
• Where is p declared?
• Why do you need to use &a[0] instead of just a[0], if all you're doing is finding the smallest value in the array?
• You keep trying to access *a[some_index]. It looks like you meant to pass it as I stated. Accessing it as *a[some_index] will result in all kinds of errors, you'll need to write something like (*a)[some_index]. That's how C recognizes pointers.
• If either way you're returning *p_min, you shouldn't put the returns in the if-statements, as it'll just slow down the compiler and waste space.

^{* If you pass it like int a[], the function will only have a local copy of the variable, and will not be able to modify it. This'll result in a lot of confusing errors, so if you want to develop your function into anything bigger, this is something to consider.}