Déclaration Variable Global

Version imprimable

25/10/2007, 21h49
b_reda31

Déclaration Variable Global
Bonjour à tous.
Je suis entrain de faire la transition entre le delphi et le C++ Builder,et j'ai un petit problème concernant la portée des variables:
J'ai une application contenant deux fiches (Form1 et Form2 associées aux Unit1.h et Units2.h)
Je voudrai déclarer dans Unit1 une variable qui soit accéssible par UNIT2.h
je viens de voir ce post
j'ai donc fais comme suit:
dans Unit1 :
Code:

1 2 3 4 5 6 extern int i; #include <vcl.h> #pragma hdrstop #include "Unit2.h" #include "Unit1.h"
et dans Unit2:
Code:

1 2 3 4 5 #include <vcl.h> #pragma hdrstop #include "Unit1.h" #include "Unit2.h"
Et pourtant la variable i n'est pas accéssible à partir de unit2;J'ai un message d'erreur quand je compile:Symbole 'i' non défini!!
Quelqu'un peut m'aider Svp
Merci d'avance

Salut,

Quand il parler de mettre en externe c'est dans unit.h que celà se fait :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 class TForm1 : public TForm { __published: // Composants gérés par l'EDI TButton *Button1; void __fastcall Button1Click(TObject *Sender); private: // Déclarations de l'utilisateur public: // Déclarations de l'utilisateur __fastcall TForm1(TComponent* Owner); }; //--------------------------------------------------------------------------- extern PACKAGE TForm1 *Form1; int i;
Utilisation de i :
Code:

1 2 3 4 5 __fastcall TForm2::TForm2(TComponent* Owner) : TForm(Owner) { i=12; }
Par contre, j'ai une erreur :

Citation:

[Lieur Avertissement] Public symbol '_i' defined in both module C:\PROGRAM FILES\BORLAND\CBUILDER6\PROJECTS\UNIT1.OBJ and C:\PROGRAM FILES\BORLAND\CBUILDER6\PROJECTS\UNIT2.OBJ

Dans ce cas, i est global à toute l'application sans passer par l'objet Form1

Sinon tu peux faire ceci :
Code:

1 2 3 4 5 6 7 8 9 10 class TForm1 : public TForm { __published: // Composants gérés par l'EDI TButton *Button1; private: // Déclarations de l'utilisateur public: // Déclarations de l'utilisateur __fastcall TForm1(TComponent* Owner); int i; };
Utilisation de i :
Code:

1 2 3 4 5 __fastcall TForm2::TForm2(TComponent* Owner) : TForm(Owner) { Form1->i=12; }
PS :

Je viens aussi du monde de Delphi et j'avoue que l'erreur, je ne vois trop la cause du soucis.

Salut ero-sennin
Tout d'abord merci pour ta réponse mais je n'ai pas su ou placer ce code,Car quand je créer une nouvelle application voila ce que j'ai dans Unit1.h :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 #include <vcl.h> #pragma hdrstop #include "Unit1.h" //--------------------------------------------------------------------------- #pragma package(smart_init) #pragma resource "*.dfm" TForm1 *Form1; //--------------------------------------------------------------------------- __fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) { }
j'ai remplacé

Code:

TForm1 *Form1;

par le fragment que tu m as donnée :
Code:

1 2 extern PACKAGE TForm1 *Form1; int i;
Mais j'obtient une erreur quand je compile:
[lieur erreur]Unresolved external referenced from...

J'ai passé la nuit à tatonner en arrivant au résultat suivant:
dans Unit1.h j'ai mis :
Code:

1 2 3 4 5 6 7 8 9 10 11 #include <vcl.h> #pragma hdrstop #include "Unit1.h" #include "Unit2.h" //--------------------------------------------------------------------------- #pragma package(smart_init) #pragma resource "*.dfm" TForm1 *Form1; int i;
et dans Unit2.h :
Code:

1 2 3 4 5 6 7 8 9 10 extern int i; #include <vcl.h> #pragma hdrstop #include "Unit1.h" #include "Unit2.h" //--------------------------------------------------------------------------- #pragma package(smart_init) #pragma resource "*.dfm" TForm2 *Form2;
Et là ça marche trés bien,pas de soucis pour le passage de la valeur de i pour le moment,mais est ce que je risque d'avoir des surprises avec cette methode??

27/10/2007, 10h52
kot
Bonjour

Si tu veux utiliser une variable dans plusieurs module, il faut indiquer au compilateur que la variable existe, on dit que l'on "déclare" la variable:
int i;

Tu dis "i est une variable de type entière".
Pour pouvoir utiliser i dans plusieurs unit, il faut que le compilateur trouve cette déclaration dans chaque unit. Pour éviter de le répéter à chaque unit, on met cette déclaration dans un fichier include ".h" et chaque unit voulant utiliser cette variable utilise le fichier include.
Cela fait donc:
Code:

1 2 3 4 5 6 7 8 9 Fichier A.cpp #include <iostream> using namespace std; #include "fichieri.h" // Je peux utiliser la variable i void totoA() {cout << i << endl;}
Code:

1 2 3 4 5 6 7 8 9 Fichier B.cpp #include <iostream> using namespace std; #include "fichieri.h" // Je peux aussi utiliser la variable i void totoB() {cout << i << endl;}
et le fichier i:
Code:

1 2 Fichier i.h int i;
Le code ci-dessus a le défaut suivant:
A la compilation de A, il réserve de la mémoire pour une variable i de type entier.
A la compilation de B, il réserve de la mémoire pour une variable i de type entier.

Le problème est que la variable i a deux réservations mémoire. Il faut donc dire au compilateur que l'on déclare la variable mais que l'on ne souhaite pas qu'il fasse de réservation:

A et B.cpp sont identiques mais i.h devient:
Code:

1 2 Fichier i.h extern int i;
Si tu compiles cela tout va bien se passer. Dernier problème: le compilateur n'a jamais réservé de mémoire pour i. Du coup, il faut dans un seul fichier cpp réserver de la mémoire pour i:
Code:

1 2 Fichier i.cpp int i;
Voili, voilou.

En espérant avoir répondu à tes questions.
En résumé:
Code:

1 2 Fichier i.cpp int i;
Code:

1 2 Fichier i.h extern int i;
Code:

1 2 3 4 5 6 7 8 9 Fichier A.cpp #include <iostream> using namespace std; #include "fichieri.h" // Je peux utiliser la variable i void totoA() {cout << i << endl;}
Code:

1 2 3 4 5 6 7 8 9 Fichier B.cpp #include <iostream> using namespace std; #include "fichieri.h" // Je peux aussi utiliser la variable i void totoB() {cout << i << endl;}

Bonjour,

Je ne suis pas expert en C++ et en ce qui concerne les déclarations de variable globale, je le fais de cette façon :

Déclaration du .h:

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
//---------------------------------------------------------------------------
 
#ifndef Unit1H
#define Unit1H
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
//---------------------------------------------------------------------------
class TForm1 : public TForm
{
__published:	// Composants gérés par l'EDI
        TButton *Button1;
        void __fastcall Button1Click(TObject *Sender);
private:	// Déclarations de l'utilisateur
public:		// Déclarations de l'utilisateur
        __fastcall TForm1(TComponent* Owner);
        int i;
};
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif

Déclaration du .cpp :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include "Unit2.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
  i=12;
}
//---------------------------------------------------------------------------
 
