Gibt es eine Inline-Methode zum Mischen von C- und C++ - Prototypen?

Question

Ich möchte eine Inline-Art der Angabe, welche Prototypen in C++ enthalten sein sollen. Zum Beispiel:

 
     void ArrayList_insert(ArrayList *arrlst, void *data, int i); 
IS_CPP void ArrayList_insert(ArrayList *arrlst, char *data, int i); 
IS_CPP void ArrayList_insert(ArrayList *arrlst, Buffer *data, int i); 

zur Zeit mache ich:

 
#ifdef __cplusplus 
extern "C" { 
#endif 

....C HEADERS.. 

#ifdef __cplusplus 
} 

....C++ HEADERS... 

#endif 

aber es ist sehr unbequem, weil Überlastungen der gleichen Funktion in verschiedenen Orten sind. Ich könnte nur zwei verschiedene Header-Dateien haben, aber das ist auch ein Schmerz. Daher suche ich nach einer Inline-Lösung, wie ich sie oben vorgeschlagen habe. Kennt jemand eine Möglichkeit, das zu tun?

Answer 1

Es ist einfacher als Sie denken.

#ifdef __cplusplus 
#define IS_C(x) extern "C" x ; 
#define IS_CPP(x) x ; 
#else 
#define IS_C(x) x ; 
#define IS_CPP(x) 
#endif 

Mit dieser Art von Kopf:

IS_C (void ArrayList_insert(ArrayList *arrlst, void *data, int i)) 
IS_CPP (void ArrayList_insert(ArrayList *arrlst, char *data, int i)) 
IS_CPP (void ArrayList_insert(ArrayList *arrlst, Buffer *data, int i)) 

Answer 2

Sicher, können Sie es durch die Verwendung eines funktionsähnliche Makro fast wie Ihr Beispiel tun:

#ifdef __cplusplus 
#define IS_CPP(x) x 
#else 
#define IS_CPP(x) 
#endif 

     void ArrayList_insert(ArrayList *arrlst, void *data, int i); 
IS_CPP(void ArrayList_insert(ArrayList *arrlst, char *data, int i)); 
IS_CPP(void ArrayList_insert(ArrayList *arrlst, Buffer *data, int i)); 

Nun, wenn Sie den Header als C++ kompilieren, Sie alle drei bekommen, aber wenn Sie als kompilieren C, du bekommst nur den einen. Wenn Sie eine einzelne Bibliothek zwischen den beiden teilen möchten, müssen Sie der C-Funktion beim Kompilieren für C++ einige extern "C" Qualifier hinzufügen. @ MarkLakatas Antwort zeigt einen möglichen Weg.

Answer 3

Sie können offensichtlich den Präprozessor missbrauchen zusammen zu hacken, was Sie fragen, aber warum es tun? Persönlich würde ich lieber mylst.insert(foop, 1); anstelle von ArrayList_insert(mylst, foop, 1); eingeben, wenn ich C++ benutze. Mit anderen Worten, ich sehe wenig Nutzen darin, den C-Stil zum Aufrufen der überladenen Funktionen zu verwenden, aber das Mischen der Stile der Funktionsaufrufe, die Sie als Codeautor erstellt haben, ist auch nicht gerade hübsch.

Ich würde eine ArrayList-Klasse, die die gleichen Mitglieder wie in der C-Struktur hat und wann immer Sie Ihre Klasse mit den C-Funktionen verbinden müssen, erstellen Sie eine flache Kopie, wenn möglich und übergeben Sie diese an die C-Funktion dann Kopieren Sie die Informationen aus dieser Struktur zurück in Ihre Klasse.

Eine Alternative wäre, die Struktur in eine C++ - Klasse zu verpacken und diese für die C-Schnittstellenfunktionen zu verwenden.

Andernfalls könnten Sie versuchen, die Klasse die C-Struktur erben, vorausgesetzt, das Struktur-Tag hat nicht den Namen ArrayList und der Typdef für die Struktur ist nicht sichtbar von der C++ - Schnittstelle. Dann können Sie den This-Zeiger hoffentlich direkt aus der Member-Funktion übergeben, als wäre es die tatsächliche C-Struktur. Ich bin mir nicht sicher, ob diese Methode in allen Fällen portabel ist, also würde ich die erste Idee nach Möglichkeit implementieren, auch wenn es Daten erfordert, die Daten hin und her zu kopieren.

