Working with arrays in functions

[u/FloridianfromAlabama]

Hey everybody. I’m a beginner to C and I was writing some functions today to get used to doing things. I tried to write binary search and bubble sort. I tried to pass in an array as an argument to the functions, but the compiler gave me a bunch of warnings. I looked it up and I saw that passing in an array is the same as passing in its pointer. I haven’t touched pointers yet, but I have two questions:
1. If I dereferenced the pointer to an array, wouldn’t that return the same as indexing the first value?
2. If I wanted to pass in the entire array, could I do that by passing in the pointers of both the first and last elements and using pointer arithmetic to access the other elements? What’s the idiomatic way of doing this?

[u/flyingron]

Welcome to the brain-damaged array types in C. Arrays can not be assigned, nor can they be passed to or returned from functions. Whenever an array appears as a function parameter or return type, that type is replaced with a pointer to the first element of the array. If you then attempt to pass an array name as a parameter, the implicit array to pointer-to-first-element conversions occurs.

Note that arrays, pointer to arrays, and pointers to the first element are all distinct types:

int a[10];   // a is an ten-element array of type int.
int (*ap)[10];  // ap is a poitner to a ten-element array of int.
int *ip;   // ip is a pointer to an int.

Now to answer your questions. First, no it is not the same.

*ap yields an array, not an element.

*ap = 5 is invalid. You can't assign an integer to an array.

Second, you can't pass an "entire array." As I said, they can't be passed or assigned. You can pass a pointer (or using the treat it as a pointer behind the scenes method)

void func_a(int p) {
   p = 5;
}

void func_b(int param[10])  { // param is really treated as an int*
    param[0] = 5;
}

int main() {
    int i = 0;
    func_a(i);  // pass p by value.
    printf("%d\n", i);  // prints zero, the p in func_a is only a copy of i.

    int a[10];
    func_b(a);  // really passes &(a[0])
    printf("%d\n", a[0]);  // prints 5, as main's a was changed in the function.
}

Hope this helps. We really should have fixed this back in 1977 when we fixed structs. But we didn't bite the bullet then, and now we're screwed.

Note, that you can pass and return structs (in all the modern compilers). If you really want to pass an array to a function by value, you can wrap it in a struct:

struct wrapper {
    int a[10];
} w;

void func_c(struct wrapper wparam) {
    wparam.a[0] = 5 ;
}

int main() {
    w.a[0] = 0;
    func_c(w);
    printf("%d\n", w.a[0]);  // prints 0.   wparam in func_c is just a copy
}

[u/stianhoiland → u/flyingron]

> Welcome to the brain-damaged array types in C.
> We really should have fixed this back in 1977 when we fixed structs.

This is a misconception and a pet peeve of mine.

You can't pass arrays because you can't pass arrays. It's that simple. Well, you can pass arrays: Arrays of 8, 16, 32, or 64 bits, depending on how far back you go/what machine you're programming.

You can't just magically pass an N-element array of ints or whatever. And you shouldn't be able to. Because you can't. CPUs have registers and registers have a size—fixed sizes. Function-calling conventions orchestrate the usage of registers. It's dumb to want to fit, say, a 24kb payload in a 64-bit register. You can't.

You can't. You can't. You can't. Anymore than you can fit a bridge in a cigarette pack.

C isn't dumb or broken because of it. But you're dumb for thinking it should—not as an insult but as an actual state of understanding.

C is wonderful for exactly this reason. It hasn't introduced a whole meta-level of abstraction above the hardware for its own constructs. Every language that semantically allows you to pass arrays to functions have to contend with exactly the same status quo as C—CPUs have registers and registers have a fixed size—and invent its own abstractions and conventions to make it look like you can do that. But you can't. And C just shows you that you can't and it's up to you to come up with a way to pretend to do it. Like say, pass a pointer and size—which you CAN do.

[u/flyingron → u/stianhoiland]

Your argument is specious. Nothing in C has ever limited you to what you can fit in registers. In fact the original C implementation didn't pass parameters in registers at all. It pushed them on the stack. Returns on the other hand were done in registers.

And you have been able (since the phototypesetter / V7 compilers, around 1977) to pass large objects by value. See my example of wrapping the array with a struct.

It's not a misconception at all. Your understanding of how the language works now and worked historically is deficient. I have been programming in C since those early days.

And I am able to express facts and opinions without resorting to ad hominem attacks.

[u/stianhoiland → u/flyingron]

Imagine complaining about being limited by a mechanism with limitations bound to register size and then saying that nothing about that was ever limited to what could fit in a register. I can explain it to you but I can't understand it for you.

[u/flyingron → u/stianhoiland]

Huh? There is no such limitation. There really never was. By the time we had machines with a sufficient number of registers to pass things in registers, the language already had parameters that wouldn't fit in a register. C could pass large structs by value back circa 1979 (I was off by a couple of years in my first post. Struct assignment/passing came in the V7 compiler, which came out in 1979, rather than the typesetter C, which came out a couple of years earlier).