Thread: pointers and functions

Hello..

I have some program's source that I do not fully understand.
Could someone please help me to explain/understand how pointers/arguments are passed betwen the functions:

Code:

class someclass {
public:
	char member;
};

void someotherfunc(ULONG_PTR *ptr) {
	//here it calls windows api GetQueuedCompletionStatus with ptr and some other arguments (which will set ptr)
}
void somefunction(someclass *&sc) {  //why *& ?
	someotherfunc((ULONG_PTR)&sc);
}

int main() {
	someclass *sc_p = 0;
	somefunction(sc_p);
	return 0;
}

Thanks for help

Guess your real problem is this

Code:

someclass *sc_p = 0;

Many of the Windows API functions require a pointer to some data as parameter where they store some result. If you pass 0 or an uninitialized pointer they fail or crash.
Guess you are talking about the lpCompletionKey parameter of GetQueuedCompletionStatus.
you have to do something like this

Code:

void somefunction(ULONG_PTR * compl ) {
	GetQueuedCompletionStatus( .., ...,  compl, ..., ... );
}


unsigned long compl;
somefunction(& compl );  // pass a pointer to compl where GetQueuedCompletionStatus will store the CompletionKey

Anyway you cannot pass a Null pointer to some class to this kind of functions.
Kurt

Thanks for help guys.

Kurt thats exactly what I am talking about.

Originally Posted by ZuK

Code:

void somefunction(ULONG_PTR * compl ) {
	GetQueuedCompletionStatus( .., ...,  compl, ..., ... );
}

unsigned long compl;
somefunction(& compl );  // pass a pointer to compl where GetQueuedCompletionStatus will store the CompletionKey

Since when its unsigned long compl a pointer?
Is it better to use ULONG_PTR instead of unsigned long?


So can I do this instead:

Code:

void somefunction(ULONG_PTR *&compl ) {
	GetQueuedCompletionStatus( .., ...,  compl, ..., ... );
}

unsigned long compl;
somefunction(compl );

Thank you

Originally Posted by l2u

Since when its unsigned long compl a pointer?
Is it better to use ULONG_PTR instead of unsigned long?

You posted this code :

Code:

	someclass *sc_p = 0;
	somefunction(sc_p);

The * makes sc_p a pointer to "someclass" types. When you define a pointer, no memory is automatically allocated for the variable it points to (because you might want it to point to something which already exists!)

You're probably looking to declare something on the stack and then pass a reference to it... In which case you need to do :

Code:

	someclass sc_p;
	somefunction(&sc_p);

... and just declare somefunction without the &.

Is this the same:
If not, whats the difference?

Code:

void somefunc(int *c) {
	*c = 2;
}
void somefunc2(int &c) {
	c = 3;
}

int main() {
	int c = 5;
	somefunc(&c);
	somefunc2(c);
	return 0;
}

Originally Posted by CornedBee

some people (including Bjarne Stroustrup) prefer the pointer for parameters that get changed because the additional & at the function call site makes it clear that the value might be changed, without having to look at the parameter types of the function.

Totally.

Oh and for reference parameters that don't get changed... const all the way!!

What about:

Code:

void somefunc3(int *&c) {
	c = 4;
}