Discussion :

[Freektrax]

Bonjours a tous,

je souhaiterai interger du code C dans une application C++ et je ne sais pas du tout comment faire alors je vous demande conseil merci a tous :-)

ps: J'utilise le C++ pour crée une interface visuel puis j'ai un programme fais en C qui lui install des imprimantes. Je doit utilisé mon interface pour que les users donne les donées de l'imprimante puis après c'est le petit soft en C qui fais le reste.

je sais pas si vous avez besoin de plus d'info pour me conseiller ou pour m'aider alors si jamais dite le moi.

Merci

a si jamais je suis encore noob en C++....

[Alp]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
extern "C" 
{
// code C
}

?

Même en principe ton code C est compatible C++. Le C constitue un sous-ensemble du C++, en gros. Donc en principe ton code devrait marcher, pour peu que les bonnes librairies soient installées.

[Freektrax]

Merci de pour ton aide :-)

[Médinoc]

Même en principe ton code C est compatible C++. Le C constitue un sous-ensemble du C++, en gros. Donc en principe ton code devrait marcher, pour peu que les bonnes librairies soient installées.

Pas exactement.

• Le code C et le code C++ doivent être dans deux fichier source séparés.
• Les définitions des fonctions C n'ont pas à être modifiées.
• Les déclarations des fonctions C (dans un header, donc) que l'on veut rendre accessibles depuis le C++ doivent être précédées de extern "C" (ou entourées de extern "C" {}) uniquement quand on compile en C++, pour indiquer au compilateur C++ que ce sont des fonctions C (sinon, le linker ne les trouvera pas).
• Les définitions des fonctions C++ que l'on veut rendre accessibles depuis le C doivent être précédées de extern "C" ou entourées de extern "C" {}.
• Les déclarations des fonctions C++ (dans un header, donc) que l'on veut rendre accessibles depuis le C doivent être précédées de extern "C" (ou entourées de extern "C" {}) uniquement quand on compile en C++, pour indiquer au compilateur C++ que les fonctions sont en extern "C" (sinon, le linker ne les trouvera pas non plus).

Exemple :
Les fonctions C :

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/*
FonctionsC.h
*/
 
/* Définition de la macro EXTERN_C pour C ou C++ */
#ifndef EXTERN_C
#ifdef __cplusplus
#define EXTERN_C extern "C"
#else
#define EXTERN_C
#endif
#endif
 
/* Ces fonctions sont accessibles en C++, 
   car le linker saura que ce sont des fonctions C. */
EXTERN_C int fonction1(int);
EXTERN_C int fonction2(char const *);
EXTERN_C void * fonction3(void);
 
/* Ces fonctions ne seront pas accessibles en C++, 
   car le linker croira que se sont des fonctions C++. */
int fonction4(int, int);
int fonction5(void);

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

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
/*
FonctionsC.c
*/
#include <stdlib.h>
#include <stdio.h>
#include "FonctionsC.h"
 
int fonction1(int a)
{
return 2*a;
}
int fonction2(char const *s)
{
return puts(s);
}
void * fonction3(void)
{
return NULL;
}
 
int fonction4(int a, int b)
{
return a*b;
}
int fonction5(void)
{
return 42;
}

Les fonctions C++ :

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

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
33
34
/*
FonctionsCpp.h
*/
 
/* Définition de la macro EXTERN_C pour C ou C++ */
#ifndef EXTERN_C
#ifdef __cplusplus
#define EXTERN_C extern "C"
#else
#define EXTERN_C
#endif
#endif
 
/* Ces fonctions sont accessibles en C et en C++, car:
 Le linker C croira que ce sont des fonctions C et il aura presque raison,
 Le linker C++ saura que leurs définitions sont en extern "C" */
EXTERN_C int fonction6(int);
EXTERN_C int fonction7(char const *);
EXTERN_C void * fonction8a(void);
EXTERN_C void fonction8b(void *);
 
