Suppose we have a publicly declared function

Result ComputeResult(Foo foo);

whose implementation is complex and requires some temporary data structures. I might break the implementation down into steps to improve comprehension:

Result ComputeResult(Foo foo) {
  Result result;
  std::map<Bar, Baz> bar_to_baz;
  std::vector<Baz> extra_bazzes;
  GroupByBar(foo, &bar_to_baz, &extra_bazzes);
  AppendExtraBazzes(extra_bazzes, &bar_to_baz);
  ModifyBazzes(&bar_to_baz);
  // etc
  PopulateResult(bar_to_baz, &result);
  return result;
}

Passing the temporary structures around can get cumbersome, especially if the calls are nested; a parameter may only be indirectly relevant to the top level call. In some cases I find it more readable to define a helper class to hold them, instantiated once per function invocation:

class ResultComputer {
 public:
  ResultComputer(Foo foo) : foo_(foo) {}
  Result Compute() {
    GroupByBar();
    AppendExtraBazzes();
    ModifyBazzes();
    // etc
    PopulateResult();
    return result_;
  }
 private:
  void GroupByBar();
  void AppendExtraBazzes();
  void ModifyBazzes();
  void PopulateResult();

  Foo foo_;
  Result result_;
  std::map<Bar, Baz> bar_to_baz_;
  std::vector<Baz> extra_bazzes_;
};

Result ComputeResult(Foo foo) {
  return ResultComputer(foo).Compute();
}

I vaguely recall some advice about this but can’t find it – I don’t know what to search for. Does this pattern have a name?

Note: I’m not asking about the value of the pattern; that’s a separate question. I’m certainly not asking for detailed comments on my (very contrived) example.