469,963 Members | 1,774 Online
Bytes | Developer Community
New Post

Home Posts Topics Members FAQ

Post your question to a community of 469,963 developers. It's quick & easy.

Pass by Pointer * or Pass by Reference &?

Hello all,

I am a C programmer learning C++. And I am confused with function Pass
by Pointer * or Pass by Reference &.

Function pass by pointer like:
void func(int * x)
And function pass by referencelike:
void func(int & x)

What's their main difference and be used in what circumstance?

Best regards,
Robert

Aug 19 '05 #1
10 40448
"Robert" <zh*******@gmail.com> schrieb im Newsbeitrag
news:11*********************@g14g2000cwa.googlegro ups.com...
Hello all,

I am a C programmer learning C++. And I am confused with function Pass
by Pointer * or Pass by Reference &.

Function pass by pointer like:
void func(int * x)
And function pass by referencelike:
void func(int & x)

What's their main difference and be used in what circumstance?

Best regards,
Robert

Pointer can be null, references can't. Pointers can be reassigned.
A reference is more comfortable to use. You can handle it like a normal
object. When changing a function from
void func(const AClass);
to
void func(const AClass&);
you do not need to rewrite your code.

Greetings Chris
Aug 19 '05 #2
Robert wrote:
Hello all,

I am a C programmer learning C++. And I am confused with function Pass
by Pointer * or Pass by Reference &.

Function pass by pointer like:
void func(int * x)
And function pass by referencelike:
void func(int & x)

What's their main difference and be used in what circumstance?

Best regards,
Robert


There is a lot of good information about this in this handy guide:

http://www.parashift.com/c++-faq-lite/

--John Ratliff
Aug 19 '05 #3
Another problem is why reference cannot be able to represent a NULL
object?

Best regards,
Robert

Aug 19 '05 #4
One other difference between pointers and references is that if you use
dynamic_cast on an incorrect reference it willl throw a bad cast
exception. On the other hand, an incorrect dynamic cast on a pointer
will not throw a bad cast exception.

void function(Panda& q)
{
Panda &ip = dynamic_cast<randomref&)(q);
}

void g()
{
try{
f(*(new Panda))
}
catch(bad_cast)
{

}
}

Aug 20 '05 #5
Robert ha scritto:
Another problem is why reference cannot be able to represent a NULL
object?

Best regards,
Robert


References are intended to "point" to existing objects :

the function

void f(T &t)
{
[...]
}

is similar to

void f(T const *t)
{
assert(t != NULL);
[...]
}

Reference can't be null and its address can't be incremented.

Bye,
Giulio
Aug 22 '05 #6
Frank Chang schreef:
One other difference between pointers and references is that if you use
dynamic_cast on an incorrect reference it willl throw a bad cast
exception. On the other hand, an incorrect dynamic cast on a pointer
will not throw a bad cast exception.


No, it returns a NULL pointer. This can be useful:

void foo( Base* b )
{
if( Derived* d = dynamic_cast<Derived>(b) )
{
// do something with Derived
d->bar();
}
else
{
// User didn't have a Derived object, but we don't care why not
}
}
This is a quite common idiom. I usually leave out the comment and the
else block if there is no default action. The idea is that I don't
want to differentiate between a non-Derived Base object or no object
at all. I purely want to know if the caller has a Derived object.

HTH,
Michiel Salters

Aug 22 '05 #7
no it doesn't. On a pointer it returns null on references it throws
std::bad_cast

Aug 22 '05 #8

"Robert" <zh*******@gmail.com> wrote in message
news:11**********************@g47g2000cwa.googlegr oups.com...
Another problem is why reference cannot be able to represent a NULL
object?

Best regards,
Robert


A reference can't refer to a null object since its permanently bound to a
valid object. This is an important distinction (unlike a pointer which can
point to another object or even to a null object). A reference is a
permanent alias to a valid object.

In fact, the lifetime of any object may even be extended to satisfy this
object-is-valid rule.

Aug 24 '05 #9

"Robert" <zh*******@gmail.com> wrote in message
news:11**********************@g47g2000cwa.googlegr oups.com...
Another problem is why reference cannot be able to represent a NULL
object?

Best regards,
Robert


Define what a NULL object is.

Dan
Aug 24 '05 #10
Robert wrote:
Another problem is
why reference cannot be able to represent [an invalid] object? cat main.cc #include <iostream>

void f(const int& r) {
if (0 == &r) { // undefined behavior
std::cout << "&r = " << &r << std::endl;
}
else {
std::cout << "r = " << r << std::endl;
}
}

int main(int argc, char* argv[]) {

int* p = 0;
int& r = *p; // undefined behavior
f(r);

return 0;
}
g++ -Wall -ansi -pedantic -o main main.cc
./main

&r = 0

Beware!
A reference *can* represent an invalid object
but the behavior is undefined.
Aug 24 '05 #11

This discussion thread is closed

Replies have been disabled for this discussion.

Similar topics

2 posts views Thread by Nelson | last post: by
3 posts views Thread by dover | last post: by
41 posts views Thread by Berk Birand | last post: by
5 posts views Thread by DamonChong | last post: by
3 posts views Thread by Scott | last post: by
29 posts views Thread by shuisheng | last post: by
11 posts views Thread by HSeganfredo | last post: by
1 post views Thread by rainxy | last post: by
By using this site, you agree to our Privacy Policy and Terms of Use.