Alle Ideen vermeiden Code-Duplikation, und die C++ - Schnittstelle sieht eher wie C++ - Code statt der schlechten Mischung von C-Funktionen und C++ - Funktion Überladung. Zusätzlich werden die Schnittstellen etwas getrennt gehalten.Keine zusätzlichen Header-Dateien sind erforderlich, entweder als die C-Funktionen können in einem extern „C“ Block wie üblich gewickelt werden:

#ifdef __cplusplus 
extern "C" { 
#endif 

struct array_list_tag { 
    ... 
}; 

/* C functions here */ 

#ifdef __cplusplus 
} /* extern "C" */ 

class ArrayList ... 
#else /* !__cplusplus */ 
typedef struct array_list_tag ArrayList; 
#endif 

Answer 4

Die übliche Vorgehensweise ist, schreibt sie einfach in dem naheliegendste Weg:

void ArrayList_insert(ArrayList *arrlst, void *data, int i); 
#ifdef __cplusplus 
void ArrayList_insert(ArrayList *arrlst, char *data, int i); 
void ArrayList_insert(ArrayList *arrlst, Buffer *data, int i); 
#endif /* __cplusplus */ 

Wie @ chacham15 weist darauf hin, Sie brauchen, in einem projektweiten Header,

#ifdef __cplusplus 
#define EXTERN_C extern "C" 
#endif /* __cplusplus */ 

und Sie müssen die C-aufrufbare Funktion mit EXTERN_C dekorieren.

Answer 5

Wenn Sie wirklich den Textbaustein loswerden wollen und Sie bereit sind, den Präprozessor zu benutzen, dann machen Sie einfach weiter und schreiben Sie das Muster auf. Das allgemeine Muster haben Sie sieht aus wie

extern "C" { 
    void C_accessible_declaration(); // this is all C sees 
} 

void Cxx_accessible_declaration_1(int); 
void Cxx_accessible_declaration_1(long); 

So könnte man einen Makro machen,

#ifdef __cplusplus 
# define C_PORTABLE_FUNCTION_SET(C_DECLS, CXX_DECLS) \ 
     extern "C" { C_DECLS } \ 
     CXX_DECLS 
#else 
# define C_PORTABLE_FUNCTION_SET(C_DECLS, CXX_DECLS) \ 
     C_DECLS 
#endif 

Dies funktioniert, weil eine normale Funktionsdeklaration kein Komma nicht eingeschlossen durch Klammern enthalten. Wenn Sie möchten, dass es mit Vorlagen arbeitet (mit kommagetrennten Vorlagenparametern), können Sie Variadic-Makros, die in C99, C++ 11 und verschiedenen Compilern vor diesen Standards unterstützt werden, als Erweiterung verwenden.

#ifdef __cplusplus 
# define C_PORTABLE_FUNCTION_SET(C_DECLS, ...) \ 
     extern "C" { C_DECLS } \ 
     __VA_ARGS__ 
#else 
# define C_PORTABLE_FUNCTION_SET(C_DECLS, ...) \ 
     C_DECLS 
#endif 

Jetzt funktioniert dies so lange, wie die C-Erklärungen, keine nackten Kommas enthalten, das heißt, Sie sollten nicht mehr Objekte in der einer Erklärung erklären. Ich habe es C_PORTABLE_FUNCTION_SET genannt, um zu betonen, dass es hauptsächlich sicher für die Verwendung mit Funktionsdeklarationen ist, aber beachten Sie, dass Sie C-zugängliche Objekte auch innerhalb von extern C deklarieren müssen. Gemeinsame struct Definitionen sollten überhaupt nicht geschützt werden; Sie sind durch das C++ - POD-Konzept geschützt und enthalten keine Sprachverbindungen.

Verbrauch:

#ifdef __cplusplus 
template< typename T, typename U > 
class Buffer { // still use #ifdef for the general case 
    ... 
}; 
#endif 

C_PORTABLE_FUNCTION_SET (
     void ArrayList_insert(ArrayList *arrlst, void *data, int i); 
, /* C++ */ 
     void ArrayList_insert(ArrayList *arrlst, char *data, int i); 

     template< typename T, typename U > 
     void ArrayList_insert(ArrayList *arrlst, Buffer< T, U > &data, int i); 
) 

Ich glaube nicht, dass ich das selbst tun würde, aber es scheint sicher genug idiomatische zu werden.