2

This is a followup question on my previous question:

Initialize const members using complex function in C++ class

In short, I have a program that has a class Grid that contains the properties of a 3D grid. I would like the properties of this grid to be read-only after creation, such that complex functions within the class cannot accidentally mess the grid up (such as if(bla = 10), instead of if(bla == 10)) etc. Now, this question has been answered well in the previous discussion: calling an initializer lists via a create function.

Here comes my new problem. My Grid has many properties that just plainly describe the grid (number of grid points, coordinates at grid points etc.) for which it just does not make sense to redistribute them among different objects. Still, basic textbooks in C++ always link functions with a large number of parameters to bad design, but I need them in order to be able to have const member variables.

Are there any standard techniques to deal with such problems?

Community
  • 1
  • 1
Chiel
  • 6,006
  • 2
  • 32
  • 57
  • 1
    Do *all* variables need to be members of the `Grid` class? Can't you split up the functionality in multiple classes, where each sub-class handles a subset of the current `Grid` class? – Some programmer dude Aug 03 '14 at 15:55
  • The variables are merely properties of that grid. Splitting them would be rather artificial. – Chiel Aug 03 '14 at 16:32

1 Answers1

1

The answer depends on what you're trying to protect.

  1. If you're trying to assure that users of the class can't inadvertently alter the critical parameters, then the way to do that is to declare these members as private or protected and only provide const getters if they're needed at all outside the class implementation.

  2. If you're trying to assure that the implementer of the Grid class doesn't alter these values, then there a few ways to do so. One simple way is to create a subclass that contains just those parameters and then the answer looks just like 1. Another way is to declare them const in which case they must be initialized when a Grid instance is constructed.

If the answer is 2, then there are also some other things that one can do to prevent inadvertently altering critical values. During the time that you're writing and testing the class implementation, you could temporarily use fixed dummy const values for the critical parameters, assuring that the other functions you write cannot alter those values.

One more trick to avoid specifically the if (i=7) ... error when you meant to write if (i == 7) ... is to always put the constant first. That is, write if (7 == i) .... Also, any decent compiler should be able to flag a warning for this kind of error -- make sure you're taking advantage of that feature by turning on all of the warning and error reporting your compiler provides.

Edward
  • 6,964
  • 2
  • 29
  • 55