Removing Unused (Unreferenced) Static Global Variable Constants in C++

Question

Update,

I tried removing the static modifier, and I tried putting them in a namespace (as well as both of those), and none worked.


Hi,

I have a header file with common constants like names and stuff that are automatically included in each project (an example follows). The thing is that they are included in the compiled binary (EXE) whether they are used (referenced) or not. If I use DEFINEs instead, then naturally they are not included if they are not used, but of course consts are better than defines so… I tried Googling it, but the closest thing I could find was a question right here on SO that did not quite help. Matters of i18n aside, how can I keep the ones that are not used out of the binary, while still keeping it easy to use like this?

Thanks.

//COMMON.H:
  static const CString s_Company _T("Acme inc.");
  //etc. others
  static const CString s_Digits  _T("0123456789");

//TEST.CPP:
  #include common.h
  int main() {
    AfxMessageBox(s_Company);
  }

  //s_Company should be in the final EXE, but s_Digits should not be, but is

Answer 1

The reason they're not stripped from the binary is because they are used: CString is not a POD type, so when you create instances of them at global scope, the compiler has to generate code to call their constructors and destructors.

If you want unused symbols to be stripped, just replace the CStrings with a POD type such as const TCHAR*:

static const TCHAR *s_Company = _T("Acme inc.");
static const TCHAR *s_Digits  = _T("0123456789");

Then, the unused constants will be stripped from your binary automatically by the compiler. However, one important thing to keep in mind is that if your strings are used in multiple files, then your binary will have multiple copies of those strings in it, one copy for each translation unit that uses the string. Not even gcc's -fmerge-constants option seems to fix this. If you don't want this to happen, you'll need to use extern declarations in your header files and then put the string constants' values in source files (usually in one file, but that's not required). This also allows you to change the constants without needing to recompile every file that uses them.

Answer 2

If you don't need the values as literals, you can declare them in the header file as:

extern const CString s_Company;

Put each one of them in its own source file that defines it as:

const CString s_Company _T("Acme inc.");

Then you can only link in the constants that you need; the linker will tell you in its error messages if you're missing any! (There are also ways to tell the compiler to not make those symbols public in the built library – assuming you're building a library at all – but they're not standard or portable.)

Answer 3

If there are clear rules defined that make it clear when you want to use what, then you can use preprocessor defines like this:

#if defined CONFIG_COMPANY
  static const CString s_Company _T("Acme inc.");
#elif defined CONFIG_DIGITS
  static const CString s_Digits  _T("0123456789");
#endif

You can then define or not define either of these values in a separate configuration header.

By the way, if this file is meant to be included in many source files, then you should probably refrain from declaring these constants as static. They have internal linkage and you'll get a separate copy of them in all of your translation units.

Answer 4

On Windows, especially using MFC, the answer is to put the strings into resources, and load the string from there using LoadResource / LoadString (see http://msdn.microsoft.com/en-us/library/a44fb3wy(VS.80).aspx)

In your case, you have two constant CStrings, So the resource compier will generate something like

#define IDS_COMPANY 1
#define IDS_DIGITS  2

So in this case you would have a .dll with two strings. You app would load the .dll (AfxLoadLibrary). Then when you need the string your app loads it from the resource .dll.

This is what keeps Windows apps from bloating with global static strings, bitmaps, etc.