2ème cpp pour les focntions

Version imprimable

Voir 40 message(s) de cette discussion en une page

08/05/2007, 16h22
superc7

2ème cpp pour les focntions
Bonjours,
J'ai un programme en c++ qui est volumineux et j'aimerai crée un 2ème cpp sans fiche pour y mettre quelque fonction:
Mais depuis ce 2ème cpp j'aimera appeler des boutons ou memo de la fiche du 1er cpp.
Es que c'est possible?

2ème cpp
Code:

1 2 3 4 5 6 7 8 void __fastcall DevicessHID() { Mem1->Clear(); // effacer le memo ... }
et le mem1 = memo du 1er cpp

merci
08/05/2007, 19h26
Bob.Killer

je comprend pas trop mais la synthaxe "extern" pourrait peut être t'aider ?
08/05/2007, 19h49
koala01
Salut,

Si j'ai bien compris, tu as un fichier d'entete du genre de
Code:

1 2 3 4 5 6 #ifndef FICHIER_H #define FICHIER_H void fonction1(); void fonction2(); ... #endif
et tu voudrais pouvoir implémenter les focntions dans deux fichier différents dans le genre de
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 dans fiche1.cpp #include "fichier.h" void fonction1() { //blabla fonction2(); } dans fiche2.cpp #include "fichier.h" void fonction2() { //blabla fonction1(); }
:question:

Si c'est le cas, il n'y a aucun problème...

La seule chose à laquelle tu doive faire attention, c'est au fait que chaque fichier d'implémentation dispose bien de la déclaration de chaque fonction qui est appelée ;)

C'est d'autant plus facile si toutes les fonctions sont déclarées dans le meme fichier d'entete ;)
09/05/2007, 08h43
superc7
enfaite ce serai plutot comme sa:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 cpp1: quand on clique sur le bouton { fonction1(); } cpp2: { fonction1 { ecrire "Bonjours" sur le memo } }
mais le memo ce toruve sur la fiche de cpp1 comme le bouton!
09/05/2007, 09h14
ac/dc

salut t'aurais dû poster ton message dans la partie C++Builder ....
Dans ton Unit2.cpp tu peut faire appelle à ta méthode via Form1->fonction1(); si celle-ci est déclarée en public dans TForm1
09/05/2007, 09h21
superc7

oki merci pour avoir déplacer mon post!!

Mais mon problème est pas d'apeler la fonction, sa j'y arrive mais c'est d'écire sur le memo! Et d'utiliser des objets comme le memo ou les boutons qui sont sur la fiche du cpp1 et donc déclarer dans le cpp1!

J'ai inclu le header du cpp1 dans le cpp2 pourtant!
merci
09/05/2007, 10h03
josse95

Oui, tu peux tout à fait.

Il suffit d'accéder aux membres en préfixant par le nom de la forme:

Ex:

Code:

Form1->Mem1->Clear();
09/05/2007, 10h08
superc7

Merci,
mais c'est bien ce que je pensai mais sa ne fonction pas :-(

J'ai pas changer le nom de ma forme, elle appel toujours form1,
et quand je mais comme sa :

Code:

Form1->Mem1->Clear();

sa me dit qu'il y a une erreur:

[C++ Erreur] FonctionG.cpp(17): E2451 Symbole 'Form1' non défini

Je dois définir a quelque part quelque chose?
09/05/2007, 10h16
say

Citation:

Envoyé par superc7

Merci,
mais c'est bien ce que je pensai mais sa ne fonction pas :-(

J'ai pas changer le nom de ma forme, elle appel toujours form1,
et quand je mais comme sa :

Code:

Form1->Mem1->Clear();

sa me dit qu'il y a une erreur:

[C++ Erreur] FonctionG.cpp(17): E2451 Symbole 'Form1' non défini

Je dois définir a quelque part quelque chose?

tu as inclus form1.hpp dans form2.cpp?
09/05/2007, 10h50
superc7

Form1.hpp je ne sais pas ce que sais, j'ai inclus le header de ma form1 = Nom.h
09/05/2007, 10h50
josse95

Plutôt Unit1.h:

Code:

#include "Unit1.h"

(à adapter en fonction du nommage de ton fichier source)
09/05/2007, 10h52
josse95

Citation:

Form1.hpp je ne sais pas ce que sais, j'ai inclus le header de ma form1 = Nom.h

Cela aurait dû fonctionner.

Le mieux à faire, poste ton "Nom.h" ainsi que le .cpp qui ne fonctionne pas.

voila le header de la la forme principale:

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
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
//---------------------------------------------------------------------------
 
#ifndef GUID_mainH
#define GUID_mainH
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <ComObj.hpp>
#include "hid.hpp"
 
