Some thoughts about C and D, return data through parameters
Petar
Petar
Tue Dec 19 08:54:38 UTC 2017
On Tuesday, 19 December 2017 at 01:01:57 UTC, cosinus wrote:
> Recently I've asked my self why `C` isn't capable of returning
> multiple values at once. And I thought that the
> return-statement was primarally used only for error-handling
> and all the valuable data has been returned through the
> parameter-list.
> If this was true then all `C`-like languages had abused the
> return-statement till now.
>
> This is the way most programmers are doing it:
>
> ```C
> int add(int a, int b);
> // ...
> int c = add(a, b);
> ```
>
> This is the way I think `C` was designed to:
>
> ```C
> int add(int *c, int a, int b);
> // ...
> int c;
> if(add(&c, a, b)) {
> printf("error!");
> }
> ```
>
> This isn't good example but think about how you are doing it
> with huge structs or even arrays.
>
> I think the main reason why most people are using the first
> example is because it looks more like a function in math or you
> need less code to call the function or we think the
> parameter-list is for inputs only.
> But the second one is faster especially with huge junks of
> data. I think a lot of unnecessary allocations has been done
> just to be able to call the function like the first example.
> Think about `std::string` in c++.
>
> So my question is would it be a good idea to have some kind of
> implicit declarations of variables that are used as parameters:
>
> ```D
> int add(decl ref int c, int a, int b);
>
> // ...
>
> // c is unknown here
>
> if(add(c, 123, 456)) {
> writeln("error!");
> }
> // c is implicit declared at the function-call above.
> assert(c == 579);
> ```
>
> The good things out of this are:
>
> * The function becomes easier to be called
> * The variable `c` does not need to be default-initialized to
> keep it save
> * It's like the `auto`-declaration we can already use to
> declare a variable that keeps the return-value
> * It solves the problem with multiple return-values.
>
> [snip]
Reminds me of C#7's out variable declarations:
https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-7#out-variables
However multiple return values are much better implemented
through language-integrated tuples:
https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-7#tuples
More information about the Digitalmars-d
mailing list