Re: inheriting from std::vector bad practice?

From:

Kai-Uwe Bux <jkherciueh@gmx.net>

Newsgroups:

comp.lang.c++

Date:

Sat, 03 Apr 2010 19:14:50 +0200

Message-ID:

<hp7t2b$urn$1@news.doubleSlash.org>

Alf P. Steinbach wrote:

* Kai-Uwe Bux:

Alf P. Steinbach wrote:

* Steve Chow:

Originally I had a bunch of related functions that all took a vector
of Point2D as their argument.
Point2D findGreatestDistance(std::vector<Point2D>& points);

However, this didn't strike me as a very C++/OO way to do things, so I
found a solution I was happy with in:
class Path : public std::vector<Point2D>
{
public:
   Path();
~Path();
   Point2D findGreatestDistance();
  /* related functions */
};

And it works, at least as far as I can tell. Yet it's been received by
people more knowledgeable than me as disgusting and wrong, without
explaining why. Is there a better way I should be doing this?

Yes. In terms of knowledge distribution you have ensured that the
knowledge required to do something (findGreatestDistance) is there. But
in doing so you have enabled both inadvertent and intentional abuse of
knowledge, like posting a recipe for creating a simple biological
weapon-of-mass-destruction on the net; you have forgotten to /limit/ the
access to those in need to know.

I have difficulties in seeing what you mean; especially with the advice
you give below.

Someone suggested moving findGreatestDistance into Point2D (struct
with x,y and overload ==) but I don't see how that's possible because
it'd only be able to look at itself.

Yes, that sounds like a silly suggestion.

Instead, replace inheritance of std::vector<Point2D> with a private
member.

Ok, lets say we had:

  class Path {

   std::vector<Point2D>

  public:

   Path();
   ~Path();
   Point2D findGreatestDistance();
   /* related functions */

  };

How does that limit the knowledge of findGreastedDistance to those in
need to know?

It doesn't and what you're asking is AFAICS not meaningful.

A: "Peter was several hours under water."
B: "How did he survive?"
A: "He didn't. Therefore, what you're asking is not meaningful."

It limits
knowledge of the implementation of the sequence of points as a
std::vector<Point2D>.

I see. I was misunderstanding you because you mentioned findGreatestDistance
as the main example for distributed knowledge. I was, therefore, under the
impression, that you also suggested limiting _that_ knowledge to those in
need to know. But for the limiting, you really had _other_ knowledge in
mind.

Best

Kai-Uwe Bux