#include <setupapi.h>
#include <Buttons.hpp>
#include <ComCtrls.hpp>
#include <ExtCtrls.hpp>
#include "hid.hpp"
#include "winbase.h"
#include "dbt.h"
#include "LoadUSB.cpp"
#include "UsagesInfo.cpp"
#include "FonctionG.cpp"
 
 
//---------------------------------------------------------------------------
class TForm1 : public TForm
{
__published:	// Composants gérés par l'EDI
        TButton *BtnGUIDE;
        TButton *BtnHID;
        TEdit *Edt1;
        TMemo *Mem1;
        TBitBtn *BitBtn1;
        TTimer *Timer1;
        TButton *BtnT;
        TEdit *EdtUse;
        TLabel *Label1;
        TLabel *Label2;
        TEdit *EdtUseP;
        TLabel *Label3;
        TEdit *EdtIRBL;
        TLabel *Label4;
        TEdit *EdtORBL;
        TLabel *Label5;
        TLabel *Label6;
        TEdit *EdtNLCN;
        TEdit *EdtNIVC;
        TLabel *Label7;
        TEdit *EdtNIBC;
        TLabel *Label8;
        TEdit *EdtFRBL;
        TLabel *Label9;
        TLabel *Label10;
        TEdit *EdtNOVC;
        TEdit *EdtNFVC;
        TLabel *Label11;
        TEdit *EdtNFBC;
        TLabel *Label12;
        TEdit *EdtNOBC;
        TButton *BtnCap;
        TEdit *EdtUse2;
        TEdit *EdtUseP2;
        TEdit *EdtIRBL2;
        TEdit *EdtFRBL2;
        TEdit *EdtNLCN2;
        TEdit *EdtORBL2;
        TEdit *EdtNIBC2;
        TEdit *EdtNIVC2;
        TEdit *EdtNOVC2;
        TEdit *EdtNOBC2;
        TEdit *EdtNFBC2;
        TEdit *EdtNFVC2;
        TLabel *LabelIRBL;
        TLabel *LblORBL;
        TStatusBar *StatusBar;
        void __fastcall BtnGUIDEClick(TObject *Sender);
        void __fastcall FormClose(TObject *Sender, TCloseAction &Action);
        void __fastcall BtnHIDClick(TObject *Sender);
        void __fastcall BtnTClick(TObject *Sender);
        void __fastcall Timer1Timer(TObject *Sender);
        void __fastcall BtnCapClick(TObject *Sender);
        void __fastcall FormActivate(TObject *Sender);
        void __fastcall FormCreate(TObject *Sender);
 
 
private:	// Déclarations utilisateur
      void __fastcall UsbMsg(TMessage &Message);
 
public:  // Déclarations utilisateur
          // Variable pour le GUID
          GUID guid;
          HDEVINFO hDevInfo;
          HDEVINFO hDevInfo;
          SP_DEVINFO_DATA DeviceInfoData;
 
       __fastcall TForm1(TComponent* Owner);
 
 
};
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif

la form pricnipale

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
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
//---------------------------------------------------------------------------
 
#include <vcl.h>
#pragma hdrstop
 
#include "GUID_main.h"
#include "hid.hpp"
#include "winbase.h"
#include "dbt.h"
#include "LoadUSB.cpp"
#include "UsagesInfo.cpp"
#include "FonctionG.cpp"
 
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
 
// Variable pour le HID
HANDLE HidDeviceObject;
 
 
DWORD i;
 
// Variable pour le Device
SP_DEVICE_INTERFACE_DATA     devInfoData;
LONG   Result;
int    MemberIndex = 0;
bool   MyDeviceDetected = FALSE;
bool   LastDevice = FALSE;
ULONG  Length;
PSP_DEVICE_INTERFACE_DETAIL_DATA	detailData;
ULONG	 Required;
HANDLE	 DeviceHandle;
HIDD_ATTRIBUTES  Attributes;
 
 
 
// Variable pour le PID, PIV et N.Serie
int BufferLength;
wchar_t * Buffer;
bool ManufacturerName, ProductName, SerieNum;
wchar_t ManufacturerBuffer[256], ProductBuffer[256], SerieBuffer[256];
 
// Variable pour UsagesInfo.cpp
AnsiString UsagePageTex;
AnsiString UsageTex;
 
 
// Création de Panel
TPanel *Panel[10];
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
// Charger les fonctions de la dll
  if (LoadHidDll())
  {
       ShowMessage("Problème de chargement de librairie");
       Application->Terminate();
  }
}
//---------------------------------------------------------------------------
void __fastcall TForm1::BtnGUIDEClick(TObject *Sender)
{
   Edt1->Text = GUIDToString(guid);  // Afficher le GUID
   BtnHID->Enabled = true;           // Activer le bouton Liste des devices HID
}
//---------------------------------------------------------------------------
 
