Printable View
whats the difference between these two?
-----Code:MyMouse& getMouse() {return m_mouse;};
MyMouse* getMouse() {return &m_mouse;};
MyMouse is a class. and getMouse just returns the m_mouse which is a private member.
-----
I know to access the second one u need:
m_mouse->function inside the Mymouse();
the the first one:
m_mouse.function inside the Mymouse();
----
But when and how are they different - which is better? and when?
Thanks in advance,
There is basically no discernable difference. One returns a reference, the other a pointer.Quote:
Originally Posted by armen_shlang
The only real difference besides that is the usage of one over the other. If the m_mouse can be NULL, then you return a pointer (since references can't be NULL).
However, you forgot the third option:
This returns a copy of m_mouse back to the caller. The reason why this may be more desirable than either of the first two choices is that the Mouse object that is returned will survive if the object that contains it is destroyed.Code:MyMouse getMouse() const { return m_mouse; }
With the other two choices, this code will not work. The object that contains the mouse object is destroyed, and you will wind up with a reference that refers to nowhere, or a pointer that points to invalid memory.Code:void SomeCode()
{
MyMouse m;
{
Object object;
m = object.getMouse();
}
// m is still good here, even though object was destroyed
}
Regards,
Paul McKenzie
Quote:
Originally Posted by armen_shlang
Sometimes you have to return a pointer, but my personal preference is to use references when possible. References can't be NULL like pointer variables. So if the caller gets a reference to some object, they don't have to worry about doing this:
Even better is to return const references or const pointers, when possible. In order to use a reference, it must be assigned immediately, but pointers can be initialized to NULL and re-initialized later. You can't re-initialize references and you must initialize them to something immediately upon creation.Code:if (NULL != pVariable)
{
pVariable->callFunction();
}
Other people might have some other philosophical reasons as to why they prefer one or the other. By the way, don't fool yourself into thinking that you can return references when you should be returning by value. I think I read that somewhere (meyers, effective c++). Reference variables can be deceiving to look at because the reference variable looks and feels like any other variable but it is pointing to something that could be changed elsewhere in the program, just like a pointer.
A reference is very similar to a const pointer(except that a reference cannot be null). Other than that, the syntax is the major difference: you don't have to dereference a reference with that star thingy (edited).Quote:
Originally Posted by armen_shlang
reference. ;)Quote:
Originally Posted by 7stud
Thanks for the reply - I read more about it too.
HOWEVER, there's one thing that confuses me. the code...
getMouse return type is an address of the type MyMouse.Code:MyMouse& getMouse() {return m_mouse;};
however - the confusing part is where m_mouse is a regular variable and not the address? It makes sense if it were return &m_mouse.
Yes, that's one of the more confusing aspects of C++ syntax. In this case & means "reference to", not "address of".
Generally % means reference when applied to a type or argument, and address otherwise.
The two are related, naturally, but not quite the same.
Ok, I'm still confused. I though when I declared & before a function that means the return type of that specific function is an address?
IF that's not the issue, then why use referencing?
yes they can; references can point to the same places a pointer canQuote:
Originally Posted by Paul McKenzie
If you want to return an address, use a pointer (*) return type.Quote:
Originally Posted by armen_shlang
What's the point of references? Well, strictly speaking there isn't one. They're just pointers in disguise. Essentially, references are pointers except that you don't have to use pointer syntax, which can make things clearer sometimes.
The theory is that when dealing with references, you never have to worry about addresses and the like directly; you simply use an object as if it were local, but in so doing effect changes to a non-local object. With pointers, you actually have to be aware that you're dealing with an address and everything that entails.
You're probably confused because the & operator is used when assigning the address of something to a pointer, as I said before. References are slightly different than that.
In order for a reference to be null, it will have to be initialized with a null pointer that is dereferenced. Since dereferencing a null pointer is undefined behavior and a bug in the program, one can assume that the reference will never be null.Quote:
Originally Posted by spoon!
So if your application has a reference to null, then that is merely a symptom of a bug elsewhere in the program where a null pointer was dereferenced.
No, the & before a function is part of the return type. The & when part of a type means that type is a reference.Quote:
Originally Posted by armen_shlang
Exactly.Quote:
Originally Posted by jlou
Or, to put it another way: yes, references can be NULL, but not legally.
Set a reference to NULL, and have it not be either a hack or undefined behaviour. See 8.3.2 section 4 of the ANSI spec:Quote:
Originally Posted by spoon!
This is in the same category as returning a pointer to a local variable. Sure, you can do it, but what happens when it's done?Quote:
[Note: in particular, a null reference cannot exist in a well defined
program, because the only way to create such a reference would be to bind it to the “object” obtained by dereferencing a null pointer, which causes undefined behavior. As described in 9.6, a reference cannot be bound directly to a bitfield.]
Regards,
Paul McKenzie
Ok I'm sorry but the answers didn't digest quite well. Even though I'm sure an average person would've got it by now, but I didn't.
So i prepared a sample code, to understand it clearly, with examples.
Also, i'm trying to make a complete set with examples so maybe we can place it in the FAQs.
the output is:Code://**********************************************************
//**********************************************************
// Work In Progress
// Author Armen Babakanian
// A complete set of examples to illustrate the use of reference and pointers
// in related to functions and classes
//**********************************************************
//**********************************************************
#include <iostream>
#include <string>
using namespace std;
//*********************************************************
class Job
{
public:
Job(string compName, string titl, double sal)
: companyName(compName), title(titl), salary(sal){};
Job(){};
string& getCompanyName() {return companyName;};
string& getTitle() {return title;};
double getSalary() {return salary;};
void setCompanyName(string name) {companyName = name;};
void setTitleName(string name) {title = name;};
void setSalery(double name) {salary = name;};
private:
string companyName;
string title;
double salary;
};
//*********************************************************
class person
{
public:
person(string name, string last)
: m_name(name), m_last(last)
{
secondJob = new Job("DelTaco", "cleaner", 9.00);
fourthJob = new Job("Neverland", "cleaner", 200.00);
};
int getAge(){return m_age;};
string& getName(){return m_name;};
string& getLast(){return m_last;};
void setAge(int age) {m_age = age;};
Job& get1stJob(){ return firstJob;};
//------------------------------------
Job& get2ndJob(){ return *secondJob;};
//------------------------------------
Job* get3rdJob(){ return &thirdJob;};
//------------------------------------
Job* get4thJob(){ return fourthJob;};
//------------------------------------
Job get5thJob(){ return fifthJob;};
//------------------------------------
private:
string m_name;
string m_last;
int m_age;
Job firstJob;
Job* secondJob;
Job thirdJob;
Job* fourthJob;
Job fifthJob;
};
//**********************************************************
void main()
{
person RafaelB("Rafael","BakerMan");
RafaelB.setAge(22);
cout << RafaelB.getName() << " --" << RafaelB.getLast() << " --" << RafaelB.getAge() << endl;
RafaelB.get1stJob().setCompanyName("IBM");
cout << RafaelB.get1stJob().getCompanyName() << endl;
RafaelB.get3rdJob()->setCompanyName("Apple");
cout << RafaelB.get3rdJob()->getCompanyName() << endl;
RafaelB.get4thJob()->setCompanyName("Neverland");
cout << RafaelB.get4thJob()->getCompanyName() << endl;
RafaelB.get5thJob().setCompanyName("Microsoft");
cout << RafaelB.get5thJob().getCompanyName() << endl;
//this wont print Microsoft
}
Rafael --Bakerman --22
IBM
Apple
Neverland
now The Five get JOB functions w/ their private member functions are the main focus here. What exactly is happening in each one, and why is one compared to another bad or better or useful in some other way.
If the job object is custom for each person you could use a member object like 'firstJob' in your code. on the otherhand, if there are specific job roles in your company and several peoples can be attached to them you'll have it like
Here I assumed each person shoud have a firstJob, it can't be null; also you should know the firstJob at the time of constructing person objects. so it is possible to use a reference; hence use it.Code:class Job {
....
list<Job*> lst_jobs;
};
class person {
....
Job& myFirstJob;
Job* mySecondJob;
}
(use a member init list to initialise the reference myFirstJob)
if the second job can be null, or you don't know the value when constructing the person, you will need to have a pointer for mySecondJob.
to decide on how to have the getter functions,
returning a Job obect is costly, also remember you return a copy of it, so any modification to this returned object, will not reflected in the member object.
In my example, you can use a reference to return myFirstJob, as it can't be null. for the second job, you'll need to return a pointer.