Re: inheriting from std::vector bad practice?
Steve Chow wrote:
In your example above, a Path might be represented by a
std::vector<Point2D>, but whether the IS-A relationship (or LSP) is
valid is questionable. By pinning down the representation of a Path so
concretely, you make it harder to change the interface later on.
The Animal: Cat, Dog example always makes the relationship between
objects seem so clear.
When ideas become more abstract I have a real difficult time
determining whether an
object should contain an object or should be an extension of an
object.
As an unrelated example I have an image class and and a class that
extracts information
from the image and translates it to data that I use for a game. That
class is completely useless
without the image class and the relationship seems murky. Another one
was "does a window have an engine? or does an
engine have a window" that arose because I was passing arguments to
Engine's constructor just so it could forward
arguments to Window's constructor. I still feel dirty. Obviously I
don't expect a solution
since I haven't provided any really useful information. I'm just
saying it's not always clear as a car
has an engine, a dog is an animal, etc. At least for me.
Well -- in the case of the imaging example, I can't see why either class
would inherit from the other (an Image isn't a DataExtractor, or
vice-versa). I'm assuming the DataExtractor class is some sort of
functor, incidentally. The relationship seems to be that some other code
instantiates a DataExtractor, and uses it to extract data from an image.
Or something along those lines :) Either way, doesn't sound like there
should be an inheritance relationship between those two classes.
In the case of the engine/window example (and I'm now speculating), it
sounds like maybe what you're after is a model/view design. The engine
is the model, and maintains a list of "model listeners" that get
informed when the model changes. The window is the view. Views are model
listeners (in practical terms, this usually means View inherits from
ModelListener and implements some sort of model_changed() virtual
function in ModelListener). Views contain a reference to the particular
model they're working with, so that when it changes they can access it.
Like I say, I'm just speculating -- but hope that helped. You might want
to look at the Design Patterns book by Gamma et al., it's quite helpful.
One might also question whether there is any logical reason why a Path
IS-A std::vector<Point2D> any more than it IS-A std::list<Point2D>, for
example.
Someone asked if all I was using was .push_back and []; the answer is
I'm not even using [].
I'm just using vector at this point because outwardly it can act like
a list and act like an array
if I decide to change it in the future.
Indeed -- the potential need for change in the future is one key reason
why publicly inheriting from std::vector isn't a good idea (even though
it can be made to work).
If you're using it for a toy program,
you'll probably get away with it (but should strive to improve your
design skills nonetheless). If you're using it on a team project, expect
others to ask you to change it.
it's a toy project at the moment, but I aim to bring others on board
once I have a prototype, which is why
correctness is important to me.
Regarding findGreatestDistance(), it's somewhat hard to say where it
should go because you haven't specified precisely what it does (in
particular, the Point2D it returns doesn't seem like a distance).
p_it a,b;
p_it furthest;
float max = 0;
for(a = this->begin(); a != this->end(); a++)
{
for(b = this->begin(); b != this->end(); b++)
{
float dx = a->x - b->x;
float dy = a->y - b->y;
float distance = sqrt(pow(dx,2)+pow(dy,2));
if(distance > max)
{
max = distance;
furthest = b;
}
}
}
return *furthest;
greatestDistance is actually a misnomer. It should be furthestPoint
(the point that is furthest away from all other points in the vector)
and I'm not even sure that code is correct, but it doesn't appear to
be giving me problems.
As far as I can see, this code finds a pair of the points of maximum
distance from each other and arbitrarily returns one of them (the second
one). That's not the same as what you describe above, which sounds like
you want to sum the distances of each point from every other point and
return a point whose sum is maximal. In other words, given a point set S
= {p1,...,pn}, you want to find pi maximising:
\sum_{j=1}^n ||pj - pi||
Something like this (not tested):
p_it i, j;
p_it furthest;
float maxDistance = 0.0f;
// For each possible furthest point...
for(p_it i=begin(); i!=end(); ++i)
{
// ...calculate its total distance from other points...
float distance = 0.0f;
for(p_it j=begin(); j!=end(); ++j)
{
if(j == i) continue;
float dx = j->x - i->x, dy = j->y - i->y;
distance += sqrt(dx*dx + dy*dy);
}
// ...and compare this to the highest total distance so far,
// updating the furthest distance and point if necessary.
if(distance > maxDistance)
{
maxDistance = distance;
furthest = i;
}
}
return *furthest;
Cheers,
Stu