C question: Why would one put 'static' variables in a header?

I don't think that's just "potentially" - it's for certain!

Especially in cases like the example I showed - which is quite a large table!!

I don't think that's just "potentially" - it's for certain!

Especially in cases like the example I showed - which is quite a large table!!

To show their C prowess?

We had a guy here a while ago that took one of my projects and put ALL the contents of every header file into one super large header file.

"Why?", I asked, "So I only have to edit one file of course" came the reply.

--- Now why didn't I think of that?

This was the same guy who had a function that returned "TRUE", "FALSE" and 2.

--- I'll never forget his C prowess!

and put ALL the contents of every header file into one super large header file

I know of at least one commercial product that has that (I did not write that part, though...).

Indeed - I have a copy.

But I still don't see why having static definitions in header files would be a useful thing to do.

What am I missing?

I have a method of #inclusion that works in a highly structured environment. This does allow static to be used in a header file, but it is segregated from the rest of the included file(s).

/*
** UART.C
**
*/

#define UART_Module 1
#include "Includes.h"
#undef UART_Module  // NON MISRA, but deemed okay by me

The "Includes.H" file contains and controls all included files within the project.

/*
** Includes.H
**
*/

//////////////////////////////////////////////////
// COMMON TO ALL "C" MODULES                    //
//////////////////////////////////////////////////
#include "TMS320LF2813.H" // SFR Mapping
#include "SystemDefs.H"   // System Definitions
@include "Structures.H"   // Global System Structures
#include "gDefs.H         // Global Definitions
#incldue "gData.H"        // Global Data Stores

//////////////////////////////////////////////////
// SPECIFIC TO EACH "C" MODULE                  //
//////////////////////////////////////////////////

//-----------------------------------------------
#ifdef UART_Module
#include "UART.H"
#endif
//-----------------------------------------------

//-----------------------------------------------
#ifdef SPI_Module
#include "SPI.H"
#endif
//-----------------------------------------------

//-----------------------------------------------
#ifdef PWM_Module
#include "PWM.H"
#endif
//-----------------------------------------------

etc.

Each Header file would then be split into either module specific or 'extern' access:

/*
** UART.H
**
*/

#define MAX_ROWS 29     // "global" values to all that include this file
#define MAX_COL   2     // "global" values to all that include this file

/* ============================================

/* ============================================
**
**  Module Specific (Data Allocation)
**
** ============================================
*/

#ifdef UART_Module

.-----------------------------------------------.
;   TCO count to temperature  conversion table. ;
'-----------------------------------------------'

static erTcoTableStruct tcoTableOPUS1[] = {
    /*{TCO,Temp,} */
    {1,-99},  {4,-45},  {5,-40},  {8,-35},  {11,-30}, {16,-25}, {22,-20}, {29,-15},
    {37,-10}, {48,-5},  {61,0},   {78,5},   {99,10},  {124,15}, {153,20}, {188,25},
    {227,30}, {270,35}, {315,40}, {365,45}, {420,50}, {481,55}, {549,60}, {625,65},
    {710,70}, {805,75}, {910,80}, {1010,85}, {1060,88}
};


/* ============================================
**
**  NON-Module Specific (Externs)
**
** ============================================
*/
#else // not included by "UART.C" but referenced...

// NOTE: "erTooTableStruct" is structured in "Structures.H"
extern erTooTableStruct tooTableOPUS1[ MAX_ROWS ][ MAX_COL ];

#endif

Using this format, I can control what includes get included with each module, and when. In addition, I don't have to worry if each module has the proper 'global' header files, and avoids a mismatch or redundant inclusions.

--Cpt. Vince Foster
2nd Cannon Place
Fort Marcy Park, VA

P.S. You are welcome: I rarely give out such information.

But why would you ever want to do that?

What am I missing?

This could make some sense if each copy of the table had to be modified individually.
The other possibility is that the author of the code didn't want to make the table 'global', so only the files that include the header can access it. Some kind of phobia of global variables.
Either way, it looks strange.

Total Control

All data allocation on a module basis should be kept in a header file.

--Cpt. Vince Foster
2nd Cannon Place
Fort Marcy Park, VA

Why would you want to have distinct but identically-named and identically-typed objects in multiple files??

Again,

Total Control

--Cpt. Vince Foster
2nd Cannon Place
Fort Marcy Park, VA

#ifdef UART_Module

.-----------------------------------------------.
;   TCO count to temperature  conversion table. ;
'-----------------------------------------------'

static erTcoTableStruct tcoTableOPUS1[] = {
    /*{TCO,Temp,} */
    {1,-99},  {4,-45},  {5,-40},  {8,-35},  {11,-30}, {16,-25}, {22,-20}, {29,-15},
    {37,-10}, {48,-5},  {61,0},   {78,5},   {99,10},  {124,15}, {153,20}, {188,25},
    {227,30}, {270,35}, {315,40}, {365,45}, {420,50}, {481,55}, {549,60}, {625,65},
    {710,70}, {805,75}, {910,80}, {1010,85}, {1060,88}
};


/* ============================================
**
**  NON-Module Specific (Externs)
**
** ============================================
*/
#else // not included by "UART.C" but referenced...

// NOTE: "erTooTableStruct" is structured in "Structures.H"
extern erTooTableStruct tooTableOPUS1[ MAX_ROWS ][ MAX_COL ];

#endif

That won't work - you can't have an extern reference to something that was declared static!

Although the use of static CAN be circumvented, as shown, it is still not conforming with the C spec:

(1) An identifier declared in different scopes or in the same scope more than once can be made to refer to the same object or function by a process called linkage. There are three kinds of linkage: external, internal, and none.

(2) In the set of translation units and libraries that constitutes an entire program, each declaration of a particular identifier with external linkage denotes the same object or function. Within one translation unit, each declaration of an identifier with internal
linkage denotes the same object or function. Each declaration of an identifier with no linkage denotes a unique entity.

3 If the declaration of a file scope identifier for an object or a function contains the storage class specifier static, the identifier has internal linkage.

Therefore, declaring static - by definition above - forces/restricts the identifier to be internal.

Sorry about being nit-picky.

I think you can, but I might be rusty on my "C." I only say that because you (ANDY) are an excellent embedded guy, and therefore I *might* be wrong on the extern to a static.

--Cpt. Vince Foster
2nd Cannon Place
Fort Marcy Park, VA

Dear Captain,

I think that doing what you propose really harms the chance of a less-informed "code-monkey" to correctly maintain C code. I mean, I have encountered too many software spaghettization instances so far, due to:
* Incompetence
* Sloth
* A bad character
* Job security
* Arrogance

I don't want to add "control freak" to this list :-) :-) :-)

Tamir,

Although it might look 'complicated' it really isn't. All too many times people will re-include files that don't need to be included, and will sometimes include the wrong file (esp the SFR files).

Using my method, the code is very structured and all include files are in total control via the "Includes.H" file.

This also adds to the reliability of the code, not to mention repeatability during the debug phase.

Any code-monkey who cannot handle this structure should be taken out back and, well you get the idea.

I think once you have tried it, you'll stick with it.

--Cpt. Vince Foster
2nd Cannon Place
Fort Marcy Park, VA