Proper class member access in scientific simulation

Question

I'm currently working on a program, a scientific simulation, with the following structure (first level - logical grouping, second level - implemented classes, third level - implemented subclasses):

• Input Data
  • Sample
  • Parameter (abstract base class, declaring virtual functions)
    • ParModel1
    • ParModel2
    • ...
• Physical Models
  • Model (abstract base class, declaring virtual functions)
    • Model1
    • Model2
    • ...
• Simulation
  • Simulation

The Model subclasses (e.g. ModelX) define certain algorithms in a virtual Calculation(int x) function, representative for the physical model X to be described. The parameters to be used in this calculation will be provided by a Sample object and a respective ParModelX object. The Simulation class knows how to deal with a Model in general and will eventually perform the calculation for a given x (by calling the public Calculation(int x) function)... in a biiig for-loop.

We approach the actual question... During each iteration, the calculation defined by the ModelX will be performed and thus various parameters of the Sample and ParModelX objects need to be accessed.

Since the Simulation class only triggers a provided public calculation function of Model, it's only Sample and Parameter which both have to communicate with Model.

Should I...

1. Have the members declared private and provide get-functions? (I read that heavy dependence on getters/setters can be a sign of flawed design. Could too many get function calls be a problem in an ample for loop or is it "bad style" respectively?)
2. Have the members declared 'public' but const (they won't need to change!) so that 'Model' can access them without a function call? (Doesn't look like good style to me...)
3. Let the Model constructor extract the parameters from given Sample and Parameter objects and store them in its own members for quick access (this would make the Parameter class redundant!)
4. friend Sample and Parameter (etc.) with the according Models
5. other options...?

I'm concerned about the speed (even if it may not be important in my particular calculation, I want to know what would be good programming style!) and the structure of my program. I, for instance, don't want the models to be mixed with the simulation/calculating process. The separation of input data and models seemed good to me, because of the possibility to have many parameter sets for one model...

Answer 1

All of this depends on a whole lot of circumstances, so please be cautious with the following general considerations.

As long as you don't know that you are facing performance issues, I would definitely favor well-structured design over performance optimization—you'll thank yourself if you ever need to come back to this code, e.g., if you need to extend it somehow. Separating data structures from objects which operate on them certainly sounds like a valuable idea. Introducing constant values, hoping for better performance while sacrificing the ability to use different sets of values in your computation, sounds like a bad idea. Personally, I'm fond of getters and setters because they provide an interface for accessing data while abstracting how the data is represented internally. I wouldn't expect a big performance hit from them, they are even likely to get "optimized away" by the compiler. The friend keyword is an access modifier and (other than some compiler-specific black magic) probably won't have a big impact on performance—I've only ever used it in the context of unit testing.

When thinking about performance bottlenecks in your scenario, my gut feeling tells me to rather watch out for things like passing around big data structures by value and unnecessary re-calculations instead of reusing intermediate results. And if you are truly interested in performance insights, stop guessing, grab one of those profiling tools and start measuring!