Velocity Reviews

Velocity Reviews (http://www.velocityreviews.com/forums/index.php)
-   C Programming (http://www.velocityreviews.com/forums/f42-c-programming.html)
-   -   passing the address of a pointer to a func that doesnt recieve a pointer-to-a-pointer (http://www.velocityreviews.com/forums/t441976-passing-the-address-of-a-pointer-to-a-func-that-doesnt-recieve-a-pointer-to-a-pointer.html)

jimjim 03-25-2006 11:37 AM

passing the address of a pointer to a func that doesnt recieve a pointer-to-a-pointer
 
#include <stdio.h>
#include <stdlib.h>

//WARNING: The function's signature should be: f( int ** )
void f(int *ip) {
static int dummy = 5;
*ip = &dummy;
}

int main(){
int *ip;
f(&ip);
printf("%d",*ip);
return 0;
}

The function's signature should be: f( int ** ). However, f( int *) seems to
produce the same results, even though I am
warned by the compiler (Borland_bcc_5.5):
Warning W8069 solution.c 5: Nonportable pointer conversion in function f
Warning W8075 solution.c 12: Suspicious pointer conversion in function main

What can go wrong when you pass the address of a pointer to a function that
does not recieve a pointer to a pointer?

TIA
jimjim



Michael Mair 03-25-2006 12:05 PM

Re: passing the address of a pointer to a func that doesnt recievea pointer-to-a-pointer
 
jimjim schrieb:
> #include <stdio.h>
> #include <stdlib.h>
>
> //WARNING: The function's signature should be: f( int ** )
> void f(int *ip) {
> static int dummy = 5;
> *ip = &dummy;
> }
>
> int main(){
> int *ip;
> f(&ip);
> printf("%d",*ip);
> return 0;
> }
>
> The function's signature should be: f( int ** ). However, f( int *) seems to
> produce the same results, even though I am
> warned by the compiler (Borland_bcc_5.5):
> Warning W8069 solution.c 5: Nonportable pointer conversion in function f
> Warning W8075 solution.c 12: Suspicious pointer conversion in function main
>
> What can go wrong when you pass the address of a pointer to a function that
> does not recieve a pointer to a pointer?


The above seems to "work" by pure, dumb luck or bad luck.
It works, if
1) the representation of an int** is the same as for an int*
2) the conversion address->int->address yields the original
address
3) an int* can be stored in an int (this can hold if the size
of an int* is the same as the size of an int).
This is just a rough description, not by the very word of the
standard. This means, it can easily break or sometimes break
if sizeof (int*) != sizeof (int) which is not that unlikely
in the future if you think of 64 bit architectures.

Just do not do that.


Cheers
Michael
--
E-Mail: Mine is an /at/ gmx /dot/ de address.

pete 03-25-2006 12:06 PM

Re: passing the address of a pointer to a func that doesnt recieve a pointer-to-a-pointer
 
jimjim wrote:

> What can go wrong when you pass
> the address of a pointer to a function that
> does not recieve a pointer to a pointer?


Whatever might be caused by the function translation
not taking into consideration that you may have
passed in the wrong type.

The philosophy of the newsgroup,
is that it is worth knowing how to write defined code,
and not worth knowing just exactly
what might happen with undefined code.

--
pete

Barry Schwarz 03-25-2006 06:13 PM

Re: passing the address of a pointer to a func that doesnt recieve a pointer-to-a-pointer
 
On Sat, 25 Mar 2006 11:37:40 GMT, "jimjim" <netuser@blueyonder.co.uk>
wrote:

>#include <stdio.h>
>#include <stdlib.h>
>
>//WARNING: The function's signature should be: f( int ** )
>void f(int *ip) {
>static int dummy = 5;
>*ip = &dummy;


As a result of the faulty calling statement, this statement invokes
undefined behavior. One of the more insidious manifestations of
undefined behavior is to "appear to work as intended." Just bad luck.
Not the worst luck (it could have formatted your hard drive) or good
luck (an easily diagnosed software failure).

>}
>
>int main(){
>int *ip;
>f(&ip);
>printf("%d",*ip);
>return 0;
>}
>
>The function's signature should be: f( int ** ). However, f( int *) seems to
>produce the same results, even though I am
>warned by the compiler (Borland_bcc_5.5):
>Warning W8069 solution.c 5: Nonportable pointer conversion in function f
>Warning W8075 solution.c 12: Suspicious pointer conversion in function main


Ignore the warnings if you want but you really need to understand ALL
the repercussions.

>
>What can go wrong when you pass the address of a pointer to a function that
>does not recieve a pointer to a pointer?
>

