This is a language most commonly used in firmware in hardware level.Mark44 said:
#165 has nothing to do with integer, I just want to verify the data and pointer are destroy after exiting the function.PeterDonis said:
I don't see how this is relevant to the discussion here about pointers.yungman said:
That's not what you said in post #171, copied belowyungman said:
yungman said:
yungman said:
yungman said:
yungman said:
yungman said:
int** pptr. For a pointer to a pointer to a different type of variable, you would have to use the different type instead of int; so, for example, for a pointer to a pointer to a double variable, it would be double** pptr.yungman said:
yungman said:
Ah, I see. If *ptr is an int. The pointer to pointer **pptr that point to ptr HAS to be int**pptr;. NOT THAT it is pointing to an int, just to acknowledge that it is pointing to a pointer that points to an int.PeterDonis said:
I was pulling hair for a day or so, but now I am happy and have fun again. Just kept at it, last night, it was a lightbulb moment, it's just that simple. Thanks to the people here, no thanks to the book.Vanadium 50 said:
yungman said:
I am happy camper now. Now I can move on. BUT, first, I am going to take it easy today, have a nice drink and relax! I was pulling hair for the last day! It's like what's wrong with me, it's right in front of my face and I just cannot connect them together.PeterDonis said:
// passing reference to pointer to function 2
#include <iostream>
using namespace std;void changeRvalue(int*&);
int main()
{
int var = 23;
int* ptr;
ptr = &var;
cout << " Before passing to function, *ptr = " << *ptr << "\n\n";
changeRvalue(ptr);
cout << " After passing to function, *ptr = " << *ptr << "\n\n";
return 0;
}
void changeRvalue(int*& pp)
{
int glov = 52;
pp = &glov;
}yungman said:
So just don't count on it. It just so happen the value in glov is not erased only, no guaranty.willem2 said:
#include <iostream>
using namespace std;
void changeRvalueA(int*&);// function receives a pointer of an address
void changeRvalueB(int**);// function receives a pointer to pointer
int main()
{
int var = 23;
int* ptrA;// pointer whose address to be passed
ptrA = &var;// pointer pointing to address of var
changeRvalueA(ptrA);// passing address of pointer ptrA
cout << " ptrA = " << ptrA << "\n\n";
int* ptrB;// declare a pointer ptr
int** pptrB = &ptrB;
ptrB = &var; //ptr pointing to address var
changeRvalueB(pptrB);// passing pointer of pointer pptrB.
cout << " pptrB = " << pptrB << "\n\n";
return 0;
}
void changeRvalueA(int*& ppA)// receiving address for pointer ppA
{ cout << " ppA = " << ppA; }
void changeRvalueB(int** ppB)// receiving pointer to pointer ppB.
{ cout << " ppB = " << ppB; }
// ppA = 00FDF854 ptrA = 00FDF854 ppB = 00FDF83C pptrB = 00FDF83Cyungman said:
No, that's not what you're doing. the function parameter is of type reference to pointer to int. In all the C++ books I've seen over the years, I've never seen a single function with a parameter like this, which is a weird mixture of C notation (pointer parameter) and C++ (reference parameter). Since it's not shown in books, it's probably not a good thing to put in a real program.yungman said:
#include <iostream>
using std::cout;
void FuncPtr(int *); // Prototype for a function with a pointer parameter
void FuncRef(int &); // Prototype for a function with a reference parameter
int main()
{
int x = 3;
int y = 5;
FuncPtr(&x); // Note the difference in the semantics for the two functions
FuncRef(y);
cout << "New value for x: " << x << '\n';
cout << "New value for y: " << y << '\n';
}
void FuncPtr(int* argPtr)
{
*argPtr = 10;
}
void FuncRef(int & argRef)
{
argRef = 10;
}ThanksJarvis323 said:
For that you should use double indirection; i.e., a pointer to a pointer to some type.yungman said:
#include <iostream>
using std::cout;
using std::cin;
using std::endl;
void passAddr(int **);
int main()
{
int List[] = { 1, 3, 5, 7, 9 };
int * ptr = List; // Initialize ptr with the address of List, which is itself a kind of pointer.
cout << "Before call to passAddr(), *ptr == " << *ptr << endl;
passAddr(&ptr); // Pass the address of the pointer to the first element of the array.
cout << "After call to passAddr(), *ptr == " << *ptr << endl;
}
void passAddr(int ** pptr)
{
*pptr += 2; // pptr is a pointer to a pointer to an int
}Before call to passAddr(), *ptr == 1
After call to passAddr(), *ptr == 5A struct (C and C++ keyword) is not the same as an array. A struct is a user-defined collection of possibly different types. In an array, all of the elements are exactly the same type.yungman said:
But List[] is declared as int with initial value only, how can it be pointer constant? I don't get List is a pointer as it's not declared as int*List. I thought there's a difference between ptr where it's declare as int*ptr. I know *ptr = List.Mark44 said:
This is where I am confused. *ptr=List=&List[0] which is the starting address of List[]. ptr is not equal to &List[0]. passAddr() passing the ADDRESS of ptr in line 4 in main. BUT in the function definition: void passAddr(int**); that means it is passing a pointer to pointer variable ( like int**pptr). But in main, it pass as &ptr, the address of ptr. they are not the same type even thought at the end, it is the same. Can you explain?Mark44 said:
Actually I prefer to pass pointer as reference ( or pass reference pointer, I still not quite sure) to function. This is more in line with passing any variable as reference to function by declaring void func(int&). It is easier than func(int**).Mark44 said:
I read the first post in your link, that's kind of the reason I spend extra effort in pointers as you said it's relate to data structure in the advanced class. I also put in extra effort in creating and read/write to files stored on hard disk/flash memory, anything to do with data transport and storage. Actually my book by Gaddis does NOT even go into pointer to pointer or reference pointers. It just declare int func() to return the int pointer. I insisted in learning passing pointer as reference and/or pointer to pointer. It's only two extra days, might be worth my time in the long run...at least that's how I think.jtbell said:
yungman said:
List has type "array of int", which the compiler treats as a pointer to the initial item in the array, so it's the same type to the compiler as "pointer to int", so it can be assigned to a variable of that type, such as ptr. The difference is that the address List points to can't be changed--it always points to the first int in the array. Whereas the address that ptr points to can be changed, by assigning some other address to it, as long as that address points to an int. So assigning to ptr a pointer to some element in the array of ints other than the first one is fine.yungman said:
int *ptr = List, the variable ptr points to the first int in the array. So *ptr at that point is not List; it's the first int in the array, which is of type int, not type "array of int", which is the type of List.More precisely, I would say "const pointer to int", because, as you note,PeterDonis said:
PeterDonis said:
jtbell said:
Yes, you are confused, as well as mistaken. In its declaration ptr is initialized with List, which is the same as &List[0].yungman said:
[B]int * ptr = &List[0];[/B], but I chose the shorter form.A pointer represents an address, so the address of a pointer is a pointer to a pointer to an int, in this case.yungman said:
The type of &ptr is pointer to pointer to int.yungman said:
Like I said before, I've never seen any C++ book with function parameters that mix references and pointers. This should suggest something to you. Sure, you could probably do it, and get something to work, but why? You're mixing together two concepts that really don't belong together, and are obviously confusing to you.yungman said:
No. int func() means that func returns an int value, not a pointer.yungman said:
It's really not a good idea to pass a pointer as a reference parameter. You haven't been able to make it work, so that should be a clue to you. I've shown you an example with double indirection with a parameter of type int**. Before going off into weirdness as you are trying to do, see if you can grasp what my example is doing.yungman said:
I tried and broke up int *ptr = List to int*ptr;PeterDonis said:
Mark44 said:
There's no real difference between this:yungman said:
int * ptr;
ptr = List;int * ptr = List;1) It's really not advisable to have a function parameter that is the reference of a pointer.yungman said:
Another word I have no idea what you mean....indirection.Mark44 said:
Indirection means using a pointer to get access indirectly, to some memory location. If you have a pointer to a pointer to an int (the type int **), that is double indirection.yungman said:
In any field of study, there is some basic terminology that is used. If you don't know what the basic terms mean, you won't get far in that field.yungman said:
No, that's not what the parameter declaration int& x means. It is not the address of x: it is a reference to x. A function with this signature, void func2(int * x), is passing the address of x. This is why several people have told you that you aren't understanding the difference between a reference parameter and a pointer parameter.yungman said:
Except when it didn't work, in several examples of your code that wasn't working.yungman said:
**ptr and *(*ptr) mean exactly the same thing, although the name you chose is somewhat confusing.yungman said:
#include <iostream>
using std::cout;
using std::endl;int main()
{
int val = 23;
int* pInt = &val; // pInt is a pointer to an int
int** ppInt = &pInt; // ppInt is a pointer to a pointer to an int
cout << "ppInt == " << ppInt << endl;
cout << "*ppInt == " << *ppInt << endl;
cout << "**ppInt == " << **ppInt << endl;
}ppInt == 012FFB70
*ppInt == 012FFB7C
**ppInt == 23