heap based objects

[Tony Johansson]

Hello Experts!

I know that to use heap-based objects, the C++ programmer has to define
variables that are of pointer types like Car *car = new Car;

Now to my question I also read this "to use heap-based objects, the C++
programmer has to define variables that are of either pointer or reference
types."

Is it really possible to use heap-based object when having variables of
reference types.

How does that statement look like if that is possible.

//Tony

[Josh Mcfarlane]

Tony Johansson wrote:

Hello Experts!

I know that to use heap-based objects, the C++ programmer has to define
variables that are of pointer types like Car *car = new Car;

Now to my question I also read this "to use heap-based objects, the C++
programmer has to define variables that are of either pointer or reference
types."

Is it really possible to use heap-based object when having variables of
reference types.

How does that statement look like if that is possible.

//Tony

Well, think about dereferencing a pointer, perhaps from the return of
another function.

Car test()
{
Car* car = new Car;
return *car;
}

Also, you could do the same for parameters.

For test(Car& car)

You could call it with test(*pCar) and it would never know the
difference.

The former I've used very very rarely (if at all, can't remember), but
you never know when you might need these things.

HTH,
Josh McFarlane

[Alipha]

Josh Mcfarlane wrote:

Tony Johansson wrote:

Hello Experts!

I know that to use heap-based objects, the C++ programmer has to define
variables that are of pointer types like Car *car = new Car;

Now to my question I also read this "to use heap-based objects, the C++
programmer has to define variables that are of either pointer or reference
types."

Is it really possible to use heap-based object when having variables of
reference types.

How does that statement look like if that is possible.

//Tony
Well, think about dereferencing a pointer, perhaps from the return of
another function.

Car test()

Car& test()
{
Car* car = new Car;
return *car;
}

Note that if a function allocates dynamic memory, you should return a
pointer to that dynamic memory, never a reference. With a reference, it
is assumed that the function will clean up the memory in some way. With
a pointer, any decent programmer will at least look at the function's
documentation to know whether or not the caller needs to clean-up the
memory. Or better yet, use a std::auto_ptr or another smart pointer
class to make ownership clear.

[Josh Mcfarlane]

Alipha wrote:

Note that if a function allocates dynamic memory, you should return a
pointer to that dynamic memory, never a reference. With a reference, it
is assumed that the function will clean up the memory in some way. With
a pointer, any decent programmer will at least look at the function's
documentation to know whether or not the caller needs to clean-up the
memory. Or better yet, use a std::auto_ptr or another smart pointer
class to make ownership clear.

True, the example that came to my mind involved allocating in the
constructor and then deallocating in the destructor, and then returning
references, but returning the pointer is normally alot more useful. Was
just trying to give an easy example. =)

Josh McFarlane

[E. Robert Tisdale]

Tony Johansson wrote:

I know that, to use heap-based objects,
the C++ programmer [must] define variables
that are of pointer types like Car *car = new Car;

Now to my question, I also read this,
"to use heap-based objects, the C++ programmer [must] define variables
that are of either pointer or reference types."

Is it really possible to use heap-based object
when having variables of reference types.

How does that statement look like if that is possible. cat main.cc #include <iostream>
#include <string>

class Car {
private:
// representation
std::string Make;
std::string Model;
public:
// functions
std::string make(void) const {
return Make;
}
std::string model(void) const {
return Model;
}
// operators
friend
std::ostream& operator<<(std::ostream& os, const Car& car) {
return os << car.make() << ' ' << car.model();
}
// constructors
Car(const std::string& make = "Chevrolet",
const std::string& model = "Corvette"):
Make(make), Model(model) { }
};

int main(int argc, char* argv[]) {
const Car& car = *(new Car);
std::cout << car << std::endl;
delete &car;
return 0;
}
g++ -Wall -ansi -pedantic -o main main.cc
./main

Chevrolet Corvette

[msalters]

Tony Johansson schreef:

Hello Experts!

I know that to use heap-based objects, the C++ programmer has to define
variables that are of pointer types like Car *car = new Car;

Now to my question I also read this "to use heap-based objects, the C++
programmer has to define variables that are of either pointer or reference
types."

Is it really possible to use heap-based object when having variables of
reference types.

Easily. The reason is that C++ supports inheritance. A Car* can hold a
(new Car) but also a (new SportsCar). Now, if you want to pass both
to a function, the function shouldn't try to copy the Car. If it copies
a Car, it copies only the Car parts and loses the SportsCar extras.
A function that takes a Car& will not copy the Car, so it will work on
the original SportsCar.

HTH,
Michiel Salters