C++ Library Inclusion Guards

Question

Just a question of style, or possibly even a malpractice I am unaware of.

I am currently writing my first piece of software, which will be used and reviewed by people other than myself. When I am writing my code and calling my headers, is it bad practice to call the same header multiple times across files.

For example

exampleClass.h

#ifndef BUG_H
#define BUG_H
#include<string>

class Bug{
private:
    int bug_id; //6 digit int
    Date creation_ts; //Date object containing time of creation
    std::string short_desc; //Short description of bug
    std::string classification; //Catagory of bug_id
    std::string product; //What product is the bug regarding
    std::string component
}

#endif

anotherExample.h

#ifndef ANOTHEREXAMPLE_H
#define ANOTHEREXAMPLE_H
#include<string>

class Pug{
private:
    int bug_id; //6 digit int
    Date creation_ts; //Date object containing time of creation
    std::string short_desc; //Short description of bug
    std::string classification; //Catagory of bug_id
    std::string product; //What product is the bug regarding
    std::string component
}

#endif

Is there anything wrong with including string twice in two different header files if both have dependencies? Will this cause errors later in the software's life?

It's very likely that `` has its own [*header* include guard](https://en.wikipedia.org/wiki/Include_guard). — Some programmer dude, Aug 30 '16 at 15:33

Arnav Borborah · Accepted Answer · 2016-08-30T15:37:31.580

2

If the two files are unrelated, eg not included both in the same source, then you have no choice. Otherwise, It doesn't really matter, since <string> would get included anyway, if you included one file after the other. One of the files would still need it. But still, if one file ever needs a file, ALWAYS include it. There is always the risk that one time someone may forget to include the other file, and the code won't compile. Don't take the risk, trusting clients.

In addition, std::string has include guards as well, so no need to worry about multiple inclusion. Also, for safety of inclusion, you can do this fr your headers:

#pragma once
#ifndef HEADER_H
#define HEADER_H
//.....Code
#endif

You could always #pragma or #define, (as in 1 or the other), but putting both guarantees header guards, since old compilers don't support #pragma once

edited Aug 30 '16 at 15:37

answered Aug 30 '16 at 15:32

Arnav Borborah

11,357
8
43
88

was the question edited after you gave the answer? As it stands now I neither really understand the question nor do I understand why you explain include guards when OP has them already – 463035818_is_not_an_ai Aug 30 '16 at 16:43
It is just irrelevant info, to assure the OP to not worry about dobule-definition errors, or double-inclusion errors @tobi303 – Arnav Borborah Aug 30 '16 at 19:30
hm ok. I mean if the question was not edited, it seems like OP was using them without really understanding their purpose and your explanation isnt irrelevant at all – 463035818_is_not_an_ai Aug 31 '16 at 09:23
I mainly included it since the other answers were, too – Arnav Borborah Aug 31 '16 at 12:26

score 1 · Answer 2 · answered Aug 30 '16 at 15:33

Is there anything wrong with including string twice in two different header files if both have dependencies? Will this cause errors later in the software's life?

No. In fact, you should include every header file that you actually have dependency on. You shouldn't rely on some other header being included that includes your dependency. It's failure to include all the headers you need that causes errors. If your class needs std::string, it should include <string>. Period.

All headers should have include guards (whether of the #ifndef or #pragma once varieties). Certainly the ones in your standard library implementation do. So the downside of extra includes is just marginal extra preprocessing time, with the upside being guaranteed compiling code.

score 1 · Answer 3 · answered Aug 30 '16 at 15:33

1

You have to include string if you are using it in your class. Since string is also protected against multiple inclusions it is fine.

BTW there's a better way than the ifdefs to avoid multiple inclusions:

#pragma once

answered Aug 30 '16 at 15:33

Jean-François Fabre

137,073
23
153
219

Please also see [Why isn't C/C++'s "#pragma once" an ISO standard?](http://stackoverflow.com/questions/1695807/why-isnt-c-cs-pragma-once-an-iso-standard) – Bo Persson Aug 30 '16 at 16:47

C++ Library Inclusion Guards

3 Answers3