Перегрузка вставки потока без нарушения сокрытия информации?

Типичный способ сделать это, не нарушая инкапсуляцию, состоит в том, чтобы сделать функцию operator>> дружественной. Должно быть, возникла синтаксическая проблема с вашим объявлением оператора-друга (из сообщения об ошибке неясно, что именно). Я не использую YAML, но из вашего вопроса следует следующее:

class Note{
    ...
    friend void operator >> ( const YAML::Node& node, Note& note );
    ....
 };
 void operator >> ( const YAML::Node& node, Note& note ){
    node[0] >> note._number;
    node[1] >> note._author;
    node[2] >> note._subject;
    node[3] >> note._body;
 }

Функция друга имеет те же права доступа к закрытым членам, что и функция-член.

В качестве альтернативы вы можете объявить сеттеры для всех данных-членов, но метод дружественной функции будет чище.

Мне нравится использовать вспомогательный метод. Поскольку метод является частью класса, он будет иметь полный доступ ко всем приватным полям:

class Note {
public:
    void read(const YAML::Node& node)
    {
        node >> ...;
    }
};

а затем пусть operator>> просто переадресует вызов:

const YAML::Node &operator >> ( const YAML::Node& node, Note& note ) {
    note.read(node);
    return node;
}

Вы определяете дополнительные методы установки в Note, такие как

void number(YAML::Immitter& e) { e>>_number; }

и т. д., и затем вы определяете синтаксический сахар >> как

void operator >> ( YAML::Immitter& e, Note& note ) {
  note.number(e);
  note.author(e);
  note.subject(e);
  note.body(e);
}

Я не знаком с пространством имен YAML, которое вы используете (я знаю yaml, но я никогда не работал с ним на C++), но примерно так вы поступили бы с обычными потоками (кроме возвращаемых типов void;-), и я уверен, что его можно легко адаптировать к вашим конкретным потребностям.

В вашем классе уже есть методы установки. Просто используйте временные файлы для чтения значений и используйте методы установки для настройки объекта:

void operator >> ( const YAML::Emitter& node, Note& note ) {
  unsigned long number;
  unsigned long author;
  // ...
  node[0] >> number;
  node[1] >> author;
  // ... everything properly read, edit the node:
  node.number(number);
  node.author(author);
  // ...
  return;

}

Некоторые другие комментарии: класс, который имеет сеттеры/геттеры для всех атрибутов, вряд ли инкапсулирован. Вы предоставляете пользователям тот же уровень доступа, как если бы ваши поля были на самом деле общедоступными (с единственным преимуществом, что вы можете добавить проверку позже, но все равно инкапсуляция слаба).

В решениях, которые предлагают добавить метод-член, который принимает узел YAML, это добавит дополнительную зависимость для всех пользователей вашего класса. Хотя вы можете использовать предварительные объявления, чтобы не заставлять их включать заголовки YAML, вы не сможете извлечь библиотеку с вашим Note для использования в другом проекте, который не использует YAML легко.

Потенциальное расточительное использование ресурсов, вероятно, будет очень ограниченным. Потом опять же, как всегда, сначала измерьте, а потом попробуйте решить проблемы, если они у вас есть.

Ну, вот идея, которую вы могли бы рассмотреть. Вы говорите, что проблема с функцией ‹‹, которая не является другом и не членом, заключается в том, что она включает в себя множество объявлений tmp. Рассматривали ли вы возможность инкапсулировать концепцию и построить вокруг нее повторно используемый компонент? Использование может выглядеть примерно так:

inputter& operator >> (inputter& in, my_type & obj)
{
  input_helper<my_type> helper(obj);

  in >> helper.setter(&my_type::number);
  in >> helper.setter(&my_type::subject);
  // etc
}

Ответственность input_helper состоит в том, чтобы просто предоставить функцию шаблона setter(), которая возвращает объект, который просто считывает значение и вызывает с ним сеттер, создавая необходимую временную переменную. Код, подобный этому, потребует некоторого близкого знакомства с шаблонами, но не будет особенно сложным. Я не могу сейчас соображать полностью — может быть, простудился — или я, вероятно, смог бы просто напечатать это. Может быть, что-то вроде этого:

template < typename T >
struct input_helper
{
  input_helper(T & t) : obj(t) {}

  template < typename V >
  struct streamer
  {
    streamer(T & t, void (T::*f)(V const&)) : obj(t), fun(f) {}

    template < typename Stream >
    Stream& read_from(Stream & str) const // yeah, that's right...const; you'll be using a temporary.
    {
      V v;
      str >> v;
      obj.(*fun)(v);
      return str;
    }

  private: // you know the drill...
  }

  template < typename V >
  streamer setter(void (T::*fun)(V const&))
  {
    return streamer(obj, fun);
  }
private:
  T & obj;
};
// etc...  operator >> (blah blah) { return setter.read_from(stream); }

Конечно, в этом есть всевозможные ошибки, но это должно дать вам представление. Также потребуется больше работы, чтобы обобщить.