Thread: Differene between reference object and value object

I'm kinda confused between the two

Code:

#include <string>

class Address;

class Driver						
{
public:
	Driver(Address& ad);

	void SetDriverDetails(const std::string&  fname, const std::string&  lname, const std::string& IDno, 
		const std::string&  contact);
	const std::string&  getFName() const;
	const std::string&  getSName() const;
	bool ReadFromFile(std::istream& i, std::string* refNo);
	friend std::istream& operator>>(std::istream& in, Driver& driver);
	void SetAddress(Address add);
	Address getAddress() const;
	const std::string& getContact() const;
	const std::string& getIDNo() const;

private:
	std::string firstName;
	std::string lastName;
	std::string idNo;
	Address& address;
	std::string contact;
};

If you look into this driver class, i have an object Address. Am kinda confused whether to make it a reference like i have, or remove the '&' sign ...

this is how i use it

Code:

// Overload for reading input file streams 
std::istream& operator>>(std::istream& in, Driver& driver)
{
	std::string fname, sname, licNo, contact;
	Address add;
	std::string IDNo;

	in >> fname >> sname;
	in >> IDNo;
	in >> contact;
	in >> add;

        // Here ....
	driver.SetAddress(add);

	driver.SetDriverDetails(fname, sname, IDNo, contact);
	
	return in;
}

void Driver::SetAddress(Address add)
{
	address = add;
}

As a rule of thumb, I'll often pass a class by reference (or const reference) rather than by value.

If your "Driver" type is smallish (eg a small number of integer members) then there is no much difference either way. If it is a moderately large type (multiple members, base classes, etc) or has a non-trivial copy constructor (eg copying it dynamically allocates memory) then you will often be better off using a reference.

Strictly speaking, the trade-off between passing by reference or value are compiler dependent. But, in practice, the comments or rule of thumb above, usually apply.

As a rule of thumb, I'll often pass a class by reference (or const reference) rather than by value.

If your "Driver" type is smallish (eg a small number of integer members) then there is no much difference either way. If it is a moderately large type (multiple members, base classes, etc) or has a non-trivial copy constructor (eg copying it dynamically allocates memory) then you will often be better off using a reference.

Strictly speaking, the trade-off between passing by reference or value are compiler dependent. But, in practice, the comments or rule of thumb above, usually apply.

Originally Posted by Elysia

If you can, take any non-native type by reference.
The address inside the class should not be a reference. Why? Because:
1) References must be initialized in the initializer list.
2) You would be pointing that reference to a local variable.
You need to think of the consequences.

my thoughts exactly.. i removed all references where there's no need

Originally Posted by King Mir

A reference class member works like a non-nullable const pointer; it always points to the same thing as long as a class exists. This implies that the value referred to must be in scope for the duration of the existence of the class holding the reference. This is a requirement and guarantee. When it does hold, the a reference is preferred to a const pointer, because it cannot be null. But for most cases a pointer or a copy is more useful.

Which brings me to the next question, what's the difference between Address& add; and const Address& add; ? If you shouldn't be changing both ...

I know whats the difference between a const and non-const, my code has always showed that, you guys didn't get my question !!!!

Originally Posted by King Mir

A reference class member works like a non-nullable const pointer; it always points to the same thing as long as a class exists. This implies that the value referred to must be in scope for the duration of the existence of the class holding the reference. This is a requirement and guarantee. When it does hold, the a reference is preferred to a const pointer, because it cannot be null. But for most cases a pointer or a copy is more useful.

You logically shouldn't have a setAddress function when the Address member in the class is a reference because you can't reseat references

Assuming he meant reset ...

From these statements, it sound to me you can't change an address member object, unless am not reading these English statements too well. Well, English ain't my first language

Originally Posted by csonx_p

I know whats the difference between a const and non-const, my code has always showed that, you guys didn't get my question !!!!





Assuming he meant reset ...

From these statements, it sound to me you can't change an address member object, unless am not reading these English statements too well. Well, English ain't my first language

No, he meant reseat.

I don't know what you mean by "address member object": do you mean reference (like Address &bob)? References cannot be changed to refer to other objects:

Code:

int foo = 5;
int &bar = foo; //bar will always and forever refer to foo -- it can never refer to another int variable