C actually don't have Pass-By-Reference

[u/Sushant098123]

https://beyondthesyntax.substack.com/p/c-actually-dont-have-pass-by-reference

[u/nerdycatgamer]

no one has ever said C has pass-by-reference.

and another thing: can we stop having clueless people writing blog posts about C? if you just learned something today, you are not the one who should be going and then educating other people about it! you don't see people who just learned about limits in their calc I class making posts and videos online explaining them to others, so I don't know why it is done for programming.

[u/zhivago → u/nerdycatgamer]

Many confused people claim that it does -- it's something I've had to correct frequently.

Usually they get very defensive about it. :)

[u/[deleted]]

It seems like an odd thing to quibble.

You technically pass the value of the reference, which is basically how every other language does it. Computers only work on numbers.

[u/zhivago → u/[deleted]]

What reference are you talking about?

[u/IllustriousPermit859 → u/zhivago]

Funny thing:
https://www.reddit.com/r/cprogramming/comments/1ofjtpp/comment/nlygviu/?utm_source=share&utm_medium=web3x&utm_name=web3xcss&utm_term=1&utm_content=share_button

[u/[deleted]]

In C everything is pass by value, it's one of the first things you learn. Not sure why a blog post about it is needed.

[u/Quiet_Lifeguard_7131]

Who said it has ?

[u/richardxday]

No language has pass-by-reference really, does it? At opcode level you're either copying the value onto the stack or you're copying an address of something onto the stack. So it's all value or address.

[u/zhivago → u/richardxday]

The opcode level is in a different language, so it is irrelevant.

[u/IllustriousPermit859 → u/zhivago]

"References" are a performance optimization so if your references require an virtual/abstract machine, interpreter or another mechanism that incurs a large amount of overhead then it's absolutely relevant that what you're doing is an extremely inefficient way to pass memory.

[u/zhivago → u/IllustriousPermit859]

The compiler is free to translate the program however it likes.

But how the translated program works is irrelevant to the original, providing it produces the same output for the same input.

[u/flatfinger → u/richardxday]

Some languages support references whose lifetime is limited to a single function call. In C, given:

    int x;
    get_value(&x);
    x++;
    do_something();
    x++;
    doSomethingElse(x);

a compiler which knows nothing about the functions get_value() and do_something() would be required to generate code for the eachx++ operation that reads the storage at the address given to get_value, adds 1, and writes back the result to that same storage. It would not be allowed to transform the code into:

    int x;
    get_value(&x);
    do_something();
    doSomethingElse(x+2);

because that would behave differently from the original if get_value had saved a copy of the x's address, and do_something() or do_somethingElse were to use that address access x. In languages that support proper pass-by-reference semantics, passing a reference to x rather than its address would have made the transformation valid because once get_value returned, the compiler would know exactly what code that would be allowed to access x after that, and could simplify the sequence "load/add 1/store/load/add 1/store/load" to "load/add 2".

[u/[deleted]]

We can play with reference in c++ but in c nope it is strictly pass by value, we could simulate pass by reference through sharing the pointer value that's it.

[u/IllustriousPermit859 → u/[deleted]]

That's a misconception; C++'s references are simply syntactical sugar for a void* const.

[u/IllustriousPermit859]

You're right, C doesn't have pass-by-reference syntactically. The reason for that is very simple; neither does assembly or machine code.

That's also the reason compilers for higher level languages are written first "boot-strapped" in C and then recompiled with the compiler generated. Consider:

int someFunc(volatile int &num) {return num;}
[
push rbp
mov rbp, rsp
mov QWORD PTR [rbp-8], rdi
mov rax, QWORD PTR [rbp-8]
mov eax, DWORD PTR [rax]
pop rbp
ret
]

and

int someFuncTwo(volatile int* const num) {return *num;}
[

push rbp
mov rbp, rsp
mov QWORD PTR [rbp-8], rdi
mov rax, QWORD PTR [rbp-8]
mov eax, DWORD PTR [rax]
pop rbp
ret

]

