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 !