Header Inclusion style

[qazmlp]

If I include the headers(.h files) like
#include "myHeader.h",
in my implementation file(.C file), then 'myHeader.h' is properly
included. But, when I include it like
#include <myHeader.h>, Compiler gives an error.

What setting do I need to do such that, the latter syntax also accepted
for my headers ?

 

[Bertrand Mollinier Toublet]

If I include the headers(.h files) like
#include "myHeader.h",
in my implementation file(.C file), then 'myHeader.h' is properly
included. But, when I include it like
#include <myHeader.h>, Compiler gives an error.

What setting do I need to do such that, the latter syntax also accepted
for my headers ?

[replied only in c.l.c]

None that you should know about. The latter syntax is reserved for
standard headers (in the ISO C meaning of the term), and any header your
implementation is willing to consider standard.

Your own headers are your own only, and should always be included with
the #include "foo.h" syntax.

 

[Floyd Davidson]

If I include the headers(.h files) like
#include "myHeader.h",
in my implementation file(.C file), then 'myHeader.h' is properly
included. But, when I include it like
#include <myHeader.h>, Compiler gives an error.

What setting do I need to do such that, the latter syntax also accepted
for my headers ?

The <...> notation finds headers "in the standard places", hence
system headers, as opposed to those that you provide, will be
found.

The "..." notation probably looks in the current working
directory first, and will thus include headers you provide,
before looking in the same places that <...> will look.

That means you probably want to use the different notations
thusly,

#include <stdio.h> /* header provided by the platform */
#include "myhdr.h> /* header provided by the program */

With unix style compilers you also have the option of adding to
the places the compiler thinks of as "standard", usually with
the -I option. Hence invoking the compiler with '-I./include'
will cause the <...> notation to also look in the ./include
directory for headers.

You'll definitely want to read the documentation for your
compiler. You can also look for an option that will tell you
more about what it is doing. For example, with the GNU C
compiler, gcc, you can give it the -v option and it will
verbosely explain what it is doing and where it is searching for
headers (and libraries, and whatever).

 

[Darrell Grainger]

If I include the headers(.h files) like
#include "myHeader.h",
in my implementation file(.C file), then 'myHeader.h' is properly
included. But, when I include it like
#include <myHeader.h>, Compiler gives an error.

What setting do I need to do such that, the latter syntax also accepted
for my headers ?

The places searched are implementation defined for both formats. You'd
have to consult your compiler documentation to find out where it searches
for the different headers.

Typically, #include <file.h> will search the system header files and
#include "file.h" will search the project header files and then the system
header files.

Why is it important that you use #include <file.h> to find your header
files? If I looked at your source code I would assume the header file is
an implementation specific header file for a certain compiler. It would
not immediately occur to me that it was a project header file. When I see
#include "file.h" I immediately think this is a file created by the
project programmer and not the compiler company. This is all jut
convention but having conventions makes it easier for you to work with
others.

 

[JCB]

If I include the headers(.h files) like
#include "myHeader.h",
in my implementation file(.C file), then 'myHeader.h' is properly
included. But, when I include it like
#include <myHeader.h>, Compiler gives an error.

What setting do I need to do such that, the latter syntax also accepted
for my headers ?

I don't think you can.
If it was the case, your program will be less clear, because less easy
to distinguish beetween standard headers and "personnal" headers.

Just one question : why do you want to use the <file.h> syntax with
your personal headers ???

 

[Ben Pfaff]

#include "myhdr.h> /* header provided by the program */

Is that a joke?

 

[Default User]

If I include the headers(.h files) like
#include "myHeader.h",
in my implementation file(.C file), then 'myHeader.h' is properly
included. But, when I include it like
#include <myHeader.h>, Compiler gives an error.

This guy just HAS to be trolling. He's supposedly been studying C and
C++ for over a year now, he's posted dozens if not hundreds of questions
to various groups, all of them these simplistic matters that he could
have figured out by reading the books he claims to own or from a brief
google search.




Brian Rodenborn

 

[Emmanuel Delahaye]

If I include the headers(.h files) like
#include "myHeader.h",
in my implementation file(.C file), then 'myHeader.h' is properly
included. But, when I include it like
#include <myHeader.h>, Compiler gives an error.

Good.

What setting do I need to do such that, the latter syntax also accepted
for my headers ?

The <> headers are reserved for the implementation (standard or not).
The "" headers are reserved for the user's headers.

 

[Emmanuel Delahaye]

"myHeader.h" without that comma is in the current working directory.

This is completely implementation dependent.

<myHeader.h> is in /usr/include or one referenced by some -I/directory or
-isystem /somedirectory.

This is completely implementation dependent.

The good reason was exposed already on the other posts.

<> -> implementation
"" -> user

 

[Dave Uhring]

This is completely implementation dependent.

The good reason was exposed already on the other posts.

<> -> implementation
"" -> user

Works the same way with gcc and Solaris cc. What is your point?

 

[Emmanuel Delahaye]

Works the same way with gcc and Solaris cc. What is your point?

It's a question of design. The <> headers are preprocessor directives. They
are not necessarely including a real file. They just tell the compiler to
behave 'as-it'.

The "" have to include an actual file.

 

[Eric Bernard]

If I include the headers(.h files) like
#include "myHeader.h",
in my implementation file(.C file), then 'myHeader.h' is properly
included. But, when I include it like
#include <myHeader.h>, Compiler gives an error.

What setting do I need to do such that, the latter syntax also accepted
for my headers ?

Which of "myHeader.h" or <myHeader.h> works depends entirely on your
compiler. The ISO standard specifies that both ways search for headers
in an implementation-defined manner. It also says that if #include
"myHeader.h" fails (or is not supported), the line is reprocessed as
if it were read #include <myHeader.h>.

On the practical side, a compiler will search a header included with
quotes in the working directory, and will search where its settings
tell it to when included with <>.

 

[Richard Bos]

Works the same way with gcc and Solaris cc. What is your point?

This is cross-posted to comp.lang.c. It's probably defined by the SUS or
POSIX or something similar, but in ISO C it's not even defined whether
you can put your own header files in the <> location; in fact, it isn't
even defined whether you, the user, can read the system header files.

Of course, said cross-post is evil, for precisely that reason.

Richard

 

[Dave Uhring]

Of course, said cross-post is evil, for precisely that reason.

Of course, that was cross posted to comp.unix.programmer,
comp.unix.solaris, and comp.lang.c

Evil is as evil does ;-)

 

[Casper H.S. Dik]

The preprocessor will only search the system directories for the <>
headers (and there are probably options to modify the system search
path, for gcc/g++ it is -isystem). It will search a different path
(according to command line options again, for gcc/g++ it is -I) to
search for the "" files, and if none is found the system include path
will be searched. Note that the usage of -isystem and -I differs from
what you wrote, at least for gcc/g++.

Pathnames enclosed in "<>" are search with -I for all C compilers
I'm familiar with (the -isystem option is slightly different)/

Files enclosed in "" are first searched in the directory where the
file which includes them resides; then the ordinary <> search path
is used.

Casper