Should i pass address of pointer or just pointer???

Firstly see the code:

Code:

---

#include<iostream>
#include<conio.h>
using namespace std;

typedef struct temp
{
    int data;
} T;
 

void setframe2( T **tp)
{
    (*tp)->data = 2;
}


void setframe3( T *tp)
{
    tp->data = 3;
}


void setframe( T *tp)
{
    tp->data = 1;
    setframe2(&tp);
    setframe3(tp);
   
}

 
void main()
{
 
    T  tvar;
    tvar.data=0;

    cout<<"\nValue of data before call to setframe "<<tvar.data;

    setframe(&tvar);

    cout<<"\nValue of data after call to setframe "<<tvar.data;
   
   
getch();
 
}

OUTPUT
Value of data before call to setframe 0
Value of data after  call to setframe 3

---

In setframe i have T *tp

when calling to setframe2, i am passing its address
setframe2(&tp);
and in setframe2 , tp->data has been changed
and change is permanant as it should be.

but when calling to setframe3, i am passing just pointer , not its address
setframe3(tp);
and in setframe3 , tp->data has been changed
and change is permanant here too , why??

why??
i mean i am not passing address of pointer
so why changes made are permanant, not local .

You are changing the data pointed to by the pointer; that is why the change is permanent. It would be different if you wanted to change what the pointer points to.

Code:

---

#include <iostream>

void foo(T* x)
{
  x = new T;
  x->data = 2;
}

void bar(T** x)
{
  *x = new T;
  (*x)->data = 2;
}

int main()
{
  T* y = 0;
  foo(y);
  if(!y) std::cout << "NULL" << std::endl;
  else std::cout << "Non-NULL : " << y->data << std::endl;
  bar(y);
  if(!y) std::cout << "NULL" << std::endl;
  else std::cout << "Non-NULL : " << y->data << std::endl;
}

---

The -> operator is a short way to dereference a pointer to a member of a struct. So basically:

Code:

---

someStruct* pStruct;
pStruct->value = 1;  // Same
(*pStruct).value = 1; // Same

---

This also means that if you are passing the address of a pointer, that you are dereferencing it twice by saying (*pStruct)->value = 1; Of course, there is no reason in your case why you would need to pass the address of a pointer when you can merely pass the pointer itself. Throughtout the entire operation, when you were working with that pointer that you initially pass to setframe(), the data changes are not local, they are all dereferenced (with the '*' or '->' operators) to resolve to the initial struct you decalred in main().

Quote:

---

i mean i am not passing address of pointer
so why changes made are permanant, not local .

---

But arent you passing the address of the variable?

My question is

what is the use of pointer to pointer ,if purpose is solved by just a pointer???

like


when i call setframe2(&tp); i am passing address of pointer

Code:

---

void setframe2( T **tp)
{
    (*tp)->data = 2;
}

---

and
when i call setframe3(tp); , i am pasing just the pointer

Code:

---

void setframe3( T *tp)
{
    tp->data = 3;
}

---

and data is being changed in both the cases.
and result is permanant.

sp what is the use of pointer to pointer when simple pointer solves the purpose??

Quote:

---

what is the use of pointer to pointer when simple pointer solves the purpose?

---

None. Is this code your own, or are you asking about some example that you've seen? There are uses for pointers to pointers, but here one might simply skip the pointers and pass references instead.

laserlight

Quote:

---

None. Is this code your own, or are you asking about some example that you've seen? There are uses for pointers to pointers, but here one might simply skip the pointers and pass references instead.

---

i know there are uses of pointer to pointer, but i mean specially here where the purpose is solved by just pointer.


my question is
when i am calling setframe3(tp);
and then changing the data in setframe3 by tp->data = 3;
then this change should not be permanant.
i mean value of data should not be 3 when accessed in main().

Quote:

---

i know there are uses of pointer to pointer, but i mean specially here where the purpose is solved by just pointer.

---

If you're talking about this example that you've given, no. One does not even have to use a pointer (explicitly), but can pass a reference instead.

Quote:

---

i mean value of data should not be 3 when accessed in main().

---

What makes you think so, after reading what the previous users posted?

try to understand what i mean........

ok, i am rephrasing my question...

Code:

---

typedef struct temp
{
    int data;
}T;
 

void setframe( T *tp)
{
    tp->data = 1;
}
 
 
void main()
{
 
    T  *tp=new T();
    tp->data=0;

    cout<<"\nValue of data before call to setframe "<<tp->data;

    setframe(tp);
    cout<<"\nValue of data after call to setframe "<<tp->data;
}

---

its actual output is
Value of data before call to setframe 0
Value of data after call to setframe 1

expected output
Value of data before call to setframe 0
Value of data after call to setframe 0

I think you just have the wrong expectations. Let's work with simple ints:

Code:

---

#include <iostream>

void setInt(int* p) {
        *p = 1;
}

int main() {
        int* p = new int;
        *p = 0;
        std::cout << "Value before setInt() call: " << *p << std::endl;
        setInt(p);
        std::cout << "Value after setInt() call: " << *p << std::endl;
        delete p;
        std::cin.get();
        return 0;
}

---

The expected output is:

Code:

---

Value before setInt() call: 0
Value after setInt() call: 1

---

Here p is the pointer, *p is the data that is pointed to. It is clear that the *p = 1 in setInt() means "change the data pointed to by p to 1". So the data pointed to is changed to 1. As simple as that.

For your example, tp->data = 1 is a shorthand for (*tp).data, after which the same reasoning applies: change the data member of the struct pointed to by tp to 1.

It could be that you have the local scope of setframe() and setInt() in mind. The thing is, working with the pointer means that we're working with memory, which isnt limited by function scope.

i got it......................

Here is an example for what a pointer to a pointer ( in C++ you one would normally use a reference to a pointer ) might be good for.

Code:

---

# include <iostream>
using namespace std;

void ex1(int * pi, int val ) { *pi = val; }
void ex2(int ** ppi, int val ) { *ppi = new int; **ppi= val;}

int main() {
  int a = 1;
  int * pa = &a;
  cout << "a=" << a << " *pa=" << * pa<< endl ; // both outputs are 1
  ex1( pa, 2 );
  cout << "a=" << a << " *pa=" << * pa<< endl ; // both outputs are 2
  ex2( &pa, 3 ); // changes the
  cout << "a=" << a << " *pa=" << * pa<< endl ; // outputs are 2, 3
      // ex2 made pa point to a different location
  delete pa; // pa has to be deleted because ex2 allocated a new pointer to an int
  return 0;
}

---

Kurt