I am writing a program with multiple headers and code files, as so:

  • message.h
  • message.cpp
  • option.h
  • option.cpp
  • main.cpp

message.h includes option.h as message.cpp requires the definition of the class defined therein.

There are quite a few other files, however just to keep it brief...
If I want to call a function such as memcpy, I include string.h. I include string.h in message.h - so it works fine in message.cpp, but if I want to use it in option.cpp it gives me an error.

So I see two options:

  1. In option.h, I include message.h again. This should not be an issue as I have include guards in both header files, however I feel it's rather messy.
  2. I include string.h in option.h. Now I am including string.h in both of my header files.

This gives me the declaration for memcpy and so I can get on with my programming. However when I'm including 10 different headers for many different functions, it's going to be messy again.

What is a good way for me to structure my code to get around this issue, to keep my code as neat as possible? It has crossed my mind to make all my includes in one separate file and include that in all my header files, could this be a problem in the future, and is there a better way I can go about this to ensure my code is maintainable?

  • It has crossed my mind to make all my includes in one separate file and include that in all my header files, could this be a problem in the future - #include'ing the kitchen sink in each file works for small projects but if the project gets big it might harm compilation time. Try doing a benchmark to see the impact on your environment. Make sure you're using namespaces properly to avoid name conflicts and I can't see any maintainability problem with this approach.
    – Brandin
    Commented May 11, 2015 at 5:25
  • Ok, that's good to know. For larger projects, is it better to just include the library files required in every header file?
    – Shane
    Commented May 11, 2015 at 6:16

1 Answer 1


It's perfectly fine to #include additional headers in .cpp files that are not included in the corresponding .h. In fact, you should always do so if the header is not required in the .h, because that potentially speeds up compilation of anything that depends on your .h but not on your .cpp. See this classic Guru of the Week for some tips on minimizing unnecessary #includes in your header files (I don't think any of them have gone out of date yet).

In general, you should avoid relying on what other files do or don't include as much as possible, since that makes your code more modular (and more portable to other standard libraries). That means every file should explicitly and directly #include every header that it needs to know about (I'm assuming every header file has #include guards or an equivalent like #pragma once, since not having those is a far bigger problem). If the message.h author decides to follow that GotW I linked and cut down their superfluous #includes, it would be awfully frustrating if he unknowingly broke option.h/.cpp in the process. At work we once discovered some of our code would compile under GCC but not Clang solely because we were missing a few standard library #includes, and thus unknowingly depended on the fact that certain GCC headers #included each other.

So the direct answer to your original question is: You should directly include string.h in every file you plan on using it, and no others. Assuming you aren't using memcpy() inside option.h (that seems unlikely), that means the #include belongs in option.cpp.

  • IMO include guards aren't necessarily a requirement. For example, most environments support #pragma once and that works just fine.
    – Brandin
    Commented May 11, 2015 at 7:09
  • @Brandin Edited slightly to mention that.
    – Ixrec
    Commented May 11, 2015 at 7:12

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.