void __fastcall TForm1::FormClose(TObject *Sender, TCloseAction &Action)
{
   FreeLibrary(hHID);    // libéré la library
}
//---------------------------------------------------------------------------
 
void __fastcall TForm1::BtnHIDClick(TObject *Sender)
{
   DevicessHID();   //Appele onction pour la récupération des Devicess
}
//---------------------------------------------------------------------------
void __fastcall TForm1::BtnTClick(TObject *Sender)
{
   BtnT->Tag = !BtnT->Tag;
// Active ou désactive le timer pour la récupération des données
   if (BtnT->Tag)
   {
         BtnT->Caption = "STOP";
         Timer1->Enabled = true;
   }
   else
   {
         BtnT->Caption = "Donnée";
         Timer1->Enabled = false;
   }
}
//---------------------------------------------------------------------------
void __fastcall TForm1::BtnCapClick(TObject *Sender)
{
   Capabilites();  // Appele la fonction pour récupéré les capabilities
}
//---------------------------------------------------------------------------
void __fastcall TForm1::UsbMsg(TMessage &Message)
{
// Variable
    HDEVNOTIFY *pMsgInfo;
    pMsgInfo = (HDEVNOTIFY *)Message.WParam;
 
   // Verifie que c'est le bon message
   if(Message.Msg == WM_DEVICECHANGE)
   {
       // Teste si c'est une conexion
       if((int)(pMsgInfo) == DBT_DEVICEARRIVAL)
         {
             Edt1->Text = GUIDToString(guid);  // Afficher le GUID
             BtnHID->Enabled = true;
             DevicessHID();
             Capabilites();
             StatusBar->Panels->Items[0]->Text= "USB connecté" ;
          }
          else
          {
           // Teste si c'est une déconexion
            if(((int)(pMsgInfo))==DBT_DEVICEREMOVECOMPLETE)
            {
               StatusBar->Panels->Items[0]->Text= "USB déconecté";
               BtnHID->Enabled = false;
               BtnT->Enabled = false;
               BtnCap->Enabled = false;
               BtnT->Caption = "Donnée";
               Timer1->Enabled = false;
               Timer1->Enabled = false;
               Mem1->Clear(); // effacer le memo
               EdtUseP->Text = ' '; EdtUseP2->Text = ' ';
               LabelIRBL->Visible = false;
               LblORBL->Visible = false;
              // détruire le panel
             }
          }
    }
   WndProc(Message);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormActivate(TObject *Sender)
{
     // Obtenir les information des dispositifs installé
   hDevInfo = SetupDiGetClassDevs(&guid, NULL, NULL, DIGCF_PRESENT | DIGCF_INTERFACEDEVICE);
 
  // Taille de la structur SetupDiEnumDeviceInterfaces
   devInfoData.cbSize = sizeof(devInfoData);
 
   // Obtenir le handle de la structur SP_DEVICE_INTERFACE_DATA du matériel installé
   Result = SetupDiEnumDeviceInterfaces(hDevInfo, 0, &guid, MemberIndex, &devInfoData);
 
   // Test si il y a un périférique USB conecté ou pas
   if (Result != 0)
   {
       StatusBar->Panels->Items[0]->Text= "USB connecté";
       BtnHID->Enabled = true;
   }
   else
   {
       StatusBar->Panels->Items[0]->Text= "USB déconecté" ;
       BtnHID->Enabled = false;
       BtnT->Enabled = false;
       BtnCap->Enabled = false;
   }
}
//---------------------------------------------------------------------------
 
void __fastcall TForm1::FormCreate(TObject *Sender)
{
  HidD_GetHidGuid(guid); // Fonction pour obtenir le GUID
 
  // notification du message de connexion ou déconexion USB
   ZeroMemory( &NotificationFilter, sizeof(NotificationFilter));
   NotificationFilter.dbcc_size = sizeof(DEV_BROADCAST_DEVICEINTERFACE);
   NotificationFilter.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
   NotificationFilter.dbcc_classguid = guid;
   hDevNotif = RegisterDeviceNotification(Handle, &NotificationFilter, DEVICE_NOTIFY_WINDOW_HANDLE);
   WindowProc=UsbMsg;
}
//---------------------------------------------------------------------------

Et la 2ème form: ou je dois metre mes fonction

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
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
#include "GUID_main.h"
#include "hid.hpp"
#include "winbase.h"
#include "dbt.h"
 
 
 
void __fastcall DevicessHID();
void __fastcall Capabilites();
 
//---------------------------------------------------------------
 
 void __fastcall DevicessHID()
{
 
Form1->Mem1->Clear(); // effacer le memo
 
// Obtenir les information des dispositifs installé
   hDevInfo = SetupDiGetClassDevs(&guid, NULL, NULL, DIGCF_PRESENT | DIGCF_INTERFACEDEVICE);
 
// Taille de la structur SetupDiEnumDeviceInterfaces
   devInfoData.cbSize = sizeof(devInfoData);
 
   // Obtenir le handle de la structur SP_DEVICE_INTERFACE_DATA du matériel installé
   Result = SetupDiEnumDeviceInterfaces(hDevInfo, 0, &guid, MemberIndex, &devInfoData);
 
   if (Result != 0)
   {
     // Active les bouton Capabilitées et donnée
      BtnT->Enabled = true;
      BtnCap->Enabled = true;
 
      // Recherche des information détail de hDevInfo
      Result = SetupDiGetDeviceInterfaceDetail(hDevInfo, &devInfoData, NULL, 0, &Length, NULL);
 
   	//Répartir la mémoire pour la structure hDevInfo
      detailData = (PSP_DEVICE_INTERFACE_DETAIL_DATA) malloc(Length);
 
   	  //Taile de la strucutre
      detailData->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);
 
	//Appeler la fonction SetupDiGetDeviceInterfaceDetail
      Result = SetupDiGetDeviceInterfaceDetail(hDevInfo, &devInfoData, detailData, Length, &Required, NULL);
 
      DeviceHandle = CreateFile(detailData->DevicePath,
      GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE,
      (LPSECURITY_ATTRIBUTES) NULL, OPEN_EXISTING, 0, NULL);
 
      // Fonction pour récupérer les Attributes
      HidD_GetAttributes((unsigned)DeviceHandle, Attributes);
      //Affichage des attributes (VID,PID et Version)
      Mem1->Lines->Add(("Vendor ID : ")+("0x"+IntToHex(Attributes.VendorID,4))+
                        (" Porduit ID : ")+("0x"+IntToHex(Attributes.ProductID,4))+
                        (" Version : ")+((int)Attributes.VersionNumber));
 
      // Récupération des strings fabricant, nom du produit ez numero de série
      ManufacturerName = HidD_GetManufacturerString((unsigned)DeviceHandle, ManufacturerBuffer, 256);
      ProductName      = HidD_GetProductString((unsigned)DeviceHandle, ProductBuffer, 256);
      SerieNum         = HidD_GetSerialNumberString((unsigned)DeviceHandle, SerieBuffer, 256);
 
     // Affichage du string fabricant
      for (int i = 0; i<256 ; i++)
      {
       SendMessage(Mem1->Handle,WM_CHAR,(char)ManufacturerBuffer[i],0);
     }
      SendMessage(Mem1->Handle,WM_CHAR,'\n',0);
 
      i=0;
       // Affichage du string nom du produit
      for (int i = 0; i<256 ; i++)
      {
         SendMessage(Mem1->Handle,WM_CHAR,(char)ProductBuffer[i],0);
      }
      SendMessage(Mem1->Handle,WM_CHAR,'\n',0);
 
       // Affichage du string dumero de série
      Mem1->Lines->Add(SerieBuffer[0]);
 
      free(detailData);  // libéré la mémoire detailData
   }
   else
   {
      ShowMessage("Pas de récupération des devices!");
      CloseHandle(DeviceHandle);
   }
}

