One of the most confusing things for me in D or any C style language (curly braces and such) is the use of stars * here and there and what there placement means...

for example i know that *MyString would indicate a pointer to MyString if my guess is correct.

but theres many instances where it is used such as in function params and in constant declares, immediately before, after or with a space, where i dont understand there usage, theres even double stars ** here an there...

Would someone be so kind as to write a short tutorial on what the placement of a star means in context to where its used? and how it affects passing by reference, by value, or by pointer etc... maybe a few short examples of how it would be used.

This would be very appreciated and i would be grateful !

On Sat, 20 Dec 2003 04:19:24 -0500, Lewis wrote:
> One of the most confusing things for me in D or any C style language (curly braces and such) is the use of stars * here and there and what there placement means...

"*"'s are the pointer declaration/dereference character in C, C++ and D. They are also the multiplication operator.  The placement decides whether they are being used as one or the other.  Generally, the "*" means multiply when it doesn't:

    - Follow a type (e.g. "int *", "char *", etc.)
    - Come before a pointer variable

Whitespace doesn't really matter.

To give you a code example:

> int i = 1;
> int i2 = 2;
> int* i_ptr = &i;  // "i_ptr" is a pointer to "i"
>
> i = i * i2; // i = i (multiplied by) i2
> i2 = * i_ptr; // i2 = (The value pointed to by i_ptr)

To declare a pointer you place a "*" before the variable name, any of the following are valid pointer declarations:

> int* i;
> int * i;
> int *i;

To make the pointer actually point to something you need to assign it a reference, this is done by placing the "&" character before a variable name:

> int i = 123;
> int* ptr = &i; // "ptr" points to "i"

To access the value pointed to by a pointer you need to dereference it, this is done by placing a "*" before the pointers name:

> printf( "%d", ptr ); // Will print the memory address that
>                      // "ptr" points to, e.g. "-1073743116"
> printf( "%d", *ptr ); // Will print "123"


> for example i know that *MyString would indicate a pointer to MyString if my guess is correct.

"*MyString" is a pointer /called/ "MyString", not a pointer /to/ "MyString".  Pointers are just variables like everything else and they share the same namespace(?), so you can't have:

> int MyInt;
> int *MyInt;

It's easier if you use the D type declaration [http://www.digitalmars.com/d/declaration.html] (which is also valid in C), where the "*" comes after the type instead of before the variable name:

> int* MyInt;

> but theres many instances where it is used such as in function params and in constant declares, immediately before, after or with a space, where i dont understand there usage, theres even double stars ** here an there...

