Re: what's the difference?
On Apr 19, 4:50 pm, Andrey Bulat <andrey.bu...@gmail.com> wrote:
I will change the sample:
int main()
{
MyClass obj;
MyClass2 obj1;
MyClass& objArray[2];
objArray[0] = obj;
objArray[1] = obj1;
for(int i=0; i<2; i++)
{
func2(objArray[i]);
}}
This code produces errors connected with illegal use of array of
reference type.
So references and pointers are not the same (at least all pointers
have same sizeof).
No-one is saying that pointers and references are the same in general.
They clearly aren't; they differ at the most fundamental level, since
pointers are objects, while references are not. It is also why a
reference has no sizeof - when you apply it to a reference, you get
sizeof the referenced object.
You are right when you say that "With respect to virtual function
binding,
references work in exact same way as pointers do" but I am not sure
that in case of composites and/or collections design (most frequent
use case for using of virtual functions) you will use reference types.
If by "composites" you mean objects that reference other objects, then
there's nothing wrong with using a reference for that purpose.
For collections, using raw pointers is generally still a bad idea
because of memory management issues. You're supposed to use a smart
pointer (shared_ptr today, unique_ptr in C++0x), or a specialized
collection type (such as Boost ptr_vector, ptr_list etc).
About early/late binding - I didn't read about it with respect to
reference types(Can you give me reference?)
C++03, 5.2.2[expr.call]/1:
"... The function called in a member function call is normally
selected according to the static type of the object expression (clause
10), but if that function is virtual and is not specified using a
qualified-id then the
function actually called will be the final overrider (10.3) of the
selected function in the dynamic type of the object expression [Note:
the dynamic type is the type of the object pointed or referred to by
the current value of the object expression. ..."
Specifically, "object pointed _or referred_ to" clearly indicates that
both pointers and references are covered.
but if we use single
object and reference to it it seems that it is possible to make
compile-time binding (I don't know how to check it).
If you mean that the reference is bound to an object, and then a
method is immediately invoked via that reference, then, yes, of course
the compiler can optimize that call to be non-virtual. But it can do
that with a pointer as well. References may be slightly easier to
optimize that way for more general cases because they cannot be
rebound, but, again, the same would apply to const pointers.
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]