void __fastcall TForm1::Button1Click(TObject *Sender)
{
  Form2->Show();
}
//---------------------------------------------------------------------------

Utilisation de la variable i dans la Form 2 :

Le .h :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//---------------------------------------------------------------------------
 
#ifndef Unit2H
#define Unit2H
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
//---------------------------------------------------------------------------
class TForm2 : public TForm
{
__published:	// Composants gérés par l'EDI
        TButton *Button1;
        void __fastcall Button1Click(TObject *Sender);
private:	// Déclarations de l'utilisateur
public:		// Déclarations de l'utilisateur
        __fastcall TForm2(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern PACKAGE TForm2 *Form2;
//---------------------------------------------------------------------------
#endif

Le .cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//---------------------------------------------------------------------------
 
#include <vcl.h>
#pragma hdrstop
 
#include "Unit2.h"
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm2 *Form2;
//---------------------------------------------------------------------------
__fastcall TForm2::TForm2(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------
 
void __fastcall TForm2::Button1Click(TObject *Sender)
{
  ShowMessage(IntToStr(Form1->i));
}
//---------------------------------------------------------------------------

En résumé :

- Dans public de la form 1, on mettra les variables globales
- Lorsque l'on voudrait utiliser cette variable dans une autre form, il faudra :
- Ajouter le .h de la form qui possède la variable globale à celle qui veut l'utiliser
- Appeler cette variable précédé du nom de form où elle a été déclarée (ex : Form1->i)

J'espère que ca répond à ton besoin! Peut être obtiendras tu une réponse meilleure de la part d'un des membres ...

Bonne continuation
A+ ;)

27/10/2007, 22h56
b_reda31

:salut: Merci à vous pour toutes ces précisions!!
je cours essayer ...
29/10/2007, 07h39
Xavier

Pour confirmation, j'utilise toujours la méthode de "ero-sennin" depuis que je suis mis sur CBuilder.
Cela marche sans aucun problème et c'est une méthode très simple, sans avoir besoin de connaitre tous les trucs C++.
30/10/2007, 21h21
b_reda31

Merci à vous tous ,je viens d'essayer la méthode d'ero-sennin et ça marche trés bien :king:
Pour les procédures globales c'est donc le même principe?
Je met le corp de la procédure dans la partie public du fichier H n'est ce pas?