Pointers are typically used in function params so that a variable is passed by reference rather than value.  That way you can modify the variable from within the function and not have to return it so that the caller can use it in it's modified state.  Basically, they are used to achieve what D's out/inout function parameters [http://www.digitalmars.com/d/function.html] do.

As an example, consider the following function:

> void myFunc( int i )
> {
>     i = i+1;
> };

As it stands at the moment it does nothing (at least from the callers perspective).  But if we change it to:

> void myFunc( int* i )
> {
>     *i = *i+1;
> };

It will increment any integer passed to it (by reference) by one, like so:

> int i = 1;
> myFunc( &i );
> printf( "i = %d\n", i ); // Prints: "i = 2"

Double "*"'s just indicate a pointer to a pointer.

> Would someone be so kind as to write a short tutorial on what the placement of a star means in context to where its used? and how it affects passing by reference, by value, or by pointer etc... maybe a few short examples of how it would be used.

Some good tutorials on pointers in C are:

http://pw1.netcom.com/~tjensen/ptr/pointers.htm http://cplus.about.com/library/weekly/aa010502a.htm http://www.lysator.liu.se/c/bwk-tutor.html#pointers http://vergil.chemistry.gatech.edu/resources/programming/c-tutorial/pointers.html

> This would be very appreciated and i would be grateful !

As someone else who's been confused by the concept of pointers before, I hope the above is helpful (and correct! If not I'm sure one of the local guru's will correct me).

Very helpful adam, thanks alot... you have answered alot of questions for me.
regards
Lewis


Adam Harper wrote:

> On Sat, 20 Dec 2003 04:19:24 -0500, Lewis wrote:
> 
>>One of the most confusing things for me in D or any C style language
>>(curly braces and such) is the use of stars * here and there and what
>>there placement means...
> 
> 
> "*"'s are the pointer declaration/dereference character in C, C++ and D.
> They are also the multiplication operator.  The placement decides whether
> they are being used as one or the other.  Generally, the "*" means
> multiply when it doesn't:
> 
>     - Follow a type (e.g. "int *", "char *", etc.)
>     - Come before a pointer variable
> 
> Whitespace doesn't really matter.
> 
> To give you a code example:
> 
> 
>>int i = 1;
>>int i2 = 2;
>>int* i_ptr = &i;  // "i_ptr" is a pointer to "i"
>>
>>i = i * i2; // i = i (multiplied by) i2
>>i2 = * i_ptr; // i2 = (The value pointed to by i_ptr)
> 
> 
> To declare a pointer you place a "*" before the variable name, any of the
> following are valid pointer declarations:
> 
> 
>>int* i;
>>int * i;
>>int *i;
> 
> 
> To make the pointer actually point to something you need to assign it a
> reference, this is done by placing the "&" character before a variable
> name:
> 
> 
>>int i = 123;
>>int* ptr = &i; // "ptr" points to "i"
> 
> 
> To access the value pointed to by a pointer you need to dereference it,
> this is done by placing a "*" before the pointers name:
> 
> 
>>printf( "%d", ptr ); // Will print the memory address that
>>                     // "ptr" points to, e.g. "-1073743116"
>>printf( "%d", *ptr ); // Will print "123"
> 
> 
> 
>>for example i know that *MyString would indicate a pointer to MyString if
>>my guess is correct.
> 
> 
> "*MyString" is a pointer /called/ "MyString", not a pointer /to/
> "MyString".  Pointers are just variables like everything else and they
> share the same namespace(?), so you can't have:
> 
> 
>>int MyInt;
>>int *MyInt;
> 
> 
> It's easier if you use the D type declaration
> [http://www.digitalmars.com/d/declaration.html] (which is also valid in
> C), where the "*" comes after the type instead of before the variable name:
> 
> 
>>int* MyInt;
> 
> 
>>but theres many instances where it is used such as in function params
>>and in constant declares, immediately before, after or with a space,
>>where i dont understand there usage, theres even double stars ** here an
>>there...
> 
> 
> Pointers are typically used in function params so that a variable is
> passed by reference rather than value.  That way you can modify the
> variable from within the function and not have to return it so that the
> caller can use it in it's modified state.  Basically, they are used to
> achieve what D's out/inout function parameters
> [http://www.digitalmars.com/d/function.html] do.
> 
> As an example, consider the following function:
> 
> 
>>void myFunc( int i )
>>{
>>    i = i+1;
>>};
> 
> 
> As it stands at the moment it does nothing (at least from the callers
> perspective).  But if we change it to:
> 
> 
>>void myFunc( int* i )
>>{
>>    *i = *i+1;
>>};
> 
> 
> It will increment any integer passed to it (by reference) by one, like so:
> 
> 
>>int i = 1;
>>myFunc( &i );
>>printf( "i = %d\n", i ); // Prints: "i = 2"
> 
> 
> Double "*"'s just indicate a pointer to a pointer.
> 
> 
>>Would someone be so kind as to write a short tutorial on what the
>>placement of a star means in context to where its used? and how it
>>affects passing by reference, by value, or by pointer etc... maybe a few
>>short examples of how it would be used.
> 
> 
> Some good tutorials on pointers in C are:
> 
> http://pw1.netcom.com/~tjensen/ptr/pointers.htm
> http://cplus.about.com/library/weekly/aa010502a.htm
> http://www.lysator.liu.se/c/bwk-tutor.html#pointers
> http://vergil.chemistry.gatech.edu/resources/programming/c-tutorial/pointers.html
> 
> 
>>This would be very appreciated and i would be grateful !
> 
> 
> As someone else who's been confused by the concept of pointers before, I
> hope the above is helpful (and correct! If not I'm sure one of the local
> guru's will correct me).
> 

"Adam Harper" <a-news-d@harper.nu> wrote

<snip>
>
> "*"'s are the pointer declaration/dereference character in C, C++ and D.
>
<snip>

Just as an aside I like to think of "*" as a dereference operator only.

That way in a declatation:

int * foo ;

can be thought of as 'foo' dereferenced once is an int, so foo must be a pointer to an int.  Another example is in a function definition or declaration

int oof( float * rab ) ;

then rab, when derefernced, is a float, so rab must be a pointer to a float.

In this way you can decode complicated declarations like this

int * (*bar)() ;

Then you can think of 'bar' when dereferenced once is a function, so 'bar' must be a pointer to a function.  Again, when the return value is dereferenced  it is an int, so it must retrun a pointer to an int.

In this way, you can decode any declaration by working from the inside out.

Mark.

Adam Harper wrote:
<snip>
>> myFunc( &i );
</snip>

Adam, i noticed you used the Ampersand there, so the &'Variable' is the dereferencing operator?

as in myFunc( Address Of i ) or myFunc( Pointer to i )

This has been a most useful thread here...

Lewis wrote:

> Adam Harper wrote:
> <snip>
> >> myFunc( &i );
> </snip>
>
> Adam, i noticed you used the Ampersand there, so the &'Variable' is the dereferencing operator?
>
Actually the & operator is the referencing symbol, in that you get the reference from the variable.  Ie you get the owner of the variable.  If you want the variable again, you must dereference it using *.

int x;
int *t = &x; //Now I have the reference of x
int g = *x; //Now I have the value of x

You might what think about it like looking up a phone number in a book, once someone gives you the name of the person (reference), you can get the person (value) by dereferencing (*).  Now say you've got the phone number, and you need to get the reference to the phone number, then you'd use &.

In my experience allot of people have problems with understanding pointer initially. They are really very simple once you start to use them, it's all the terms that muddle people up. I've probably just muddled your thinking again, whoopsie.

There's lots of info on the web about it.

http://cslibrary.stanford.edu/106/

> as in myFunc( Address Of i ) or myFunc( Pointer to i )
>
> This has been a most useful thread here...
>

J Anderson wrote:
> Lewis wrote:
> 
>> Adam Harper wrote:
>> <snip>
>> >> myFunc( &i );
>> </snip>
>>
>> Adam, i noticed you used the Ampersand there, so the &'Variable' is the dereferencing operator?
>>
> Actually the & operator is the referencing symbol, in that you get the reference from the variable.  Ie you get the owner of the variable.  If you want the variable again, you must dereference it using *.
> 
> int x;
> int *t = &x; //Now I have the reference of x
> int g = *x; //Now I have the value of x
> 
> You might what think about it like looking up a phone number in a book, once someone gives you the name of the person (reference), you can get the person (value) by dereferencing (*).  Now say you've got the phone number, and you need to get the reference to the phone number, then you'd use &.
> 
> In my experience allot of people have problems with understanding pointer initially. They are really very simple once you start to use them, it's all the terms that muddle people up. I've probably just muddled your thinking again, whoopsie.
> 
> There's lots of info on the web about it.
> 
> http://cslibrary.stanford.edu/106/
> 
>> as in myFunc( Address Of i ) or myFunc( Pointer to i )
>>
>> This has been a most useful thread here...
>>
> 

thanks for the info, very useful...

regards
lewis

ive notice there is no way to assign a literal to pointer, is there a reason this isnt allowed?

//for example id like to do the following:

int Test(int* Value) {
     return *Value + 1;
}

//and then call it like so:

int result;
result = Test(&cast(int)22);
//or
result = Test(&22);

//or another thing i noticed you cant do

int* MyPtr = &34;

//then you could just:
 *MyPtr = *MyPtr + 22;

is there a special reason why a person cant do this? or can it be made so we can  ;)

Lewis wrote:

> ive notice there is no way to assign a literal to pointer, is there a reason this isnt allowed?
>
> //for example id like to do the following:
>
> int Test(int* Value) {
>      return *Value + 1;
> }
>
> //and then call it like so:
>
> int result;
> result = Test(&cast(int)22);
> //or
> result = Test(&22);


This code does not make sense as a literal doesn't have a location in memory (per say).  Your not archiving anything with the code you just gave.

However in C++ you could do:

int result = Test(new int(22));  //Not D code

But then you'd also have to handle deletion (delete) of the new in created inside the Test function (yuck). If this was made available in D the garbage collection would take care of that. However,

int Test(int Value) {
   return Value + 1;
}

int result = 22;
result = Test(result);

Is much better.

>
> //or another thing i noticed you cant do
>
> int* MyPtr = &34;
>
> //then you could just:
>  *MyPtr = *MyPtr + 22;
>
> is there a special reason why a person cant do this? or can it be made so we can 


Again, a literal doesn't have a memory location. Why do you need to change the value 34? How can you access the value 34?

In C++ you could do:

int* MyPtr = new int(34); //Not D code

Still,

int t = 34;
int* MyPtr = &t;

Is almost as good.

Furthermore you don't need pointers that often (particularly in D). The code you just wrote could be simplified to:

int t = 34;
t += 22;

Try to avoid pointers where you can.  They have all kinds of side effects. Having said that they can be useful in some exceptional circumstances and in arrays.

J Anderson wrote:

> Lewis wrote:
> 
>> ive notice there is no way to assign a literal to pointer, is there a reason this isnt allowed?
>>
>> //for example id like to do the following:
>>
>> int Test(int* Value) {
>>      return *Value + 1;
>> }
>>
>> //and then call it like so:
>>
>> int result;
>> result = Test(&cast(int)22);
>> //or
>> result = Test(&22);
> 
> 
> 
> This code does not make sense as a literal doesn't have a location in memory (per say).  Your not archiving anything with the code you just gave.
> 
> However in C++ you could do:
> 
> int result = Test(new int(22));  //Not D code
> 
> But then you'd also have to handle deletion (delete) of the new in created inside the Test function (yuck). If this was made available in D the garbage collection would take care of that. However,
> 
> int Test(int Value) {
>    return Value + 1;
> }
> 
> int result = 22;
> result = Test(result);
> 
> Is much better.
> 
>>
>> //or another thing i noticed you cant do
>>
>> int* MyPtr = &34;
>>
>> //then you could just:
>>  *MyPtr = *MyPtr + 22;
>>
>> is there a special reason why a person cant do this? or can it be made so we can 
> 
> 
> 
> Again, a literal doesn't have a memory location. Why do you need to change the value 34? How can you access the value 34?
> 
> In C++ you could do:
> 
> int* MyPtr = new int(34); //Not D code
> 
> Still,
> 
> int t = 34;
> int* MyPtr = &t;
> 
> Is almost as good.
> 
> Furthermore you don't need pointers that often (particularly in D). The code you just wrote could be simplified to:
> 
> int t = 34;
> t += 22;
> 
> Try to avoid pointers where you can.  They have all kinds of side effects. Having said that they can be useful in some exceptional circumstances and in arrays.
> 

thanks Mr. Anderson, i was starting to code in D with using almost all pointers for strings, but i have since changed my mind lol... it is alot of complicated stuff im just not ready for yet i dont think, becuase you have to think about each line of code you write, you cant just type it out and know that the variable is the value (instead of a pointer), otherwise your always having to check 'is this a reference or a pointer'?