OO Design Question

I'm not sure if this is the best group for this, but I'm sure it's a little
relevant.

Given the following design, my question is on the constness of book::find().
OO principles say that you should access object members by their getters &
setters to avoid changes to those members. However, being that find()
returns a reference to a "person", which in turn controls access to its
members by getter/setters, shouldn't find() return a non-const reference?

The following obviously failed since f is a const:
const person& f = mybook.find("Pazz");
f.setFirst("Edward");

I'd have to remove the constness first. Is this even a good practice or
should I just updated book::find() to return a non-const reference?
person& f = const_cast<person&>(mybook.find("Pazz"));
f.setFirst("Edward");

class person {
public:
  person(const std::string& first, const std::string& last) ;
private:
  std::string first;
  std::string last;
public:
  const std::string& getFirst() const;
  const std::string& getLast() const;
  void setFirst(const std::string& first);
  void setLast(const std::string& last);
};

class book {
private:
  std::vector<person> people;
public:
  void add(const person& p);
  const person& find(const std::string& name);
};

int _tmain(int /*argc*/, _TCHAR* /*argv[]*/)
{
  book mybook;
  person p("Eddie", "Pazz");
  mybook.add(p);

  const person& f = mybook.find("Pazz");
  f.setFirst("Edward");

  std::cout << f.getFirst() << " " << f.getLast() << std::endl;

  return 0;
}