C++: How to include Paillier.h in a header file - c++

Question

I have a C++ class key_gen that has some data members of type paillier_ prvkey_t. The problem is that I cannot include paillier library (writen in c) in my header file say key_gen.h. But I can include it in my key_gen.cpp using
extern "C"{
#include<paillier.h>
}
I'm using cygwin to run my code, and I use command line as below:
g++ Key_Gen.cpp -L/cygdrive/c/cygwin/home/Win7/libpaillier -l:libpaillier.a -
-lgmpxx -lgmp
As soon as I include the paillier header into my header file cygwin alerts when I run the code.
The error contains many lines e.g:
In file included from Key_Gen.h:13:0,
from Key_Gen.cpp:2:
/usr/local/include/paillier.h:63:3: note: previous declaration as ‘typedef
struct paillier_pubkey_t paillier_pubky_t’} paillier_pubkey_t;
^
Can someone tell me how to resolve the problem?

Answer 1

When you tell a C or C++ compiler to process a file, foo.cpp, the first stage of compilation is pre-processing which expands macros, substitutes defines and expands pre-processor directives such as #include.
In the early days, the preprocessor was a separate program, and it generated the output on the fly: the C compiler itself didn't know about #include and all it saw was a single stream of code.
Today, the preprocessor is usually an integral part of the compiler (gcc, MSVC, etc) but the single-stream effect for each source file you specify on the command line remains the same, and you can still access the compiler to generate the output of pre-processing as a single intermediate file so that you can see what translations went on (-E option to gcc/g++). So if you write:
// Foo.h
int foo;
// Bar.cpp
#include "Foo.h"
int bar;
#include "Foo.h"
What the compiler sees is a single contiguous stream:
/* "Bar.cpp" from command line */
// Bar.cpp
/* "Foo.h" from Bar.cpp:2 */
int foo;
/* end "Foo.h" */
int bar;
/* "Foo.h" from Bar.cpp:4 */
int foo;
/* end "Foo.h" */
/* end "Bar.cpp" */
The compilation stage doesn't know about #include,
The pre-processor doesn't do de-duplication of #includes by default, so multiple includes produce duplication.
If you want to add paillier.h to your own .h file you will need to prevent this duplication. There are two common ways to do this.
pragma guard
At the start of the .h file use the pre-processor directive #pragma, understood by both the GNU C and C++ compilers:
#pragma once
Pro: The pre-processor detects duplication at the #include statement and so doesn't have to re-read the file.
Con: Most compilers use the include file's path to do this, so
#include "../include/foo.h"
#include "foo.h"
might both reference the same file but on some compilers will still produce duplication.
#ifndef guard
At the start of the .h file check for the definition of a unique pre-processor symbol and, if not defined, define it
#ifndef PAILLIER_H
#define PAILLIER_H
and at the very end of the file
#endif // PAILLIER_H (comment is optional)
Pro: De-duplicates regardless of path.
Con: Can cause problems if your guard name isn't unique enough (I worked on a project where someone used 'HEADER' in more than one header file)
Con: The pre-processor still has to read the entire header file to find the #endif.
In summary
You may also want to add the following to make your file work when included from both C and C++
#ifdef __cplusplus
extern "C" {
#endif
// all your symbols etc here
#ifdef __cplusplus
}; // extern "C"
#endif
This is going to make your header file look something like this:
#ifndef PAILLIER_H
#define PAILLIER_H
#ifdef __cplusplus
extern "C" {
#endif
// original code here
...
// end original code
#ifdef __cplusplus
}; // extern "C"
#endif
#endif // PAILLIER_H
or
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
// original code here
...
// end original code
#ifdef __cplusplus
}; // extern "C"
#endif
--- Edit ---
There's no reason you can't use both
#pragma once
#ifndef MYPROJECT_SOMETHING_H
...
#endif
This way if #pragma fails you for path reasons, you're still covered.