pour l'instant il y en a que 1 mais après il y en aura plus!
merci

09/05/2007, 11h54
josse95
Ton erreur provient des inclusions de fichiers cpp dans ton header de la forme principale:
Code:

1 2 3 #include "LoadUSB.cpp" #include "UsagesInfo.cpp" #include "FonctionG.cpp"
Au moment où le compilateur inclue FonctionG.cpp, Form1 n'est pas encore définie.
09/05/2007, 12h36
superc7

Et y-a-t-il une solution?
09/05/2007, 12h57
say

bah, si ça devrait ;)
j'avais pas fait attention que tu n'avais qu'un cpp, j'ai jamais essayé cette méthode.

de mon côté, j'ai moi aussi une "classe" dans laquelle je regroupe un certain nombre de fonctions. j'ai positionné ces fonctions en static ce qui me permet de ne pas avoir à instancier d'objet. et j'inclue les .h et non les .cpp.

si ça peut t'aider..
09/05/2007, 13h29
josse95

Bien-sûr, la solution est de ne pas inclure tes fichiers .cpp dans ton .h !!!

Un .h doit contenir des déclarations, éventuellement des fonctions inline, mais pas de code (c'est techniquement possible mais pas du tout recommandé !).
09/05/2007, 13h36
superc7

oki je vais essayer de pas inclure les cpp dans le header sa al'air de fonction un peu mieu!!!
Merci

Voir 40 message(s) de cette discussion en une page