Let's say we have two class, Foo and Bar.
in Foo.h
#ifndef MYPROJ_FOO #define MYPROJ_FOO .... # endif in Bar.cpp, do we still need to guard the include such as
#ifndef MYPROJ_FOO #include <Foo.h> #endif or simple #include is sufficient? It seems redundant to me to have include guard if we already have header guard, but I see such practice quite often, hence wondering if I'm missing something. Thanks!
Functionally, it does not make any difference.
A reason why old code may be using this is as an optimisation. It means the preprocessor can avoid reading Foo.h a second time, so it can generate the result a little bit faster.
Nowadays, even if the preprocessor does read the file a second time, the performance impact of that should be small enough not to bother with it. Some preprocessors may even detect header guards automatically, remember which header guard is associated with which macro, and avoid re-reading the header file all by themselves.
No, you should not. Include guards are for headers, which are included by other files. Source files, on the other hand, should never be included by other files.
Alternatively you may consider using the (non standard, but generally accepted) extension in your header files
#pragma once 
pragma is not portable
#pragma once is that it is applied on a per-file basis. if you have two copies of the file in your project (common to multiple distinct modules), and they both end up included (by being deeply nested) into one source file, you get a conflict.
once also has problems with mounts, symlinks, and other filesystem ninjitsu. My approach is use with caution and don't use with anything you plan to share.in Bar.cpp, do we still need to guard the include such as
#ifndef MYPROJ_FOO #include <Foo.h> #endifor simple
#includeis sufficient?
Simple #include is sufficient from a correctness point of view.
It seems redundant to me to have include guard if we already have header guard, but I see such practice quite often, hence wondering if I'm missing something.
The practice was recommended by John Lakos in his book Large Scale C++ Software Design.
However, a better alternative is to use the #pragma once directive, which is supported by most modern C++ compilers.
Foo.h:
#pragma once .... Then, you can just use
#include "Foo.h" in any .cpp file.
or simple
#includeis sufficient?
Yes, it is.
It seems redundant to me to have include guard if we already have header guard,
Yes it is totally redundant.
but I see such practice quite often
I don't see such practiced, unless the codes authors have no clue what they're doing.
#included by any other file.