On Sat, 5 Mar 2005 00:21:01 -0500, "Victor Bazarov"
<v.Abazarov@comAcast.net> wrote in comp.lang.c++:
[color=blue]
> "Exits Funnel" <exitsfunnel@noyahoospam.com> wrote...[color=green]
> > I'm slightly confused about when to use parens around #included files[/color]
>
> You're not alone.
>[color=green]
> > and when to use angle brackets. I understand (I think) that the
> > difference is that the compiler will search in its standard include
> > directories for files included as <file> but not for those included as
> > "file". It's clear to me then that headers for the standard libraries
> > (eg, iostream) should be included using the '#include <iostream>' form
> > while header files for the classes I write should be included as '#include
> > "myheader.h"'.[/color]
>
> Both forms cause implementation-defined behaviour. Whatever you know
> about what actually happens is specific to your compiler. Another
> compiler is free to behave differently. It has to document it, however.
>[color=green]
> > I'm not so sure though for the cases in between. For example what if I
> > purchase a third party library. Which form should I use to include its
> > headers? Are there any hard and fast rules? Any conventions? Thanks in
> > advance for any replies.[/color]
>
> It's all driven by the compiler rules. Read the documentation for your
> compiler, it should explain those details. Most compilers I used did
> have <> for searching in "predefined places", but VC++, for example, will
> search for "" in those places, too.
>
> Recently I've read some things about the differences, alleging that <>
> (angle brackets) are reserved for the compiler headers. AFAICT it's not
> necessarily so, and even if it is so in the Standard, all compilers I've
> used do allow you to have your own header [file] and define its name in
> the angle brackets. To me that means there is no rule saying that <>
> should only name headers and never user's files.
>
> V[/color]
For the standard headers provided as part of the standard language,
such as <iostream> or <cstdlib>, the standard requires the use of <>,
and does not require that the standard headers be files.
This does not have much practical effect in any implementation that I
know of, but even if <iostream> is a file, these two directives are
not guaranteed or required to work the same way:
#include <iostream>
#include "iostream"
The second is not guaranteed to work properly by the standard, the
first is.
For inclusion of files, there is no real difference other than the
locations searched.
For a #include "somename" directive, the C++ standard requires that if
the file is not found in the special locations searched for this form
of the directive, the implementation must then search in whatever
other places it searches for the <> form of the include directive.
The real problem with putting standard headers in the "quoted" form is
that the compiler might stumble over some other file of the same name
somewhere in its search path before it comes to the real standard
header.
--
Jack Klein
Home:
http://JK-Technology.Com
FAQs for
comp.lang.c
http://www.eskimo.com/~scs/C-faq/top.html
comp.lang.c++
http://www.parashift.com/c++-faq-lite/
alt.comp.lang.learn.c-c++
http://www.contrib.andrew.cmu.edu/~a...FAQ-acllc.html 
