Utiliser du C dans du C++

Version imprimable

27/12/2006, 10h28
Freektrax

Utiliser du C dans du C++

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++....
27/12/2006, 10h45
Alp
Code:

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.
27/12/2006, 11h03
Freektrax

Merci de pour ton aide :-)

Citation:

Envoyé par Alp

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:

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:

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:

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:

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:

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:

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:

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:

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

30/12/2006, 13h25
Médinoc

(Faut croire que j'ai du temps à perdre, ce matin)
30/12/2006, 13h38
Luc Hermitte

Ouaip en effet. :)
C'était pas dans la FAQ tout ça ?
30/12/2006, 14h48
Médinoc

Si tu parles de cette entrée, elle ne brille pas par sa précision et ne mentionne qu'un seul sens...
Quant à celle-ci, elle ne dit pas beaucoup non plus...
11/01/2007, 14h52
petdelascar

Est on obligé de déffinir les fonctions C++ à l'aide d'un extern "C" ?
Ne suffit il pas de les deffinir normalement?
11/01/2007, 18h41
Médinoc

Non.
Les fonctions C++ qui ne sont pas définies en extern "C" auront un nom manglé à la C++ et ne seront pas visibles depuis le C.
03/02/2011, 12h27
ikuzar

Pourquoi dans le programme de test c++ on inclut FonctionsCpp.h
ce qu'il nous faut c'est FonctionsC.h non ?
03/02/2011, 15h02
Emmanuel Deloget

Citation:

Envoyé par ikuzar

Pourquoi dans le programme de test c++ on inclut FonctionsCpp.h
ce qu'il nous faut c'est FonctionsC.h non ?

Pour avoir accès aux fonctions qui sont purement C++ (notamment la dernière, fonction11).

D'acc.
Pour simplifier j'ai garder que les 3 premières fonctions. Ce que je dois faire dans un premier temps c'est d'utiliser des fonctions dans un code écrit en C++.

J'ai d'abord créer le fichier objet correspondant au FonctionsC.c :

Code:

gcc -c FonctionsC.c

Puis j'ai compilé le tout ... :
Code:

1 2 3 4 5 6 moi@moi-G73Jh:~/C_CPP$ g++ -Wall -o main main.cpp /tmp/ccnAp3YM.o: In function `main': main.cpp:(.text+0xf): undefined reference to `fonction1' main.cpp:(.text+0x41): undefined reference to `fonction2' main.cpp:(.text+0x6e): undefined reference to `fonction3' collect2: ld returned 1 exit status
Apparemment il trouve pas la librairie C ( FonctionC.o) que j'ai crée ...

03/02/2011, 15h56
Emmanuel Deloget
Il ne va pas la trouver tout seul, non :) Il faut rajouter le fichier à la liste des objets avec lequel le programme doit être lié.
Code:

1 2 g++ -o main main.cpp FonctionC.o
04/02/2011, 11h32
ikuzar

D'acc. ca marche, merci.
Sinon j'aimerais pourquoi ceci ne marche pas :

Code:

g++ -Wall -o main main.cpp -L.

En gros quand est ce que je dois mettre un -L ... pour indiquer au compilateur ou chercher la (les) librairie(s) ?
04/02/2011, 17h52
Médinoc

-L. ça rajoute un chemin de recherche des fichiers .a, mais je ne pense pas que ça marche pour les .o.
04/02/2011, 20h35
gl

Citation:

Envoyé par ikuzar

D'acc. ca marche, merci.
Sinon j'aimerais pourquoi ceci ne marche pas :

Code:

g++ -Wall -o main main.cpp -L.

Comme l'indique Médinoc, -L permet de rajouter un chemin où aller chercher les bibliothèques.

Ça ne rajoute pas de fichier ou de bibliothèque.
13/02/2011, 23h34
ikuzar
J'aimerais comprendre un peu comment fonctionne ces macros :
Code:

1 2 3 4 5 6 7 8 #ifndef EXTERN_C #ifdef __cplusplus #define EXTERN_C extern "C" #else #define EXTERN_C #endif #endif
1) Dans quel fichier écrit - on #define __cplusplus ? dans le_fichier.cpp qui inclut le_fichier.h contenant les macros ci-dessus ?
2) le #else #define EXTERN_C sert à quoi ?

Merci d'avance pour votre aide.
14/02/2011, 10h53
screetch

1) c'est définit automatiquement par le compilateur si celui-ci compile du C++
2) pour remplacer EXTERN_C par une chaine vide, sinon le préprocesseur laissera EXTERN_C dans le code final et le compilateur ne connaitra pas ce EXTERN_C