Discussion :

[cestpasmoinonplus]

Bonjour à Tous.tes.
Je n'ai que très rarement utilisé les pointeurs en Delphi tout simplement parce que je n'en ai jamais eu besoin.
Du coup, je ne maîtrise pas très bien le sujet.
Je n'ai pas pu trouver de réponse claire et net à ma question :

Lorsque je crée un objet Toto ayant une structure classique (dans mon cas, relativement lourde),
est-ce que, quand je déclare un pointeur de type Toto, Delphi réserve-t-il l'espace mémoire correspondant à la structure de Toto ?

Un pointeur est une adresse, ok. Mais il me semble "logique" que si j'en déclare un, il faut bien qu'il pointe (lors de son initialisation !) vers une zone mémoire correspondant à son type.
Du coup, si j'en déclare 5 et que je les initialise, Delphi va bien réserver 5 fois l'espace mémoire correspondant à la structure de Toto, ou pas ?

Merci d'avance pour votre éclairage.

[ShaiLeTroll]

Il faut utiliser soit le couple New/Dispose pour allouer ton record soit le couple GetMem/FreeMem
C'est à toi de faire l'allocation explicite

attention, ne pas confondre l'utilisateur de pointeur que l'on alloue manuellement
Et des pointeurs qui ne sont que des références sur des variables déjà existantes

[cestpasmoinonplus]

Merci pour ces précisions ShaiLeTroll.

[cestpasmoinonplus]

Mais...si j'en déclare 5 et que je les initialise, Delphi va bien réserver 5 fois l'espace mémoire correspondant à la structure de Toto, ou pas ?

[ShaiLeTroll]

les pointeurs c'est pour gérer MANUELLEMENT la mémoire
Delphi ne fait rien si tu ne le fais pas explicitement

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
type
  PToto = ^TToto;
  TToto = record
    ...
  end;

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
var
  Toto1: PToto;
  Toto2: PToto;
  Toto3: PToto; 
  Toto4: PToto;
  Toto5: PToto;
begin
  // -- ici RIEN n'est alloué en Mémoire
 
  New(Toto1);
  // -- seul Toto1 a un espace mémoire
  New(Toto2);
  // -- seul Toto1 et Toto2 ont un espace mémoire
  New(Toto3);
  New(Toto4);
  New(Toto5);
 
  -- utilisation des Toto
 
  Dispose(Toto5);
  Dispose(Toto4);
  Dispose(Toto3);
  // -- seul Toto1 et Toto2 ont un espace mémoire
  Dispose(Toto2);
  // -- seul Toto1 a un espace mémoire
  Dispose(Toto1);

[cestpasmoinonplus]

Ok, donc la réponse est : oui.

Merci ShaiLeTroll .

[guillemouze]

Je ne suis pas sur que la question et la réponse aient bien été compris.

Premièrement, soyons surs que la terminologie soit la bonne. Je pense qu'un bout de code permettrait d'être sur qu'on parle de la même chose.

Lorsque je crée un objet Toto ayant une structure classique (dans mon cas, relativement lourde),
est-ce que, quand je déclare un pointeur de type Toto, Delphi réserve-t-il l'espace mémoire correspondant à la structure de Toto ?

Quand tu parles d'objet Toto, tu parles d'une classe, et ton pointeur sur toto une instance de cette classe ? :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
type
  Toto = class
    plein : integer;
    de : string;
    champs : double;
  end;
...
var
  pointeur_de_type_toto : Toto;
begin
  //ici, pointeur_de_type_toto est un pointeur (4octets en 32bits), c'est le seul espace mémoire réservé pour le moment (contenant une valeur aléatoire)
  pointeur_de_type_toto := Toto.Create; // ici, l'espace mémoire de toto est alloué (beaucoup plus d'octets) 
  ...
  pointeur_de_type_toto.Free; // liberation de l'instance, la memoire est libérée
end; //fin de la fonction, la variable locale "pointeur_de_type_toto" est libérée (4o)

Un pointeur est une adresse, ok. Mais il me semble "logique" que si j'en déclare un, il faut bien qu'il pointe (lors de son initialisation !) vers une zone mémoire correspondant à son type.

En Delphi, les variables d'objets sont implicitement des pointeurs. Tant que tu n’appelle pas de constructeur, seul les 4o du pointeur sont alloués. C'est le compilateur qui va vérifier si ton typage est correct. C'est le constructeur appellé qui va déterminer la taille de la mémoire à utiliser :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
type
  TA = class
    champDeA: integer;
  end;
 
  TB = class(TA)
    champDeB: string;
  end;
...
var
  maVar : TA;
