If you really want to do it, you can cast the ptr to a killer:

void Killer::kill (VictimListWithExtraInfo* victs) {
((Killer*) (victs->theVictimList[0]))->_protIntArray[0] += 5;
}

Really what you should do is use a clean object oriented approach with getters and setters. Something like this:

void Killer::kill (VictimListWithExtraInfo* victs) {
(victs->theVictimList[0])->IncrementProtIntArrayAt(0,5);
}

void Human::IncrementProtIntArrayAt(int indx, int value){
_protIntArray[indx] += value;
}

Quote:Original post by King of Men
I have an abstract base class which I'll call Human. It has two derived classes, call them Killer and Victim. It also has a protected member _protIntArray. Now, at one point, Killer has to take a pointer to a Victim and do something to its _protIntArray, thusly:

void Killer::kill (VictimListWithExtraInfo* victs) {  victs->theVictimList[0]->_protIntArray[0] += 5;}

OK, so it looks something like this (with some ugly things renamed)?

class Human {  protected:  int magic[42];};class Victim : public Human {};struct ShootingGallery {  std::vector<Victim*> victims;  int extra_info;};class Killer : public Human {  public:  void kill(ShootingGallery* s) {    s->victims[0]->magic[0] += 5;  }};

OK, well, then, several questions immediately spring to mind...

- Apparently the ShootingGallery is holding its Victims by pointer. Is this for polymorphism (i.e. it actually has a container of Human*'s, and Killers are themselves capable of being targeted)? If so, have you considered the use of smart pointers, or boost ptr_containers (such as ptr_vector)? If not, why not just store the Victims by value?

- Why is the ShootingGallery passed in via pointer? We ought to use a reference instead, surely?

- The work is divided wrongly. Repeated arrow operators are a sign of violation of the Law of Demeter.

Rearranging that, we get something like:

class Human {  public:  void takeDamage() { magic[0] += 5; }  private:  int magic[42];};class Victim : public Human {};class ShootingGallery {  std::vector<Victim> victims;  int extra_info;  public:  void wound(int who) const {    victims[who].takeDamage();  }};class Killer : public Human {  public:  void kill(const ShootingGallery& s) const {    s.wound(0);  }};

IMX, need for the 'protected' keyword is fairly rare, even when you are using inheritance and runtime polymorphism.

Quote:Original post by King of Men
I'm not storing the Victims by value because the list of Victims is a temporary subset of my pool-of-all-Victims. I've got code elsewhere that makes a list of eligible victims, calculates the extraInfo about this particular list, and passes that to the Killer. It seems to me that this is just the kind of thing pointers were invented for; you've got things stored somewhere, and you need access to them so they can be modified.

Sure; that's a perfectly good use of pointers too (and another one that came to mind, but the thought didn't fully form). These are "weak pointers", in case you ever need to study the CS literature. (When you work with boost::shared_ptr, you will sometimes also need to use boost::weak_ptrs so that you can indicate which pointers are "important" - otherwise the weak pointers can result in memory leaks by "holding onto" things that aren't actually in use and creating cyclic structures.)

I'm sort of interested in what the extraInfo is, now, though. :)

Quote:Using a reference is a good idea. For the law of Demeter, I must say I'd never heard of it, but it's not a bad idea. However, my ShootingGallery struct is basically just a wrapper around an std::vector<Victim*>; replicating the whole Victim interface to Killer just to avoid some extra arrows strikes me as a spot of overkill.

It wouldn't replicate the whole interface; only the part the Killer cares about. And it wouldn't *replicate* it, anyway; it would *delegate to* the Victim.

Quote:How about I give it an [] operator to wrap the vector[] instead? That would prettify the code.

Sure; that, in combination with doing the addition from within the Victim, is probably about as good. Except I would want the operator to dereference as well, so that we can avoid exposing ugly pointers to the client code. And at that point, calling it operator[] is getting pretty tricky.

We get:

class Human {  public:  void takeDamage() { magic[0] += 5; }  private:  int magic[42];};class Victim : public Human {};class ShootingGallery {  // weak pointers.  std::vector<Victim*> victims;  int extra_info;  public:  Victim& victim(int who) const {    return *victims[who];  }};class Killer : public Human {  public:  void kill(const ShootingGallery& s) const {    s.victim(0).takeDamage();  }};

It still violates the LoD itself (by having the Killer "reach into" the Shooting Gallery to grab a Victim, and then manipulate the Victim - instead of letting the ShootingGallery "play with its own toys"), but it avoids a lot of the problems that the LoD is meant to guard against, and handles pointers in a pretty way. I think single-level, minor violations like this are usually OK. It becomes a matter of whether you can justify it in terms of object responsibilities; a ShootingGallery is "mostly just a container" which makes this look better.