Compatibilité des API

Version imprimable

24/10/2008, 11h44
KiKiTiTi

Compatibilité des API

Bonjour,

J'ai une question concernant les API disponibles. Sous gtk, on dispose d'une API en C. Alors que sous Qt, l'API est plutôt en C++. J'aimerais savoir si ces API sont interchangeables.
Autrement dit, un programme en C peut-il accéder facilement à une API écrit en C++ et un programme en C++ peut-il accéder sans problème à une API écrit en C ou des adaptations seraient nécessaires ?

Merci à l'avance de vos réponses et cordialement.
24/10/2008, 12h01
gerald3d

A priori aucun problème.
24/10/2008, 13h14
Médinoc

Un programme en C ne peut pas accéder directement à une API C++.
Par contre, une bibliothèque programmée en C++ peut avoir une API C, une API C++, ou les deux. Généralement, quand une bibliothèque expose les deux APIs, l'une est un wrapper sur l'autre.
25/10/2008, 01h37
KiKiTiTi

Accès de C à une API C++

Bonsoir,

Je suis justement tombé sur ce problème. Un programme écrit en C doit accéder à une bibliothèque dont l'API est apparemment proposée uniquement en C++. J'aimerais savoir s'il y a un moyen simple pour que cette dernière en C++ soit accesible par un programme en C.

Merci à l'avance et cordialement
25/10/2008, 15h32
Médinoc

Le seul moyen "simple" que je connais, c'est d'écrire un wrapper: Une bibliothèque en C++ avec une API C.

Et tu ne pourras pas utiliser les classes RRIF avec ça, seulement les classes qu'on instancie sur le tas.

Exemple en cours d'écriture...

Exemple de classe :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
//UneClasse.hpp
#ifndef H_UNECLASSE_20081025_1437
#define H_UNECLASSE_20081025_1437
 
/*
Ceci est une classe faite pour être utilisée sur le tas.
Elle possède une sémantique d'entité, et par conséquent,
n'est ni copiable, ni assignable, ni swappable.
*/
class UneClasse
{
public:
	//Constructeurs et destructeur
	UneClasse(void);
	explicit UneClasse(int i);
	~UneClasse(void);
private:
	//Copie et affectation interdites
	UneClasse(UneClasse const &);
	UneClasse& operator=(UneClasse const &);
 
public:
	//Accesseurs bidon
	int GetI(void) const;
	void SetI(int i);
 
private:
	//Variables membres
	int m_i;
};
 
#endif// ! H_UNECLASSE_20081025_1437

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
//UneClasse.cpp
#include "UneClasse.hpp"
 
//Constructeurs et destructeur
UneClasse::UneClasse(void)
 : m_i(0)
{ }
 
UneClasse::UneClasse(int i)
 : m_i(i)
{ }
 
UneClasse::~UneClasse(void)
{
}
 
//Accesseurs
int UneClasse::GetI(void) const
{
	return m_i;
}
 
void UneClasse::SetI(int i)
{
	m_i = i;
}

Et le wrapper C++ extern "C" :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
/*UneClasseC.h : Ce header doit être compilable en C comme en C++*/
#ifndef H_UNECLASSEC_20081025_1444
#define H_UNECLASSEC_20081025_1444
 
#ifdef __cplusplus
class UneClasse;
#else
struct UneClasse;
typedef struct UneClasse UneClasse;
#endif
 
#ifndef EXTERN_C
#ifdef __cplusplus
#define EXTERN_C extern "C"
#else
#define EXTERN_C extern
#endif
#endif
 
/*Constructeurs et destructeur*/
EXTERN_C UneClasse * UneClasse_new(void);
EXTERN_C UneClasse * UneClasse_new_int(int i);
EXTERN_C void UneClasse_delete(UneClasse *pThis);
 
/*Accesseurs*/
EXTERN_C int UneClasse_GetI(UneClasse const *pcThis);
EXTERN_C void UneClasse_SetI(UneClasse *pThis, int i);
 
#endif/* ! H_UNECLASSEC_20081025_1444*/

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
//UneClasseC.cpp
#include "UneClasseC.h"
#include "UneClasse.hpp"
 
//Constructeurs et destructeur
EXTERN_C UneClasse * UneClasse_new(void)
{
	return new UneClasse;
}
EXTERN_C UneClasse * UneClasse_new_int(int i)
{
	return new UneClasse(i);
}
EXTERN_C void UneClasse_delete(UneClasse *pThis)
{
	delete pThis;
}
 
//Accesseurs
EXTERN_C int UneClasse_GetI(UneClasse const *pcThis)
{
	return pcThis->GetI();
}
EXTERN_C void UneClasse_SetI(UneClasse *pThis, int i)
{
	pThis->SetI(i);
}