Best Accessor and Mutator Pattern implementation?

[audinue]

Passing any reference into/from accessor and mutator IS forbidden.

Why?

Let say we have a Rectangle class which aggregates Point and Dimension class.

class Rectangle {
public:
  virtual Point *getLocation(void);
  /* OR
  virtual Point &getLocation(void); */
};

So any client who use Rectangle object will be able to modify the Point object
WITHOUT notifying the Rectangle object, and this is violate the accessor and mutator pattern for sure.

Point *point = rectangle->getLocation();
point->setX(point->getX() + 1); // BOOM!

This is also become a common mistake of Java programmers who doesn't know the concept, since every object are passed by reference, not a copy.

class Aggregator {
  private Aggregated aggregated;

  public Aggregated getAggregated() {
    return aggregated; // << WRONG WAY!
  }

  /* unless you do this
  public Aggregated getAggregated() {
    return aggregated.clone();
  }*/
}
.
.
Aggregated aggregated = aggregator.getAggregated();
aggregated.setAProperty( anotherProperty ); // BOOM!

This is useless getter and setter, since the Aggregator know nothing whenever the Aggregated is modified, and we loss the flexibility and reusability terms.

But there is a drawback or complex side effect when we copy every single thing to conform this problem, consider an example below.

class AnotherClass {
  YetAnotherClass *pYetAnotherClass;
};

class SomeClass {
  AnotheClass *pAnotheClass;
};

class SomeClassAggregator {
public:
  virtual SomeClass getSomeClass(void) {
    //exploding brain detected!!
  }
};

And performance loss problem.

class ComplexClass {
  List<HugeClass> veryHugeHugeClassList;

  /**
   * @return returns a copy of very huge HugeClass list.
   */
  virtual List<HugeClass> getVeryHugeHugeClassList(void);
};
.
.
class ComplexClassContainer {
  List<ComplexClass> veryHugeComplexClassList;

  /**
   * @return returns a copy of very huge ComplexClass list.
   */
  virtual List<ComplexClass> getVeryHugeComplexClassList(void);
};

What will you do to solve this kind of design problem?

However I'm using C++ codes here just for example.
This post is generic enough and can be implemented in any other language.

Thanks in advance.

[audinue]

Ohh, hell yeah maybe I know something..

class Rectangle {
  const Point &getLocation(void) const; //Is it possible?
};

But how about the mutator and the huge list problem?