My apologies for posting the answers to the Quiz here, but, I have searched for the correct thread and apparantly, it was never created.

I searched under jwalsh his name, I tried googling, no avail.

Chapter 9.

1) What is a reference?
A) A reference is an alias; when you create a reference, you initialize it with the name of another object, the target. From that moment on, the reference acts as an alternative name for the target, and anything you do to the reference is really done to the target.

2) What is returned if you try and get the address of a reference?
A) It returns the address of its target.

3) Can references be reassigned?
A) No, references are ALLWAYS aliases for their target.

4) Can you create a reference to a class?
A) No, you create a reference to an object from a class, not to the class itself.

5) Is it possible to have null references?
A) Yes, the reason for this is that C++ needs to be usable for device drivers, embedded systems, and real-time systems that can reach directly into the hardware, the ability to reference specific addresses is valuebale and required. For this reason, most compilers support a null or numeric initialization of a reference without to much complaint, crashing only if you try to use the object in some way when that reference would be invalid.

Taking advantage of this in normal programming, however, is still not a good idea. When you move your pogram to another machine or compiler, mysterious bugs might develop if you have null references. In short, DON'T USE THEM !!!

6) What happens when a function prototype requests a reference?
A) Then the address of the original object is put on the stack, not the entire object.

7) How does the client (the caller) of a function know that the function uses references?(where can the client look)
A) By examining the parameters declared in the prototype, the client can look these up in the header-file(s) which tells the client all that is needed to know; it acts as the interface to the class or function.

8) What's one method of allowing a function to "return" more than 1 value?
A) One way to solve this is to pass two objects into the function, by reference.

9) What benefits are there for using const references as parameters to functions rather than allowing the compiler to make copies of the objects? When is this most useful?
A) Each time you pass an object into a function by value, a copy of the object is made. Each time you return an object from a function by value, another copy is made. Seeing as these objects are copied onto the stack, it not only takes time to do so, it also uses more memory then using references or pointers. For small objects, such as built-in integer values, this is trivial cost. However, with larger, user-created objects, the cost is greater. The size of a user-created object on the stack is the sum of each of its member variables. These in turn, can each be user-created objects, and passing such a massive structure by copying it onto the stack can be very expensive in performance and memory consumption.

10) According to the text, when is the best time to use references? When is the best time to use pointers?
A) Use references whenever possible, use pointers when you have to be able to create a NULL pointer or when you have to be able to reassign it to another object.

11) What is the primary thing to be careful of when returning references from a function?
A) You have to make sure that the returned reference won't go out of scope once the function terminates. This would create a reference pointing to nothing.

12) According to the author, is it a good idea to allocate memory within a function, if the primary purpose is to return the newly allocated object back to the caller? If not, what's an alternate solution?
A) No, according to the author, it is not a good idea, there are three alternative solutions to this in his mind:
1. Declare an object in the calling function and return that object by value from the function.
2. Declare an object on the free store in the function, and have that function return a pointer to that memory to the calling function.
3. Most suitable solution would be to declare the object in the calling function and then to pass it to the function by reference.

Original post by rip-off

Quote:
5) Is it possible to have null references?

No. Any attempt to create a "null reference" involves undefined behaviour. As you allude in a later answer, if one needs the concept of a NULL reference, use a pointer instead. No compilers support null or numeric initialisation of references.

Well, I thought that was the case, but since the book mentioned the answer I gave, I thought it was important to add it. Understand that you never use them, but, seeing as the book mentioned it, it must have it's uses.

Quote:
6) What happens when a function prototype requests a reference?
A) Then the address of the original object is put on the stack, not the entire object.

While you can think of it like this, don't. Although many reference concepts apply to pointers, references are not pointers. In practise compilers will probably implement references with machine code pointers, we are at a higher level than that. We say instead that the variable is not copying but instead aliased directly through the reference parameter.

I understand that it is aliased, but, that does mean that the alias address is put on the stack, and not the whole object to which the reference aliases right?

Quote:
12) According to the author, is it a good idea to allocate memory within a function, if the primary purpose is to return the newly allocated object back to the caller? If not, what's an alternate solution?
A) 2. Declare an object on the free store in the function, and have that function return a pointer to that memory to the calling function.

2) is the solution you are trying to avoid [smile]

Hmm, strange, because number two was mentioned in the book as one of the solutions, though not the correct solution to choose.

You are using memory on the heap, which stays available after the functions scope ends, why couldn't I use this pointer on the heap then to return it to the calling function and delete it there seeing it still exists after the scope of the function?

Thanks for the help rip-off, hope you understand my answers to your replies.

Quote:Original post by rip-off
Is the function we are trying to rewrite this:

MyObject *createObject() { return new MyObject(); }

or this:

MyObject createObject() { return MyObject(); }

If the second, then yes you are correct that returning a pointer will work (although a smart pointer is preferable to a raw pointer).

I was actually talking about the first one, not only that, where are you using a pointer in the second version?

Quote:I hope I'm making sense with my replies. [grin]

You are, atleast... for the most part [grin]

Yep, now I am confused [SMILE]

I thought you said, that N° 2 was something we should avoid doing?

I thought that it would be possible since we would return a pointer on the heap.
Therefore, it would exist even if the function went out of scope, this pointer could then be deleted in the calling function right? It's my impression, this is what N° 2 stands for?