Making a design decision about reading model data from an input file

Question

I am writing a finite element software in C++ and Qt. I want to load the input data to the model. I have a Model class that holds the data and does the work. I have created a simple lexer and parser to read the input file (things that resemble database records). I don't have the experience to make an informed decision on how relate the file reader class and model class. I have two options:

1) In class Model, create a method to load the file, i.e. in pseudocode:

 class Model
 {
   // private fields

   public:
     loadFile( filename )
  }

2) This:

class Lexer(input filename)
{
    ...
    loadToModel(Model&)  // red the input filename into the Model.
}

Which one is better or makes more sense? What are the pros and cons of each one?

Answer 1

Although the code in your question isn't very clear, my understanding is that you are proposing to create an object from some input data. You outline two options:

1. Make loading the data a public method. There are few upsides to this beyond convenience. It's a pretty clear violation of the Single Responsibility Principle and it couples the model's in-memory representation to its on-disk representation. This isn't usually a very good thing. It also potentially leaves your model in an invalid state after creation, which is also very error-prone. It is much better to have classes that are never in invalid states whenever possible. A slight improvement would be to make this a static member function, rather than an instance method.

2. Pass an existing instance to a separate loader. This is a somewhat better approach if, again, your model object has no invalid states. And if your model has no invalid states, then it should be trivial to initialize a default-constructed one inside the function, rather than taking a reference as a parameter.

The best solution, then, is the adjustment I mentioned in (2). Design your model so that a default-constructed instance is valid, and then write a method in your Lexer (perhaps renamed to "ModelLoader" or "Parser" since it is doing more than lexing) to load a file from disk and populate a fresh Model instance, and then return it. In modern C++, guaranteed return value optimization (RVO) should alleviate any concerns you might have with returning a large object.

Ideally, your loader/deserializer would also take an input stream of some sort, rather than a filename directly. Qt's QDataStream, for example, can abstract over several different media (drives, network, in-memory buffers, etc.)

If you need (or want) your Model to be immutable, then you can employ the Builder pattern to stage updates to a Model before actually constructing it.