begin
  maVar := TB.Create; //c'est ici que la mémoire est allouée, car avant cette ligne, on ne sait pas quel descendant de TA on va créer.
end;

[cestpasmoinonplus]

Quand tu parles d'objet Toto, tu parles d'une classe, et ton pointeur sur toto une instance de cette classe ?

Oui.
Du coup, si j'initialise (et non déclare) 5 pointeurs PToto, il va bien allouer en mémoire 5 instances distinctes d'objet Toto, sur lesquels vont pointer distinctement les 5 pointeurs. Soit : 5 fois le poids d'un Toto.
Si ce n'est pas ça, alors, effectivement, je n'ai rien compris à la réponse.

[guillemouze]

Oui.
Du coup, si j'initialise (et non déclare) 5 pointeurs PToto, il va bien allouer en mémoire 5 instances distinctes d'objet Toto, sur lesquels vont pointer distinctement les 5 pointeurs. Soit : 5 fois le poids d'un Toto.
Si ce n'est pas ça, alors, effectivement, je n'ai rien compris à la réponse.

Si par "initialiser", tu entends "appeler le constructeur", c.a.d faire un monToto := Toto.create;, alors oui, a condition qu'on se comprenne bien sur ce qu'est PToto, parce que j'ai l'impression que tu mélanges ma réponse et celle de Shai, qui ne sont pas du tout les même; le comportement des record et des classes est bien différent. L'idéal serait que tu nous postes un bout de code pour etre sur.
Voici ce que je dis :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
type
  Toto = class
    ...
  end;
 
var
  toto1, toto2, toto3, toto4 : Toto; // on parle bien de Toto ici, pas de PToto
begin
  //mémoire utilisée ici : 4 pointeur (4 * 4o)
  toto1 := Toto.Create; //création d'une instance de toto et affectation à la variable toto1. mémoire utilisée : 4*pointeur + 1*Toto
  toto2 := Toto.Create; //création d'une instance de toto et affectation à la variable toto2. mémoire utilisée : 4*pointeur + 2*Toto
  toto3 := toto2; //Affectation du pointeur de toto2 à toto3, pas de mémoire supplémentaire, les 2 pointent sur le meme Toto
  toto4 := Toto.Create; //création d'une instance de toto et affectation à la variable toto4. mémoire utilisée : 4*pointeur + 3*Toto
  toto4 := Toto.Create; //création d'une instance de toto et affectation à la variable toto4 une fois de plus : le Toto anciennement référencé par par toto4 est définitivement perdu et sa mémoire ne sera libérée qu'a la fermeture. mémoire utilisée : 4*pointeur + 4*Toto
  ...
  toto4.Free; //ou FreeAndNil(toto4); : libération d'un Toto. mémoire utilisée : 4*pointeur + 3*Toto
  toto3.Free; // libération d'un Toto. mémoire utilisée : 4*pointeur + 2*Toto
  //Attention, ici toto2 qui pointait sur le meme Toto que toto3 n'est plus valide
  //toto2.Free; // A NE SURTOUT PAS FAIRE, la mémoire du Toto référencé à été détruite par toto3
end; // fin de la fonction, libération des variables. mémoire utilisée : 2*Toto (celui de toto1 non detruit, et le premier toto4 dont on a perdu la référence) --> fuite mémoire

[cestpasmoinonplus]

Si par "initialiser", tu entends "appeler le constructeur"

Non, je parle des pointeurs, donc par initialiser j'entends "New()"

[guillemouze]

Non, je parle des pointeurs, donc par initialiser j'entends "New()"

Du coup une bout de code serait intéressant car je pense que tu te méprend sur l'utilisation des objets et des pointeurs.

[cestpasmoinonplus]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
type
  PToto = ^TToto;
  TToto = record
    ...
  end;

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
var
  Toto1: PToto;
  Toto2: PToto;
  Toto3: PToto; 
  Toto4: PToto;
  Toto5: PToto;
begin
  // -- ici RIEN n'est alloué en Mémoire
 
  New(Toto1);
  // -- seul Toto1 a un espace mémoire
  New(Toto2);
  // -- seul Toto1 et Toto2 ont un espace mémoire
  New(Toto3);
  New(Toto4);
  New(Toto5);
 
  -- utilisation des Toto
 
  Dispose(Toto5);
  Dispose(Toto4);
  Dispose(Toto3);
  // -- seul Toto1 et Toto2 ont un espace mémoire
  Dispose(Toto2);
  // -- seul Toto1 a un espace mémoire
  Dispose(Toto1);

[Paul TOTH]

j'ai un vieille article sur les pointeurs qui reste toujours d'actualité

[cestpasmoinonplus]

Merci Paul.