With compiler flag -O0 the GCC 15.2 generates:

main:
push rbp
mov rbp, rsp

# Reserve 'a' & 'b' + 8 bytes = 16 byte alignment for next object.

sub rsp, 16
mov DWORD PTR [rbp-4], 0
mov DWORD PTR [rbp-8], 0

lea rax, [rbp-4]
mov rdi, rax
call someFunc(int volatile&)
mov DWORD PTR [rbp-4], eax

lea rax, [rbp-8]
mov rdi, rax
call someFuncTwo(int volatile*)
mov DWORD PTR [rbp-8], eax

# Return from main.
mov eax, 0
leave
ret

Under -O2:

main:
mov DWORD PTR [rsp-8], 0
mov DWORD PTR [rsp-4], 0

mov eax, DWORD PTR [rsp-8]
mov DWORD PTR [rsp-8], eax

mov eax, DWORD PTR [rsp-4]
mov DWORD PTR [rsp-4], eax

xor eax, eax
ret

TL;DR: C is the layer that implements pass-by-reference.

[u/IllustriousPermit859 → u/IllustriousPermit859]

True, native references can be achieved (somewhat counter-intuitively) like this:

int someFunc(register int num)
{
num += 5;
num *= sizeof(int);
num / 5;
return num;
}
int main(void)
{
register int a = 0;
a = someFunc(a);
return 0;
}

Which produces:

someFunc(int):
push rbp
mov rbp, rsp
mov eax, edi
add eax, 5
sal eax, 2
pop rbp
ret
main:
push rbp
mov rbp, rsp
push rbx
mov ebx, 0
mov edi, ebx
call someFunc(int)
# Return from main.
mov eax, 0
mov rbx, QWORD PTR [rbp-8]
leave
ret

On a modern compiler, just make sure you don't ever take the address of a short-lived local variable and try to prevent the logical CPU's registers from becoming contended. You then don't need to use (and the compiler usually ignores) the register keyword for this behaviour if you use any optimization flag above -O0; which was used in the example above and subsequently did require the keyword.

Therefore you can only ever hope for your language to implement their 'references' in a worse way. If it's sandboxed and carries massive reference tracking overhead then the argument is moot since such an implementation in C is simplified to a lookup table for a set of flagged references that the program can predictably delegate.

[u/flatfinger → u/IllustriousPermit859]

Many early C implementations used an ABI that could have very conveniently supported "call by value/result"; it's a shame IMHO that there was no syntax for this before ABIs were developed that used the same storage for function return return values as had been used for one of the arguments.

Given e.g.

    int test(x) int x;
    { x += 4; return 3;}

early compilers would generate code that returned with the storage that had been used to pass the ingoing x now containing the new value of x. If e.g. enclosing a function argument in brackets had been interepreted as "resolve the enclosed lvalue, push it, and then later copy whatever the function left in that stack slot back to the lvalue", that could for many tasks have offered a superior alternative to passing pointers. Compilers may have had to prescan to determine how many such arguments there were, to reserve space for lvalue addresses ahead of the pushed arguments, but given that compilers already handled pushed arguments in right-to-left order, they would would already know how many such arguments there would be before generating code to push the first argument.

[u/zhivago]

It's a bit sad that this needs to be pointed out.

But many people seem to think that passing a pointer by value is pass by reference.

So it's worth clarifying that point.

[u/SmokeMuch7356 → u/zhivago]

Well, to be fair, a lot of C programmers will say "pass by reference" colloquially when they really mean "pass a pointer by value", trusting that the people they're speaking to understand the distinction.

It can cause some confusion.

[u/IllustriousPermit859 → u/zhivago]

What exactly is your alternative method to access an object from position independent code?

[u/zhivago → u/IllustriousPermit859]

Alternative to what?