Prevent instances of the same class from calling public functions (C++)

Question

Possible Duplicate:
Why do objects of the same class have access to each other’s private data?

Something I have never understood with trying to keep encapsulation:

Say I have a class called GameObject, and a derived class called Human. GameObject has a private variable position. I have multiple instances of Human, I want each human to be able to call SetPos() and set it's position as it wants. I do not however want one human to have the power to set up the position of another human. This is my problem.

If I have SetPos public or protected, each human can alter each others positions, if SetPos() is private, a human cannot even set its own position ( I need this, might be a weak example but I hope you understand).

Can anyone offer a solution?

Thanks.

Unless you're passing in a pointer of another human object, I'm not sure how a human object can alter another object's position. — JosephH, Nov 05 '12 at 13:46
@JosephH Probably what he has is pointers to `GameObjects` and what he wants is that, if the `GameObject` is a `Human` he may not call `setPos` on the other `GameObject` that might be a `Human`. — RedX, Nov 05 '12 at 14:00

Fred Foo · Answer 1 · 2012-11-05T13:55:57.693

1

if SetPos() is private, a human cannot even set its own position

Actually, it can, if SetPos is defined on Human. A private method can only be called from inside the class, but it does not protect instances of the same class from each other:

class Human {
  private:
    void set_pos(int i) { std::cout << "moving to " << i << std::endl; }
  public:
    void set_pos_on_other(Human &other, int i) const { other.set_pos(i); }
};

int main()
{
    Human alice, bob;
    bob.set_pos_on_other(alice, 10);
}

If SetPos is defined on GameObject and it has to be called by a Human, even if only on itself, then it needs to be protected or public.

To solve the problem of objects calling each other's private methods, you simply need to program carefully and stick to your invariants. C++ offers no special syntax for this. Whenever a Human method gets passed a reference or pointer to another Human, it can call that Human's private methods all it wants.

edited Nov 05 '12 at 13:55

answered Nov 05 '12 at 13:49

Fred Foo

355,277
75
744
836

2

I think `SetPos()` is a member of `GameObject`, so if it was private, `Human` could not call it. – Björn Pollex Nov 05 '12 at 13:50
@BjörnPollex: ah, right. My main point still stands, though, I'll try to amend the answer. – Fred Foo Nov 05 '12 at 13:52
Does it make any sense to have the setter as member in the derived class when the variable itself is member of the base class? – moooeeeep Nov 05 '12 at 15:05
@moooeeeep: not if the variable is `private`. – Fred Foo Nov 05 '12 at 15:08

score 1 · Answer 2 · answered Nov 05 '12 at 14:06

Encapsulation with public and private is intended to solve a different problem, namely that of making it easier to code the class by isolating it from other classes. Not isolating individual objects.

Perhaps you can restrict access by managing the pointers? Don't make pointers to objects generally available, but always go through an interface of some sort, identifying which object you want to use by a number or some other key?

Prevent instances of the same class from calling public functions (C++)

2 Answers2