When to use pointers in a class?

[Joe Van Dyk]

Is there some rule of thumb about when to use pointers to an object and
when to use a reference* to an object when a class needs to have objects
as data members?

Example:
class A
{
B* b_ptr;
B b;
vector<B*> vector_ptrs;
vector<B> vector_objects;
};

How do I know when to use pointers and when not to use them?

Thanks,
Joe

* I'm not sure if my terminology is correct here, please correct me if
I'm wrong. I'm also slightly confused about the relationship between
references and pointers. I know a reference is an alias of an object
and a pointer contains some address that's usually the start of the
object's location in memory, but I'm still not sure what the real
difference is.

[Joe Van Dyk]

Joe Van Dyk wrote:

Is there some rule of thumb about when to use pointers to an object and
when to use a reference* to an object when a class needs to have objects
as data members?

Related question:

I have a class that looks like this:
class Image
{
public:
typedef unsigned int color_type;
Image(size_t width, size_t height);
void write(const std::string& image_file_name );
void set_pixel(size_ t x, size_t y,
color_type r, color_type g, color_type b);

private:
Magick::Image &_image;
Magick::Geometr y &(geometry;
Magick::ColorRG B &_background_co lor;
};

(documentation on ImageMagick++ is at
http://www.simplesystems.org/Magick+...mentation.html)

Quick overview: a Magick::Image takes in its constructor a Geometry and
a Color. A Magick::Geometr y takes in its constructor a width and a
height. And the Magick::ColorRG B object takes nothing in its constructor.

Do I want to use references to the member objects here? Or pointers?
I'm having difficulties initializing the objects if they are references
and aren't passed in to the Image constructor.

Thanks,
Joe

[Joe Van Dyk]

Joe Van Dyk wrote:

Joe Van Dyk wrote:

Is there some rule of thumb about when to use pointers to an object
and when to use a reference* to an object when a class needs to have
objects as data members?

Related question:

I have a class that looks like this:
class Image
{
public:
typedef unsigned int color_type;
Image(size_t width, size_t height);
void write(const std::string& image_file_name );
void set_pixel(size_ t x, size_t y,
color_type r, color_type g, color_type b);

private:
Magick::Image &_image;
Magick::Geometr y &(geometry;

oops
Magick::Geometr y &_geometry;

Magick::ColorRG B &_background_co lor;
};

(documentation on ImageMagick++ is at
http://www.simplesystems.org/Magick+...mentation.html)

Quick overview: a Magick::Image takes in its constructor a Geometry and
a Color. A Magick::Geometr y takes in its constructor a width and a
height. And the Magick::ColorRG B object takes nothing in its constructor.

Do I want to use references to the member objects here? Or pointers?
I'm having difficulties initializing the objects if they are references
and aren't passed in to the Image constructor.

Thanks,
Joe

[Daniel T.]

In article <Iw********@new s.boeing.com>,
Joe Van Dyk <jo********@boe ing.com> wrote:

Is there some rule of thumb about when to use pointers to an object and
when to use a reference* to an object when a class needs to have objects
as data members?

Example:
class A
{
B* b_ptr;
B b;
vector<B*> vector_ptrs;
vector<B> vector_objects;
};

How do I know when to use pointers and when not to use them?

Think of a reference as a const pointer that can't be NULL, and uses
object syntax. IE:

B& rb;
B* const pb;

Are very much alike in their behavior. For rb you do "rb.someFun c()" for
pb you do "pb->someFuc()"

Here are some basic rules of thumb...

As member-variables: prefer by-value. If you need to hold something that
is being shared among several objects, then use a pointer. If you need
to hold something that is an Abstract Base Class (ABC) then use a
pointer.

A vector template defines a vector's member-variables so use the same
rule as above for making one. IE prefer vector<B> unless the things
contained in the vector are being shared or B is an abstract base class.
--
Magic depends on tradition and belief. It does not welcome observation,
nor does it profit by experiment. On the other hand, science is based
on experience; it is open to correction by observation and experiment.

[Phlip]

Daniel T. wrote:

As member-variables: prefer by-value.

Except when indulging in "encapsulat ion construction". ;-)

--
Phlip
http://www.greencheese.org/ZeekLand <-- NOT a blog!!!

[Phlip]

>> As member-variables: prefer by-value.

Except when indulging in "encapsulat ion construction". ;-)
Uh, "constructi on encapsulation". ..

--
Phlip
http://www.greencheese.org/ZeekLand <-- NOT a blog!!!

[Squeamizh]

Joe Van Dyk wrote:

Is there some rule of thumb about when to use pointers to an object and
when to use a reference* to an object when a class needs to have objects
as data members?

One important thing to keep in mind is that if a class contains a
reference, then instances of it cannot be contained in an STL
container*. It is not always easy to know when you're designing the
class if this is something you'll need to do in the future or not.

* Assuming there isn't an assignment operator that doesn't touch the
reference.

[Jim Langston]

"Joe Van Dyk" <jo********@boe ing.com> wrote in message
news:Iw******** @news.boeing.co m...

Is there some rule of thumb about when to use pointers to an object and
when to use a reference* to an object when a class needs to have objects
as data members?

Example:
class A
{
B* b_ptr;
B b;
vector<B*> vector_ptrs;
vector<B> vector_objects;
};

How do I know when to use pointers and when not to use them?

Thanks,
Joe

* I'm not sure if my terminology is correct here, please correct me if I'm
wrong. I'm also slightly confused about the relationship between
references and pointers. I know a reference is an alias of an object and
a pointer contains some address that's usually the start of the object's
location in memory, but I'm still not sure what the real difference is.

I would say use a pointer if you need polymorphism. You can't get
polymorphism through a reference (my understanding anyway). Also, you can
reassign a pointer, you can't reassign a reference. The reference needs to
be set in the constructor initialization list, so the object being
referenced has to exist before the consturctor.

[Howard]

"Jim Langston" <ta*******@rock etmail.com> wrote in message
news:sW******** *******@fe03.lg a...

I would say use a pointer if you need polymorphism. You can't get
polymorphism through a reference (my understanding anyway).
Yes, you can. Polymorphism doesn't come into play when making calls
directly on an object's methods, but it does when making calls on the object
through a pointer or reference to it.
Also, you can reassign a pointer, you can't reassign a reference. The
reference needs to be set in the constructor initialization list, so the
object being referenced has to exist before the consturctor.

-Howard

[Ian Collins]

Jim Langston wrote:

"Joe Van Dyk" <jo********@boe ing.com> wrote in message
news:Iw******** @news.boeing.co m...

Is there some rule of thumb about when to use pointers to an object and
when to use a reference* to an object when a class needs to have objects
as data members?

Example:
class A
{
B* b_ptr;
B b;
vector<B*> vector_ptrs;
vector<B> vector_objects;
};

How do I know when to use pointers and when not to use them?

Thanks,
Joe

* I'm not sure if my terminology is correct here, please correct me if I'm
wrong. I'm also slightly confused about the relationship between
references and pointers. I know a reference is an alias of an object and
a pointer contains some address that's usually the start of the object's
location in memory, but I'm still not sure what the real difference is.

I would say use a pointer if you need polymorphism. You can't get
polymorphism through a reference (my understanding anyway). Also, you can
reassign a pointer, you can't reassign a reference. The reference needs to
be set in the constructor initialization list, so the object being
referenced has to exist before the consturctor.

Yes you can get polymorphism through a reference.

If the object being referenced exists when the container is constructed,
knowing the object is there saves the code form checking a pointer for
NULL.

If the contained object can be replaced, then yes, use a pointer.
--
Ian Collins.

[Jim Langston]

"Howard" <al*****@hotmai l.com> wrote in message
news:W8******** **********@bgtn sc04-news.ops.worldn et.att.net...

"Jim Langston" <ta*******@rock etmail.com> wrote in message
news:sW******** *******@fe03.lg a...

I would say use a pointer if you need polymorphism. You can't get
polymorphism through a reference (my understanding anyway).

Yes, you can. Polymorphism doesn't come into play when making calls
directly on an object's methods, but it does when making calls on the
object through a pointer or reference to it.

Also, you can reassign a pointer, you can't reassign a reference. The
reference needs to be set in the constructor initialization list, so the
object being referenced has to exist before the consturctor.

-Howard

Wow, you're right. My understanding was wrong. The output of the following
program is "derived".

#include <iostream>
#include <string>

class base
{
public:
virtual method() { std::cout << "base" << std::endl; }
};

class derived: public base
{
public:
method() { std::cout << "derived" << std::endl; }
};

int main ()
{
derived MyDerived;
base& baseref = MyDerived;
baseref.method( );

std::string wait;
std::cin >> wait;
}