Does this look normal to you?

[abc]

Hello folks,

Does this qualify as normal behavior to you ?Compiled this with gcc 3.2

-----------------------------
#include <stdio.h>

static int array[2];

void initPointer(int * i_p)
{
i_p = array;
printf("INITP: pointer: %p\n",i_p);
};

int main (void)
{
printf("MAIN : array @: %p\n", array);

int * p = NULL;
initPointer(p);

printf("MAIN : pointer: %p\n",p);
}
---------------------------

The result ? Here we go :

MAIN : array @: 0x8049540
INITP: pointer: 0x8049540
MAIN : pointer: (nil) ---> What the heck is wrong ?

[W Marsh]

On Thu, 24 Nov 2005 14:51:04 -0500, abc <[e-mail]> wrote:

Hello folks,

Does this qualify as normal behavior to you ?Compiled this with gcc 3.2

-----------------------------
#include <stdio.h>

static int array[2];

void initPointer(int * i_p)
{
i_p = array;
printf("INITP: pointer: %p\n",i_p);
};

int main (void)
{
printf("MAIN : array @: %p\n", array);

int * p = NULL;
initPointer(p);

printf("MAIN : pointer: %p\n",p);
}
---------------------------

The result ? Here we go :

MAIN : array @: 0x8049540
INITP: pointer: 0x8049540
MAIN : pointer: (nil) ---> What the heck is wrong ?

You're not changing p in main when you pass it to initPointer. You're
giving that function the value of the pointer, which it uses for the
i_p variable which is its parameter. If you want to change the actual
pointer in initPointer, pass it by reference.

[Dakka]

abc wrote:

Hello folks,

Does this qualify as normal behavior to you ?Compiled this with gcc 3.2

-----------------------------
#include <stdio.h>

static int array[2];

void initPointer(int * i_p)
{
i_p = array;
printf("INITP: pointer: %p\n",i_p);
};

int main (void)
{
printf("MAIN : array @: %p\n", array);

int * p = NULL;
initPointer(p);

printf("MAIN : pointer: %p\n",p);
}
---------------------------

The result ? Here we go :

MAIN : array @: 0x8049540
INITP: pointer: 0x8049540
MAIN : pointer: (nil) ---> What the heck is wrong ?

Your function initPointer is taking the value of your pointer (ie. a
copy). To get this to work you need to use another level of indirection...

void initPointer(int ** i_p)
{
*i_p = array;
printf("INITP: pointer: %p\n",*i_p);
};

..
..

int * p = NULL;
initPointer(&p) ;

--dakka

[John Harrison]

abc wrote:

Hello folks,

Does this qualify as normal behavior to you ?Compiled this with gcc 3.2

-----------------------------
#include <stdio.h>

static int array[2];

void initPointer(int * i_p)
{
i_p = array;
printf("INITP: pointer: %p\n",i_p);
};

int main (void)
{
printf("MAIN : array @: %p\n", array);

int * p = NULL;
initPointer(p);

printf("MAIN : pointer: %p\n",p);
}
---------------------------

The result ? Here we go :

MAIN : array @: 0x8049540
INITP: pointer: 0x8049540
MAIN : pointer: (nil) ---> What the heck is wrong ?

Perfectly normal. Does this look normal to you?

void initInt(int i)
{
i = 2;
}

int main()
{
int i = 1;
initInt(i);
printf("%d\n", i); // prints 1 not 2
}

You have to realise that variables in one function are different from
variables in another function, even if they are pointers (why should
pointers be different?).

You need to use a reference or a pointer to change a variable in another
function. Because your variable is a pointer already that means you need
a refernce to a pointer or a pointer to a pointer.

john

[Jack Klein]

On Thu, 24 Nov 2005 14:51:04 -0500, abc <[e-mail]> wrote in
comp.lang.c++:

Hello folks,

Does this qualify as normal behavior to you ?Compiled this with gcc 3.2

-----------------------------
#include <stdio.h>

static int array[2];

void initPointer(int * i_p)
{
i_p = array;
printf("INITP: pointer: %p\n",i_p);
In addition to what the others have pointed out, this is undefined
behavior. The "%p" conversion specifier to printf() requires a
pointer to void, not pointer to int or to any other type. Should be:

printf("INITP: pointer: %p\n", (void *)i_p);

Of course C++ stream insertion operators handle any type of pointer,
with the exception of pointer to char, without any cast.
};

int main (void)
{
printf("MAIN : array @: %p\n", array);
Same here.

int * p = NULL;
initPointer(p);

printf("MAIN : pointer: %p\n",p);
And here.
}

--
Jack Klein
Home: http://JK-Technology.Com
FAQs for
comp.lang.c http://www.eskimo.com/~scs/C-faq/top.html
comp.lang.c++ http://www.parashift.com/c++-faq-lite/
alt.comp.lang.l earn.c-c++
http://www.contrib.andrew.cmu.edu/~a...FAQ-acllc.html

[Peter_Julian]

"abc" <[e-mail]> wrote in message
news:dm******** **@zcars129.ca. nortel.com...
| Hello folks,
|
| Does this qualify as normal behavior to you ?Compiled this with gcc
3.2
|
| -----------------------------
| #include <stdio.h>
|
| static int array[2];
|
| void initPointer(int * i_p)
| {
| i_p = array;
| printf("INITP: pointer: %p\n",i_p);
| };

redundant semicolon above

|
| int main (void)
| {
| printf("MAIN : array @: %p\n", array);
|
| int * p = NULL;
| initPointer(p);
|
| printf("MAIN : pointer: %p\n",p);
| }
| ---------------------------
|
| The result ? Here we go :
|
| MAIN : array @: 0x8049540
| INITP: pointer: 0x8049540
| MAIN : pointer: (nil) ---> What the heck is wrong ?
|

Think about it.
You are passing a null pointer as a parameter to initPointer(... ) which
sets i_p to 0 momentarily.
You then modify the local i_p pointer to &array[0], a valid pointer.
Why should p, who's on another planet, not be null?

You might as well have written:

void initPointer()
{
int *i_p = array;
printf("INITP: pointer: %p\n",i_p);
}

which is probably what your compiler did when it optimized the code.
Try something like this instead:

static int array[2];

int main()
{
int *p = &array[0];
}