Thanks for the correction. As I wrote in the introduction, there will be some errors in these beta-version chapters that are published on the blog (as I, obviously, don't have correctors and reviewers), so I'm thankful to all who notice and point those.
> it's totally wrong to say that passing by reference is just syntactic sugar
OK, I'd say that it's still syntactic sugar with some benefits :) But I don't agree that it's totally wrong. Some of the things you mentioned are just side-effects (that you can't do pointer arithmetic or pass a null pointer. Actually, it seems that you can with some jiggling: https://stackoverflow.com/questions/8571078/pass-by-pointer-...). The point I wanted to make is that pass-by-reference is mostly the same thing. It's, actually, quite a confusing topic (as are many C++ solutions) that was not properly presented to me when I stduied it in school, and this book neither tries to present it, but I had to, at least, mention it here as I was talking about different passing styles.
type
Point = record
x, y : integer
end;
procedure ByPointer(p : ^Point);
begin
p^.x := 12
end;
procedure ByReference(var p : Point);
begin
p.x := 12;
p.y := 33
end;
procedure example
var
p : Point
begin
p.x := 23;
p.y := 28;
WriteLn('The point is ', p.x, ' ', p.y);
ByPointer(@p)
WriteLn('The point is ', p.x, ' ', p.y);
p.x := 23;
p.y := 28;
WriteLn('The point is ', p.x, ' ', p.y);
ByReference(p)
WriteLn('The point is ', p.x, ' ', p.y);
end;
Actually the concept is already exposed in Algol, a couple of years before C was even an idea.I should have provided a better example, this is impossible to do languages like Java and in C requires explicit double indirection to fake how reference types work.
type
Point = record
x, y : integer
end;
procedure ByPointer(p : ^Point)
begin
New(p);
p.x := 12
end;
procedure ByReference(var p : ^Point)
begin
if p <> nil then
Dispose(p)
end;
New(p);
p^.x := 12;
p^.y := 33
end;
procedure example
var
p : ^Point
begin
New(p);
p^.x := 23;
p^.y := 28;
WriteLn('The point is ', p^.x, ' ', p^.y, ' at ', p);
ByPointer(p)
WriteLn('The point is ', p^.x, ' ', p^.y, ' at ', p);
p^.x := 23;
p^.y := 28;
WriteLn('The point is ', p^.x, ' ', p^.y, ' at ', p);
ByReference(p);
WriteLn('The point is ', p^.x, ' ', p^.y, ' at ', p); (* here p will point to the one allocated in ByReference *)
Dispose(p);
end;Where? I see only syntax sugar. The catchy phrase from the Google C++ style guide is stuck in my head: references have value syntax but pointer semantics. And that's it (and that's why I think references are mostly a bad idea).
> C requires explicit double indirection
Your 2nd example is no different, it's still just "indirection" (value syntax but pointer semantics!). If what you are indirecting is itself a pointer type (as in your 2nd example), then yes, there technically is a "double indirection", but that's besides the point.
> impossible to do in languages like Java
actually, "in every memory safe language there is". You can do this in Pascal because Pascal is really just C-style systems programming. With a few features like references and ARC that pretend otherwise but quickly fall flat on their head.
Here is my example in C#. So now C# is unsafe?
class Point
{
public int x, y;
}
static class CSharpIsUnsafe {
static void ByPointer(Point p)
{
p = new Point();
p.x = 12;
}
static void ByReference(ref Point p)
{
p = new Point();
p.x = 12;
p.y = 33;
}
public static void Main(string[] args)
{
p = new Point();
p.x = 23;
p.y = 28;
Console.WriteLn($"The point is {p.x} {p.y}");
ByPointer(p)
Console.WriteLn($"The point is {p.x} {p.y}");
p.x = 23;
p.y = 28;
Console.WriteLn($"The point is {p.x} {p.y}");
ByReference(ref p);
Console.WriteLn($"The point is {p.x} {p.y}");
}
}1) under the hood stores an (object) reference to the lowest structural ancestor that is GC'ed, as well as an offset from that object to the ref'ed property.
2) is itself GC'ed
Escape analysis might in some cases optimize out the GC'ing of the ref, but that of course doesn't work if the ref does escape.
Something like that, but in any case it's something very different than the Pascal/C++ examples we've talked about.
Easy to check with VS Assembly visualizer or WinDbg alongside SOS.dll.
D, Ada, CLU, Mesa, Mesa/Cedar, Algol, PL/I, PL/S, PL.8, Delphi, Dylan, .NET, Swift, Oberon, Oberon-2, Component Pascal, Active Oberon, QuickBasic, Turbo Basic are just a couple of examples of languages allowing for pass by value and pass by reference, some of them also quite safe.
And then there is also call by name introduced alongside Algol.
Wait, what? Tuples aren't sum types, they're product types. Like, they're the "cartesian product" of some other types. A sum type would be like a tagged union (or Rust enum) where something can be either one type or the other. I haven't studied a lot of algebraic type theory, but Wikipedia agrees with me on that point [0]
Seems like a fairly elementary mistake in an article of this kind...
EDIT: also, this, a few paragraphs down:
> Moreover, in C++ the pass-by-reference has two flavors: pass the pointer (a common approach) and pass by what's actually called a reference, which is a syntax sugar over pointers that allows accessing the argument with non-pointer syntax (dot instead of arrow)
Pass-by-reference in C++ is most certainly not just syntactic sugar for passing in a pointer. A compiler may implement it that way (or it may not), but it's totally wrong to say that passing by reference is just syntactic sugar so you don't have to use arrow notation. The most obvious differences is that a reference can never be null, it can't be changed to point to some other object, you can't do pointer arithmetic to it and you always dereference it when use it. Also: in idiomatic C++, "passing by reference" is far more common than "passing by pointer".
I'm going to stop reading this article now. I don't have a lot of faith that this person really knows what they're talking about.
[0]: https://en.wikipedia.org/wiki/Algebraic_data_type