• thebluepandabear (15/15) Dec 21 2022 Say you have the following function that takes in a `ref`
• H. S. Teoh (8/26) Dec 21 2022 Yes, a ref parameter is implemented as a pointer in the generated
• =?UTF-8?Q?Ali_=c3=87ehreli?= (14/28) Dec 21 2022 Rather:

thebluepandabear <therealbluepandabear protonmail.com> writes:

Say you have the following function that takes in a `ref` 
parameter:

```D
void modify(ref int num) {
     num += 5;
}
```

Does the compiler turn that into the code below?

```D
void modify(int* num) {
     num += 5;
}
```

I was just wondering whether or not this is the case because I 
don't think this was touched in the book about D I am reading.

"H. S. Teoh" <hsteoh qfbox.info> writes:

On Thu, Dec 22, 2022 at 12:43:28AM +0000, thebluepandabear via
Digitalmars-d-learn wrote:
 Say you have the following function that takes in a `ref` parameter:
 
 ```D
 void modify(ref int num) {
     num += 5;
 }
 ```
 
 Does the compiler turn that into the code below?
 
 ```D
 void modify(int* num) {
     num += 5;
 }
 ```
 
 I was just wondering whether or not this is the case because I don't
 think this was touched in the book about D I am reading.

Yes, a ref parameter is implemented as a pointer in the generated
assembly code.  But that's supposed to be an implementation detail that
you generally shouldn't worry about unless you're working with low-level
operations.


T

-- 
Ph.D. = Permanent head Damage

=?UTF-8?Q?Ali_=c3=87ehreli?= <acehreli yahoo.com> writes:

On 12/21/22 16:43, thebluepandabear wrote:
 Say you have the following function that takes in a `ref` parameter:

 ```D
 void modify(ref int num) {
      num += 5;
 }
 ```

 Does the compiler turn that into the code below?

 ```D
 void modify(int* num) {
      num += 5;

Rather:

   *num += 5;

 }
 ```

 I was just wondering whether or not this is the case because I don't
 think this was touched in the book about D I am reading.

Yes, references are realized by pointers by CPUs; so that's how the code 
is compiled as well.

Pointers are considered to be one of the most difficult concepts for 
beginners (who the book was supposed to target). That's why I tried to 
hold it off as much as possible. I think once the concept of a reference 
is understood, pointers should be easy to understand.

That's why I say "Behind the scenes, D's higher-level concepts (class 
variables, slices, associative arrays, etc.) are all implemented by 
pointers." only later in the book on the pointers page:

   http://ddili.org/ders/d.en/pointers.html

Ali