Let's just consider your code and a system that requires an int to be
aligned on a four-byte boundary. When you return from f, ip contains
the address 5. Your printf statement says go to address 5 and extract
the value of the int that is there. What will the hardware do when it
attempts to extract an int that is not aligned properly.

What about systems where an int and an address do not share the same
representation. If you code something like
int *ptr;
ptr = (int*)dummy;
the compiler knows you are converting an int to a pointer and can
generate the code to to perform the conversion properly. In your
code, the compiler believes you assigning an int value to an int and
sees no need for any conversion. The value in ip might be a trap
representation (that would be good luck).


Remove del for email

SM Ryan 03-26-2006 02:19 AM

Re: passing the address of a pointer to a func that doesnt recieve a pointer-to-a-pointer
 
# What can go wrong when you pass the address of a pointer to a function that
# does not recieve a pointer to a pointer?

You can use any type T for int* such that sizeof(T)=sizeof(int*). If you cast,
you will avoid compiler warnings.

On most implementations sizeof(int)=sizeof(T*) and in the early days of
unix many interfaces were based on that. If you need to do this, and this
is not just stupid C pet tricks, be sure to test to sizeof assumption in
main() start up or in the installer.

--
SM Ryan http://www.rawbw.com/~wyrmwif/
Wow. A sailboat.

Keith Thompson 03-26-2006 02:57 AM

Re: passing the address of a pointer to a func that doesnt recievea pointer-to-a-pointer
 
SM Ryan <wyrmwif@tango-sierra-oscar-foxtrot-tango.fake.org> writes:
> # What can go wrong when you pass the address of a pointer to a function
> # that does not recieve a pointer to a pointer?


The question was posted by "jimjim" <netuser@blueyonder.co.uk>.
Please don't snip attributions. And *please* stop using your stupid
'#' quoting character. You've been told repeatedly that it causes
problems for some newsreaders; your stubbornness on this point is why
I usually ignore anything you post.

> You can use any type T for int* such that sizeof(T)=sizeof(int*). If
> you cast, you will avoid compiler warnings.
>
> On most implementations sizeof(int)=sizeof(T*) and in the early days of
> unix many interfaces were based on that. If you need to do this, and this
> is not just stupid C pet tricks, be sure to test to sizeof assumption in
> main() start up or in the installer.


Casting to suppress compiler warnings is dangerous and foolish.
Parameters of different types can be passed by different mechanisms,
even if they're the same size. For example, some systems might use
different sets of registers for pointers vs. integers, or integers
vs. floating-point types. If both types are pointers, there's
probably less risk of something going visibly wrong, but the behavior
is still undefined. Don't waste time figuring out how it can go
wrong; just fix the code.

--
Keith Thompson (The_Other_Keith) kst-u@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

CBFalconer 03-26-2006 08:43 AM

Re: passing the address of a pointer to a func that doesnt recieveapointer-to-a-pointer
 
Keith Thompson wrote:
> SM Ryan <wyrmwif@tango-sierra-oscar-foxtrot-tango.fake.org> writes:
>
>># What can go wrong when you pass the address of a pointer to a
>># function that does not recieve a pointer to a pointer?

>
> The question was posted by "jimjim" <netuser@blueyonder.co.uk>.
> Please don't snip attributions. And *please* stop using your
> stupid '#' quoting character. You've been told repeatedly that
> it causes problems for some newsreaders; your stubbornness on
> this point is why I usually ignore anything you post.


Many of us no longer notice him, we just let the plonk file work.

--
Some informative links:
news:news.announce.newusers
http://www.geocities.com/nnqweb/
http://www.catb.org/~esr/faqs/smart-questions.html
http://www.caliburn.nl/topposting.html
http://www.netmeister.org/news/learn2quote.html



jimjim 03-26-2006 03:40 PM

Re: passing the address of a pointer to a func that doesnt recieve a pointer-to-a-pointer
 
>> What can go wrong when you pass the address of a pointer to a function
>> that does not recieve a pointer to a pointer?

>
> The above seems to "work" by pure, dumb luck or bad luck.
> It works, if
> 1) the representation of an int** is the same as for an int*
> 2) the conversion address->int->address yields the original
> address
> 3) an int* can be stored in an int (this can hold if the size
> of an int* is the same as the size of an int).
> This is just a rough description, not by the very word of the
> standard. This means, it can easily break or sometimes break
> if sizeof (int*) != sizeof (int) which is not that unlikely
> in the future if you think of 64 bit architectures.
>

Hi..thx to all for your replies!

