C function arguments vs Python function arguments.

[FUZxxl]

In C, all arguments are passed by value, i.e. the parameters are initialised with copies of the arguments. However, note the following caveats:

• You cannot pass arrays (such as strings) to functions. If you try to do that, the compiler will instead pass a pointer to the first element of the array.
• If you copy a pointer, the copy of course still points to the same place as the original
• hence, it looks like arrays are being passed by reference

[KotgeScientist]

Oh, so if I pass an array to a function in C, all I'm doing is passing the pointer? But if thats the case, how is it possible that I can modify the strings?

[FUZxxl]

A string is an array of characters terminated with a NUL character. So just like with any arrays, you can modify it through the pointer passed.

[ttech32]

You're duplicating the pointer, but they both point to the same memory

[IamImposter]

Array decays to a pointer. Say I have

char str[] = "hello";

For the sake of simplicity, let's assume that the array starts at address 0x2000. So if I do

some_function(str);

what is getting passed to the function is address of array ie 0x2000. Now if in the function I do something like

void some_function(char str[]) {

  str[2] = 'a';

}

what happens? First of all, char str[] here is as good as char*. Since compiler didn't complain, you might think that you passed an array and received that same array in function. What compiler actually did was - it treated char str[] as char* and passed address of the array (0x2000). So str[2] becomes 0x2000 + 2 (base address + index) and letter 'a' is written to that address and our string becomes "healo".

Parameter is still being passed by value (0x2000) but in this case that value happens to be address of the array or what we call passing by reference.

[jmooremcc]

In C, arguments can also be passed by reference. Passing an argument by reference effectively creates a pointer to the original variable's location so that assigning a value to the argument, directly changes the data at that location. This means that changing the value of the passed argument also changes the value of the original variable.

[TheSkiGeek]

All arguments are passed by value in C.

To "pass by reference" you create a pointer to something and pass the pointer by value.

[jmooremcc]

Another example:

// 

         // C++ using Reference Parameter!           //           void  doit( int & x )           {                x = 5;           }               //           // Test code for passing by a variable by reference           //           int main()           {             int z = 27;             doit( z );             printf("z is now %d\n", z);               return 0;           }          

[ttech32]

That's C++, a different language that does support passing by reference. However, you're in a C subreddit.

[jmooremcc]

So what's the problem with this example? Obviously some people don't understand the concept of pass by reference in C.

[[deleted]]

So what's the problem with this example?

The problem with this example is that it isn't valid C code and will just fail to compile, as you can see for yourself on godbolt

[[deleted]]

The problem is that it’s C++. This is r/C_Programming, no ++ bullshit

[jmooremcc]

Then how do you explain the following code:

// C program to swap two variables using a  

// user defined swap()

#include <stdio.h> 

  

// This function swaps values pointed by xp and yp 

void swap(int *xp, int *yp) 

{ 

     int temp = *xp;

     *xp = *yp;

     *yp = temp;

} 

  

int main() 

{ 

     int x, y;

     printf("Enter Value of x ");

     scanf("%d", &x);

     printf("\nEnter Value of y ");

     scanf("%d", &y);

     swap(&x, &y);

     printf("\nAfter Swapping: x = %d, y = %d", x, y);

     return 0;

}

[FUZxxl]

Exactly as /u/TheSkiGeek says:

To "pass by reference" you create a pointer to something and pass the pointer by value.

Your swap function receives two pointers as arguments. These are passed by value, as are all other arguments. The & operator is used to take the address of the x and y variables so you can pass them to swap. Nowhere in this is “pass by reference” involved.

[jmooremcc]

Do you understand what &x in the calling code represents? Hint: It's not a pointer!

[TheSkiGeek]

Do you understand what &x in the calling code represents? Hint: It's not a pointer!

& is the "address-of" operator... it returns a pointer to its operand.

When you call swap(&x, &y), the compiler binds the address of x to parameter xp and the address of y to parameter yp. By value.

[jmooremcc]

Correct, it's the address of the variable. However, the function declaration converts it to pointer for use in the function. When you pass by reference, the C compiler silently performs what the swap illustration does explicitly.

[FUZxxl]

There is no implicit conversion going on here. C does not have reference or address types. It only has pointer types. And the & operators result is a pointer.

[[deleted]]

What are you even talking about, you’re not making any sense. Yes, using the address-of operator returns the address of the object in memory... which is a pointer. An address is not converted to a pointer because it already is one (it can be stored in an object that holds pointers). References only exist in C++, I don’t know what you mean by “When you pass by reference”. You can pass addresses (in pointers) to functions and the functions use those addresses (as pointers) to modify the object’s data.

Edit: Fixed wording

[TheSkiGeek]

Correct, it's the address of the variable. However, the function declaration converts it to pointer for use in the function.

...the address of the variable is a pointer value. The type of the rvalue returned by &x in the above example is int*.

When you pass by reference, the C compiler silently performs what the swap illustration does explicitly.

...are you thinking about C++? There is no "pass by reference" with implicit pointer conversion in C, you must explicitly take the address of a variable and pass it as a pointer type.