/* Ces fonctions ne seront pas accessibles en C, 
   car le linker croira, à tort, que ce sont des fonctions C. */
int fonction9(int, int);
int fonction10(void);
 
/* Ces fonctions ne doivent être accessibles qu'en C++,
   car elles seraient inutilisables en C et leur déclaration seule 
   causerait une erreur de compilation */
#ifdef __cplusplus
#include <string>
 
std::string::size_type fonction11(std::string const &);
#endif

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
#include "FonctionsCpp.h"
#include <iostream>
using namespace std;
 
/* Ces fonctions sont accessibles en C et en C++, car:
 Le linker C croira que ce sont des fonctions C et il aura presque raison,
 Le linker C++ saura que leurs définitions sont en extern "C" */
extern "C" int fonction6(int a)
{
return 3*a;
}
 
extern "C" int fonction7(char const *sz)
{
cout << sz << endl;
return 33;
}
 
extern "C" void * fonction8a(void)
{
return new string("Les fonctions C ne peuvent rien faire de cet objet, mais peuvent avoir son adresse");
}
 
extern "C" void fonction8b(void *pv)
{
string *ps = static_cast< string * >(pv);
delete ps;
}
 
/* Ces fonctions ne seront pas accessibles en C, 
   car le linker croira, à tort, que ce sont des fonctions C. */
int fonction9(int a, int b)
{
	return (b==0 ? -1 : a/b);
}
 
int fonction10(void)
{
	return 0x12345678;
}
 
/* Ces fonctions ne doivent être accessibles qu'en C++,
   car elles seraient inutilisables en C et leur déclaration seule 
   causerait une erreur de compilation */
std::string::size_type fonction11(std::string const &s)
{
	return s.length();
}

Le programme de test en C :

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include "FonctionsC.h"
#include "FonctionsCpp.h"
#include <stdio.h>
#include <stdlib.h>
 
int main(void)
{
	printf("1: %d\n", fonction1(2));
	printf("2: %d\n", fonction2("coucou"));
	printf("3: %p\n", fonction3());
	printf("4: %d\n", fonction4(3, 4));
	printf("5: %d\n", fonction5());
 
	printf("6: %d\n", fonction6(2));
	printf("7: %d\n", fonction7("bonjour"));
	{
		void *p = fonction8a();
		printf("8: %p\n", p);
		fonction8b(p);
	}
	return EXIT_SUCCESS;
}

Sa sortie (chez moi, VS2005, Windows XP) :

Code X :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
1: 4
coucou
2: 0
3: 00000000
4: 12
5: 42
6: 6
bonjour
7: 33
8: 00356A68

Le programme de test en C++ :

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

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
#include "FonctionsC.h"
#include "FonctionsCpp.h"
#include <iostream>
#include <string>
using namespace std;
 
int main(void)
{
	cout << "1: " << fonction1(2) << endl;
	cout << "2: " << fonction2("coucou") << endl;
	cout << "3: " << fonction3() << endl;
 
	cout << "6: " << fonction6(2) << endl;
	cout << "7: " << fonction7("bonjour") << endl;
	{
		void *p = fonction8a();
		cout <<"8: " << p << endl;
		string const *pcs = static_cast< string const * >(p);
		cout << "11: " << fonction11(*pcs) << endl;
		fonction8b(p);
	}
	cout << "9: " << fonction9(15, 3) << endl;
	cout << "10: " << fonction10() << endl;
 
	return EXIT_SUCCESS;
}

Et sa sortie chez moi :

Code X :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
1: 4
coucou
2: 0
3: 00000000
6: 6
bonjour
7: 33
8: 00355AB0
11: 82
9: 5
10: 305419896

[Médinoc]

(Faut croire que j'ai du temps à perdre, ce matin)

[Luc Hermitte]

Ouaip en effet.
C'était pas dans la FAQ tout ça ?