As far as your (1) point is concerned, I understand it.
Now, your (2) point hints that theres a relationship btw pointer
representation of an address and int(s). Can you elaborate on that, please?
Regarding your (3) point, how does an int* and an int relates to my code's
use of an int* as an int**? Can you elaborate, please?

TIA



Vladimir S. Oka 03-26-2006 04:46 PM

Re: passing the address of a pointer to a func that doesnt recieve a pointer-to-a-pointer
 
jimjim opined:

>>> What can go wrong when you pass the address of a pointer to a
>>> function that does not recieve a pointer to a pointer?

>>
>> The above seems to "work" by pure, dumb luck or bad luck.
>> It works, if
>> 1) the representation of an int** is the same as for an int*
>> 2) the conversion address->int->address yields the original
>> address
>> 3) an int* can be stored in an int (this can hold if the size
>> of an int* is the same as the size of an int).
>> This is just a rough description, not by the very word of the
>> standard. This means, it can easily break or sometimes break
>> if sizeof (int*) != sizeof (int) which is not that unlikely
>> in the future if you think of 64 bit architectures.
>>

> Hi..thx to all for your replies!
>
> As far as your (1) point is concerned, I understand it.
> Now, your (2) point hints that theres a relationship btw pointer
> representation of an address and int(s). Can you elaborate on that,


2) says that your code will work if converting from the pointer to
`int` and back to the pointer, yields the same pointer you started
with. This is going to be implementation-specific, so you can't really
count on that being true.

> please? Regarding your (3) point, how does an int* and an int relates
> to my code's use of an int* as an int**? Can you elaborate, please?


It would be possible to reply to that, but you did not quote the code
in question, and I can't see your OP. You also snipped attribution
lines (the ones saying "jimjim opined:" or similar), soI don't really
know who you're replying to.

> TIA


These have been slated recently, and for good reasons, IMHO.

--
BR, Vladimir

Theory is gray, but the golden tree of life is green.
-- Goethe


santosh 03-26-2006 08:10 PM

Re: passing the address of a pointer to a func that doesnt recieve a pointer-to-a-pointer
 
Vladimir S. Oka wrote:
> jimjim opined:
> > please? Regarding your (3) point, how does an int* and an int relates
> > to my code's use of an int* as an int**? Can you elaborate, please?

>
> It would be possible to reply to that, but you did not quote the code
> in question, and I can't see your OP. You also snipped attribution
> lines (the ones saying "jimjim opined:" or similar), soI don't really
> know who you're replying to.


Here's a reconstruction of the thread, as far as I can see:

> jimjim wrote:
>> Michael Mair wrote:
>> jimjim schrieb:
>>> #include <stdio.h>
>>> #include <stdlib.h>
>>>
>>> //WARNING: The function's signature should be: f( int ** )
>>> void f(int *ip) {
>>> static int dummy = 5;
>>> *ip = &dummy;
>>> }
>>>
>>> int main(){
>>> int *ip;
>>> f(&ip);
>>> printf("%d",*ip);
>>> return 0;
>>> }
>>>
>>> The function's signature should be: f( int ** ). However, f( int *) seems to
>>> produce the same results, even though I am
>>> warned by the compiler (Borland_bcc_5.5):
>>> Warning W8069 solution.c 5: Nonportable pointer conversion in function f
>>> Warning W8075 solution.c 12: Suspicious pointer conversion in function main
>>>
>>> What can go wrong when you pass the address of a pointer to a function that
>>> does not recieve a pointer to a pointer?

>>
>> The above seems to "work" by pure, dumb luck or bad luck.
>> It works, if
>> 1) the representation of an int** is the same as for an int*
>> 2) the conversion address->int->address yields the original
>> address
>> 3) an int* can be stored in an int (this can hold if the size
>> of an int* is the same as the size of an int).
>> This is just a rough description, not by the very word of the
>> standard. This means, it can easily break or sometimes break
>> if sizeof (int*) != sizeof (int) which is not that unlikely
>> in the future if you think of 64 bit architectures.
>>
>> Just do not do that.

> Hi..thx to all for your replies!
>
> As far as your (1) point is concerned, I understand it.
> Now, your (2) point hints that theres a relationship btw pointer
> representation of an address and int(s). Can you elaborate on that, please?
> Regarding your (3) point, how does an int* and an int relates to my code's
> use of an int* as an int**? Can you elaborate, please?
>
> TIA




All times are GMT. The time now is 05:50 AM.

Powered by vBulletin®. Copyright ©2000 - 2014, vBulletin Solutions, Inc.
SEO by vBSEO ©2010, Crawlability, Inc.