D�claration d'un composant dynamique

Version imprimable

12/02/2009, 11h16
darkman13130

D�claration d'un composant dynamique
Bonjour tout le monde, j'ai essay� de d�clararer un composant dynamique en d�finissant la taille du composant avec une variable mais borland m'indique une erreur....
Code:

1 2 int nbimage=10; TImage *Image[nbimage];
Code erreur : [C++ Erreur] Unit1.cpp(24): E2313 Expression constante n�cessaire

Merci
12/02/2009, 11h47
sat83
Comme le message d'erreur l'indique, tu ne peut pas initialiser la taille d'un tableau � partir d'une variable :

Code:

TImage *Image[10]; // C'est OK
Code:

1 2 int nbimage=10; TImage *Image[nbimage]; //Erreur de compilation
12/02/2009, 11h57
darkman13130

Je suis obliger de faire comme sa car c'est une variable que je recup�re de l'utilisateur quand il rentre dans le programme, sinon si possible d'avoir une autre solution

De mon cot�, lorsque je dois g�rer une liste d'objet dont le nombre n'est pas d�termin� � la conception, j'utilise TObjectList. Il s'utilise comme TStringList, avec des objets :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
  TObjectList *objList = new TObjectList() ;
 
  objList->Add( Image1 ) ;
  objList->Add( Image2 ) ;
  objList->Add( Image3 ) ;
  //[...]
  for( int i=0; i< objList->Count; i++ )
  {
     ShowMessage( ((TImage*) objList->Items[i] )->Name ) ; //Au moment de récupérer l'objet, il faut indiquer de quel objet il s'agit, par exemble pour des images (TImage*)
  }
  //[...]
  delete objList ;

Oui je suis d'accord mais ton image tu sais combien tu en veu, moi je sais pas
Code:

1 2 3 4 5 objList->Add( Image1 ) ; objList->Add( Image2 ) ; objList->Add( Image3 ) ; //Moi je ne sais pas combien j'ai est

Ce n'est pas grave, tu peut faire une boucle pour les cr�er :
Code:

1 2 3 4 5 6 TImage* image = NULL; for(int i=0;i<nbImage;i++) { image = new TImage(NULL); objList->Add(image); }

Je suis desoler mais je commence a �tre perdu voici mon code source

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
nbImage=10;
 
//C'est issi que sa ne fonctionne pas d'ou l'erreur
TImage *Image[nbImage];
 
chemin="C:\\Documents and Settings\\09.12.08\\Bureau\\photos\\";
extension=".bmp";
Extensions->Add(extension);
 
//Cette fonction me permet de recuperer chaque chemin de la photo
Search(chemin, Extensions, ListBox1->Items);
 
 
 for(int m=0;m<lignetab;m++)
 {
 
 
   Image[m]= new TImage(this);
 
   Image[m]->Parent = Form1;
 
   Image[m]->Name="Image"+m;
   Image[m]->Left = 100*m;
   Image[m]->Proportional=true;
 
        if(ExtractFileExt(tab[m]).LowerCase() == ".bmp")
        {
                Image[m]->Picture->LoadFromFile(tab[m]);
        }
 
 }

Et si c'est possible de me montrer comment je peut faire avec sa

Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 TObjectList *imgList = new TObjectList( true ) ; //true signifie que TObjectList gère lui même la libération des objets TImage *image; for(int m=0;m<lignetab;m++) { image = new TImage(this); image->Parent = Form1; image->Name="Image"+m; image->Left = 100*m; image->Proportional=true; if(ExtractFileExt(tab[m]).LowerCase() == ".bmp") { image->Picture->LoadFromFile(tab[m]); } imgList->Add( image ); }
Ensuite imaginons que tu souhaite afficher la n-i�me image sur ta fiche
(en admettant que sur ta fiche tu est un composant TImage appell� Image1):

Code:

Image1 = (TImage*) imgList->Items[n]

et ne pas oublier lorsque tu n'a plus besoin de ta liste d'image :

Code:

delete imgList;

12/02/2009, 14h41
darkman13130

Une question ton code fonctionne, mais ma variable ou je dois definir le nombre d'image je le met ou, car je dois la mettre imperativement

Salut !

En restant au plus pr�s de sa proposition initiale :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
int NbImages = 10;
// On crée un tableau de pointeurs vers TImage
TImage **Images = new TImage*[NbImages];
//On crée les images
for(int j = 0; j < NbImages; j++) 
    {
    Images[j] = new TImage(this); // << à voir pour this
    Images[j]->Parent = ...
    }
...
 
//A terme on doit détruire le tableau
delete [] Images;

En s'�cartant de sa propostion initiale :

Un TComponent suffirait amplement pour superviser une liste d'objets qui lui appartiennent, en l'occurence ici, des images !
L'avantage est qu'on n'a pas besoin de se soucier de g�rer la liste ou le tableau !
Au moment de se d�truire, ce superviseur d�truira tous les objets dont il est propri�taire !

Un exemple vite fait :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
class jImages : public TComponent
{
protected :
    TImage* __fastcall GetImage(int Index);
public :
    __fastcall jImages(TComponent *AOwner);
    __fastcall jImages(TWinControl *AOwner, int NbImages);
    __fastcall ~jImages();
    void __fastcall LoadFromFile(AnsiString Filename, int Index);
 
__property TImage* Image[int Index]={read=GetImage};
};

Les m�thodes :

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
 
//Constructeur par défaut
 
__fastcall jImages::jImages(TComponent *AOwner)
    : TComponent(AOwner)
{
}
 
//Constructeur dédié 
 
__fastcall jImages::jImages(TWinControl *AOwner, int NbImages)
    : TComponent(AOwner)
{
TImage *Image;
for(int j = 0; j < NbImages; j++)
    {
    Image = new TImage(this);
    Image->Parent = AOwner;
    //Image->SetBounds ...
    }
}
 
//Destructeur
 
__fastcall jImages::~jImages()
{
}
 
//Méthode pour charger une image dans l'une d'elles
 
void __fastcall jImages::LoadFromFile(AnsiString Filename, int Index)
{
if(FileExists(Filename) && (Image[Index] != NULL))
    {
    Image[Index]->Picture->LoadFromFile(Filename);
    }
}
 
//Gère l'accès aux images sous forme de tableau : propriété Image[int Index]
 
TImage* __fastcall jImages::GetImage(int Index)
{
if((Index >=0) && (Index < ComponentCount)) return (TImage*)Components[Index];
return NULL;
}

Pour l'usage :

Code:

1
2
3
4
5
6
7
8
 
jImages *Images;
 
Images = new jImages(this, 10);
 
TImage *Image = Images->Image[N];
 
Images->LoadFromFile("bla bla", 0);

On peut bien s�r y rajouter tout ce que l'on veut : � chacun sa propre vision du d�veloppement !

A plus !