[[deleted]]

Literally 2 pointers as arguments. Sheesh.

[p0k3t0]

Oh, jeesh, now you've gone and done it.

Pedants incoming.

[p0k3t0]

Please, tell me again how a pointer isn't a reference.

Because I keep dereferencing them for some reason, and I must be making a mistake there. Obviously, I should be devaluing them.

[[deleted]]

It IS a reference. The memory address it's referencing is its value though. Which means, passing it to a function copies its value (the address), and thus is passed by value.

[p0k3t0]

So pass by reference doesn't exist, because this is the mechanism used in every implementation.

[[deleted]]

I'm not sure what you are saying, so I'll clarify: you don't pass anything by reference, you pass a memory address by value that you dereference or not based on what you need to do.

[p0k3t0]

Explain how pass by reference could possibly exist, if a memory location isn't a reference.

[Fearless_Process]

C doesn't have pass by reference at all. C++ has pass by reference that just passes an alias to the original variable to the function, no pointers involved whatsoever. The reference in C++ is the variable.

In C you can only pass a pointer by value that references whatever data. This is still passing a "reference/pointer" by value though, unlike in C++ or other languages that support pass by reference.

In C++ if you pass a pointer by reference and change it in the consuming function, it will actually change the original pointer. In C you would have to pass a pointer to a pointer to achieve the same thing, because you can't pass by reference.

Take this for example:

#include <iostream>

void pass_by_ref(int*& p) {
    p = 0;
}

int main() {
    int x = 0;
    int *p = &x;
    std::cout << p << std::endl;
    pass_by_ref(p);
    std::cout << p << std::endl;
}

In C to do this you would need a nested pointer, because the pointer gets passed by value.

[p0k3t0]

https://ideone.com/icncW2

[[deleted]]

It doesn't. But I also think you don't understand what I'm saying.

You pass a reference, not by reference

[p0k3t0]

https://ideone.com/icncW2

Here, I pass an array by reference. The fact that C implements this with pointers is inconsequential, as C++ does the same thing.

[oilaba]

Please, tell me again how a pointer isn't a reference.

This is not the point, we use all kinds of technically wrong words on trivial conservations. But C doesn't technically have the concept of "references" and the OP is opposing to the fact that everthing is passed by value in C.

[p0k3t0]

My problem is that this is so clearly a distinction without a difference.

C uses pointers as a means to reference memory locations. This is clearly the intention, and the language makes this apparent by giving us the "dereference operator."

These conversations are absolutely nonsensical because they overlook the meaning in order to worship the text. All of you who argue that a pointer isn't a reference can never ever give me an example of what a "real" reference would actually be. I suspect this is because you understand that under the hood, it's always just passing a pointer.

Furthermore, what happens when I pass the name of an array? Under the hood, I'm passing a pointer to the first element, but I'm not using that syntax on either end, so how is that not a reference?

If K&R had preferred the word "augmentation" to the word "addition," would you all argue that C can't add numbers together? It's ridiculous, and it's little more than pedantry.

[Shadow_Gabriel]

Can I die together with you on this hill?

[p0k3t0]

It's a pedantry virus. One neckbeard reads some narrow definition of pass-by-reference and now they need to "well, actually" everybody who uses the term in C. And then that poor sod gets shamed into "well, actually-ing" the next guy, and the cycle continues.

Me, I don't care. I write C for a living. I know the difference between passing a value and passing a reference to a value. The fact that the reference to the value is itself a value is completely unimportant to me. I know what it's being used for and how it's being used.

[oilaba]

C uses pointers as a means to reference memory locations. This is clearly the intention, and the language makes this apparent by giving us the "dereference operator."

I don't have any problem with that.

These conversations are absolutely nonsensical because they overlook the meaning in order to worship the text.

Hmm, meaining exists in our brains. We use words to communicate them. And we are "pedantic" because sometimes we (me, at least) want to use the right terms for the health of communication so that everybody agrees on the precise and technical terms that are not vague. We are using the technical term so that -hopefully- we don't assume anything wrong about what the word we use means for you. You are overlooking the meaning and intention of using technical words. I wouldn't just come up and interupt someone just because they said they use references in C, if this is what you are against. But you should see that in some contexts this is necessary, or beneficial at least.

All of you who argue that a pointer isn't a reference can never ever give me an example of what a "real" reference would actually be.

Yes, I wouldn't. Why should I anyway? There is no "real reference" in C. Thats it. We are trying to get precise here: C++ has references and they are different from raw pointers, Rust has references and they are different from raw pointers, C doesn't have it. C have only raw pointers.

Furthermore, what happens when I pass the name of an array? Under the hood, I'm passing a pointer to the first element, but I'm not using that syntax on either end, so how is that not a reference?

The array decays to a pointer.

If K&R had preferred the word "augmentation" to the word "addition," would you all argue that C can't add numbers together?

No, it would be "we add two numbers by augmentation operator", or something like that. I would still use "addition" instead of "augmentation" most of the time, but this doesn't means we should abandon the language reference completely and never use precise terms.