Question

Using objective c , I have 2 classes that are using hardware, and are written in c +objC .
The other classes in the project are objective c, and they create instance of those classes.

My question .

Lets say I have classA.m and classB.m . they both have an integer const that needs to be the same say : const int numOfSamples=7;

I am seeking for the best solution to create some configuration file, that will holds all this const variables, that both A and B can see them .
I know some ways,but I wonder whats the RIGHT thing to do .

1. I wonder if I can just create a : configuration.m and write them into it .
2. to use a singleton file that holds all globals .

Number 1 seems to me the best , but how exactly should I do it ?

Thanks.

Answer 1

For approach 1 to work, you need to define two files:

1. a header file where you declare all of your constants;

2. a .m file where your constants are defined and initialized.

In your example:

/* .h file */
extern const int numOfSamples;

/* .m or .c file */
const int numOfSamples = 7;

Then, you include the .h header in every other file where you need those constants. Notice the extern keyword, this will declare the variable without also defining; in this way, you can include the .h file multiple times without having a duplicate symbol error.

EDIT:

The approach I suggest is the correct way to handle global variables in a C program.

Now, if global variables are a good thing or not, well, that is a longer story.

Generally speaking, global variables are tricky and go against a 40 years long effort towards better encapsulation (aka, information hiding) of data and behavior in a program (see “On the Criteria to Be Used in Decomposing Systems Into Modules”, David Parnas, 1972).

To further explain this, one aspect of the problem is exactly what you mention in your comment: the possibility of one module changing the value of a global variable and thus affecting the whole behavior of the program. This is recognizedly bad and leads to uncontrollable side effects (in any non trivially sized program).

In your case, I think things are a bit different, in that you are talking about “configuration” and “const” values. This is an altogether different case than the general one and I think you could safely use a header file of consts to that aim.

That said, you understand that the whole theme of configuration is a huge one, in general. E.g., you could need mechanisms to change your program configuration on the fly; in this case the constant variable header approach would be not correct. Or, your program configuration could depend on the state of some remote system (imagine: you are logged in vs. you are not logged in).

I can’t guarantee that using a header file is the best approach for your case, but I hope that the above discussion and the example I gave you can help you figure that out.