Discussion :

[Benoit_T]

Bonjour, issu de génération java (avec quelques connaissance en C++), j'ai quelques difficultés à appréhender la logique et la syntaxe de delphi. Voici mon problème:

J'ai créé un classe "Graph" qui contient une TList nodes. Celle-ci contient des instances de la classe "Node" (c'est possible d'ailleurs ?).
Je ne dispose que de delphi 7 (et donc je n'ai pas accès aux types génériques). Voici ma déclaration:

nodes : TList ;

Je souhaite créer une fonction qui renvoie l'objet de type Node en position u dans le tableau. Voici le code de ma fonction (NodeID étant un type integer):

Code :

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

1
2
3
4
5
 
function node(u : NodeID) : Node;
    begin;
    Result := Node (nodes[u])
    end;

Je ne peux pas encore tester le programme, est-ce une approche correcte ? Node (nodes[u]) effectue t'il bien le transtypage vers le type Node ?

Pour être plus clair, je cherche à porter en delphi mon code C++ suivant, je souhaite le porter exactement en delphi (d'ailleurs c'est possible d'implémenter les restrictions induites par const dans mon code delphi ?)

Code C++ :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
vector<UpdNode> nodes;
        ...
 
// Renvoie un sommet ( non modifiable )
const Node& node(const NodeID u) const {
        assert( u < nodes.size() );
        return nodes[u];
    }
 
// Renvoie un sommet
    Node& node(const NodeID u) {
        assert( u < nodes.size() );
        return nodes[u];
    }

En vous remerciant par avance,
cordialement,

[Paul TOTH]

bonjour, si tu veux le faire proprement sous Delphi voici ce que tu peux faire:

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
  TNodeList = class(TList)
  private
    function GetNode(aIndex: Integer): TNode;
  public
    property Nodes[aIndex: Integer]: TNode read GetNode; default;
  end;
 
function TNodeList.GetNode(aIndex: Integer): TNode;
begin
  Assert(aIndex < Count);
  Result := List[aIndex];
end;

le mot clé "default" te permets d'omettre le nom de la propriété

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
var
  List: TNodeList;
begin
  List := TNodeList.Create;
  try
   List.Add(TNode.Create);
   List.Nodes[0].Property := Value;
   List[0].Property := Value; // utilise Nodes[] par défaut
   // code qui libère les noeuds (il est possible de surcharger TList.Clear)
  finally
   List.Free;
  end;
end;

NB: la notion de constante sous Delphi est assez différente du C

Code :

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

1
2
3
4
5
6
 
procedure Test(const Node: TNode);
begin
  Node := nil; // impossible car Node est constant !
  Node.Property := Value; // possible car la propriété ne l'est pas :)
end;

PS: il est de coutume de préfixer les types objets d'un T majuscule (TNode et non Node...)

[Benoit_T]

Merci, c'est très clair comme explication.

Je désire faire une fonction dans ma classe TNode qui définit une relation d'ordre entre deux TNode et implémenter une procedure de tri dans la classe TNodeList. J'ai regardé le tutorial http://alphomega.developpez.com/TriTList/
mais j'ai du mal à saisir la logique.

En C++ j'avais à redéfinir l'opérateur "<":

Code c++ :

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

1
2
3
4
bool operator< (const Node& n) const {
        if (carr() == n.carr()) return (mpl() < n.mpl());
        return (carr() < n.carr());
    }

utilisé lors du tri du vecteur nodes de Node de ma classe Graph dans la méthode sortNodes comme il suit:

Code c++ :

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

1
2
3
4
 void sortNodes(NodeID first, NodeID last)
    {
        sort( nodes.begin() + first, nodes.begin() + last );
    }

Je souhaite là aussi porter mon code C++ avec un comportement similaire en delphi ( et surtout je souhaite que le code delphi soit lui aussi rapide ). Quel est la meilleur voie ?

[Paul TOTH]

Tu vas trouver dans TList une méthode Sort que tu peux exploiter de façon très similaire à ton code; elle utilise une procédure callback.

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
 
function SortNodes(Item1, Item2: Pointer): Integer;
var
  Node1: TNode absolute Item1;
  Node2: TNode absolute Item2;
begin
  Result := Node2.Carr() - Node1.Carr();
  if Result = 0 then
    Result := Node2.mpl() - Node1.mpl();
end;
 
var
  List: TNodeList;
begin
  ...
  List.Sort(SortNodes);
end.

la signature de la fonction attend des pointeurs, le mot clé "absolute" permet de déclarer les variable sur la pile de paramètre dans le cas présent. Ce qui évite un transtypage.

[Franck SORIANO]

...le mot clé "absolute" permet de déclarer les variable sur la pile de paramètre dans le cas présent. Ce qui évite un transtypage.

J'avais jamais pensé à me servir de "absolute" de cette façon...

[Benoit_T]

Merci, j'ai encore un peu de mal à percevoir la subtilité du "absolute" car je débute en delphi mais celui-ci m'arrange bien.

Je suis maintenant confronté au problème suivant :

Est-possible d'implémenter de façon performante un comportement basé sur le modèle suivant issu de la classe vector de c++ :

Code :

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

insert ( iterator position, InputIterator first, InputIterator last );

par exemple:

Code :

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

1
2
3
 
int arrayl [] = { 1,2,3};
 myvector.insert (myvector.begin(), arrayl, myarrayl+3);

Il s'agit d'insérer dans la liste à une position donnée (définit par un iterator en C++) des éléments compris entre first et last.

J'ai penser à la solution suivante mais celle-ci ne me semble ni esthetique ni rapide :

Supposons que l'intervalle [[first,last]] soit de longueur n, alors ma solution première, intuitivement serait d'appeller n fois la procédure
Insert(Index: Integer; Item: Pointer); de la classe TList.

Cependant, à chaque appel de Insert, il risque, Capacity et Count vont être incrémentée et les éléments de la liste après position vont être décalés. J'imagine que ça va être très couteux en temps ? Alors comment faire? Devrais-je utiliser une autre structure de donnée (sachant que cette dernière ne dois pas prendre plus de mémoire que la TList (impossible par exemple d'utiliser des listes chainées)) ?

PS: pas évident de se mettre à un nouveau langage !

[anapurna]

salut

moi la solution premiere serai de parcourir le tableau d'indice a entrer et a chaque iteration faire un insert

le problème devait déjà ce poser en c++ pour le decalage d'indice dans le tableau apres chaque insert a moins qu'il ne soit possible d'avoir deux indice identique

@+ Phil

[ShaiLeTroll]

Iterator, la STL ... je découvre la SPL du PHP en ce moment

Je suppose que derrière cet iterator est lié à un objet iterable, donc à la place, toi cela sera une autre TList, comme il n'y a pas d'interface Iterable en Delphi, tu devras prévoir les variantes nécessaires à chaque source, TList, TStrings, Array, DataSet, ...

On peut espérer, qu'en C++, il ne doit faire un move d'un seul, c'est dommage que cela n'existe pas en Delphi effectivement

Tu peux au moins au faire cela, déjà la mémoire sera alloué une seule fois ...

Code :

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

List.Capacity := List.Capacity + last - first + 1;

ensuite, pour la boucle de Insert, c'est le plus simple comme le suggère Anapurna, surtout qu'il faut penser au mécanisme de notification de la TList (surtout dans le cas d'heritage)

regarde aussi TList.Assign qui permet pas mal de chose

[Paul TOTH]

je ne sais pas s'il existe un équivalent à absolute en C...le principe est juste de superposer deux variables :

Code :

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

1
2
3
4
 
var
  w : word;
  b : byte absolute w; // le premier byte de W

pour ce cas, on obtiendrait la même chose avec un "union" dont la syntaxe est très particulière en Pascal

Code :

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

1
2
3
4
5
6
7
8
9
 
type
  twb = record
  case byte of
    0 : (w : word);
    1 : (b: byte);
  end;
var
 wb:twb;

je n'ai pas bien suivi le code de l'iterateur...mais pour éviter que TList ne réalloue sa liste de pointer à chaque Insert, il suffit de jouer sur Capacity

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
function TNodeList.InsertNodes(const aNodes: array of TNode);
var
  cCount : Integer;
  cIdx : Integer;
begin
  cCount := Length(aNodes);
  if Count + cCount > Capacity then
    Capacity := Count + cCount;
  for cIdx := 0 to cCount - 1 do
   Insert(aNodes[cIdx]);
end;

oui le passage à un nouveau langage n'est pas simple...pas pour la syntaxe que le compilateur pointe rapidement (sauf les faux amis comme "if (c=0)" au lieu de "if (c==0)")...mais il faut se faire au nouveau framework, ça c'est bcp plus long

[Benoit_T]

Merci ! Effectivement la syntaxe n'est pas un problème, c'est la logique et le nouveau template qui pose problème !

En me basant sur l'implémentation que vous m'avez suggéré, j'ai créé, outre ma classe TNodeList qui représente une liste qui d'objets de type TNode, une classe TNodeIDList qui contient elle des types TNodeID. Ce type est en réalité simplement un cardinal. J'ai donc effectué les modifications suivantes:

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
  // ********************** Classe codant une liste d'IDs de sommets
   TNodeIDList = class(TList)
 
    function GetNodeID(aIndex: Integer): TNodeID;
    property NodesID[aIndex: Integer]: TNodeID read GetNodeID; default;
    procedure InsertNodeIDs( position : integer; const aNodeIDs: array of TNodeID);
  end;
...
 
function TNodeIDList.GetNodeID(aIndex: Integer) : TNodeID;
   begin
    Assert(aIndex < Count);
   // List[aIndex] me renvoie un pointeur de Cardinal et non un cardinal    
   //(pourquoi ? ), j'utilise "variable"^ pour accéder au cardinal pointé par 
   //List[aIndex]
 
    Result := Cardinal(List[aIndex]^);
   end;
 
 
 procedure TNodeIDList.InsertNodeIDs( position : integer; const aNodeIDs: array of TNodeID);
 
var
  cCount : Integer;
  cIdx : Integer;
  // Je déclare une variable de type pointeur de Cardinal
  pCard : ^Cardinal;
 
begin
  cCount := Length(aNodeIDs);
   // J'initialise la variable de type pointeur de cardinal
   new(pCard);
 
 
  if Count + cCount > Capacity then
    Capacity := Count + cCount;
  for cIdx := 0 to cCount - 1 do
  // J'affecte au cardinal pointé par pCard la valeur du cardinal 
  //aNodeIDs[cIdx] 
   pCard^ := aNodeIDs[cIdx];
 
   // J'insère le pointeur de cardinal dans ma liste à la position position
   Insert(position , pCard );
end;

Mon code compile mais je ne peux pas encore le tester, est-ce que ma démarche est logique ?

Bon le "Insert(position , pCard );" n'est pas correct car avec ce code je vais insérer dans ma liste à la position position le tableau renversé du tableau en paramètre et non ce dernier dans le bon ordre mais ça ne devrait pas être très dur à corriger (d'ailleurs on ne peut pas faire de boucle for "inversée"?, du style for(i=max; i>min; i--) en delphi?)

Enfin je n'ai pas trouver de réponse dans la doc delphi ou avec google à cette question: est-il possible de trier (sort) partiellement une TList entre deux indices first et end?

Cordialement et en vous remerciant pour votre aide

[Benoit_T]

Un autre soucis !

J'ai implémenté la fonction de tri sur le critère spécifié par la fonction SortNodes comme il suit.

Code :

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

1
2
3
4
5
6
7
 procedure TNodeList.SortListNodes ( first : TEdgeID  ; last : TEdgeID );
 // TODO: implémenter le Sort entre first et last seulement (pour l'instant tri
 // global
 
  begin
    List.Sort(TUptNode.SortEdges);
  end;

...

Code :

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

1
2
3
4
5
6
7
8
9
function TUptNode.SortNodes(Item1, Item2: Pointer): Integer;
var
  Node1: TUptNode absolute Item1;
  Node2: TUptNode absolute Item2;
begin
  Result := Node2.Carr() - Node1.Carr();
  if Result = 0 then
    Result := Node2.mpl() - Node1.mpl();
end;

J'ai crée une méthode qui tri ma liste de sommet (List de UptNode):

Code :

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

1
2
3
4
5
6
7
 procedure TNodeList.SortListNodes( first : TNodeID; last : TNodeID);
 // TODO: implémenter le Sort entre first et last seulement (pour l'instant tri
 // global
  begin
// Ligne 118
    List.Sort(TUptNode.SortEdges);
  end;

La compilation de cette dernière ne passe pas et delphi me renvoie l'erreur suivante sur la ligne 118:
Type Record, Object ou Class requis et l'erreur:
Types incompatibles 'procédure normale et pointeur de méthode'

D'où pourrait venir l'erreur ? Je ne vois vraiment pas

[Paul TOTH]

deux erreurs

1) TList gère des pointeurs, alors

soit tu profites du fait qu'un pointeur et un cardinal ont la même taille pour transtyper de l'un vers l'autre :

Code :

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

1
2
3
 
  List.Add(pointer(monCardinal))
  monCardinal := cardinal(List[i]);

soit tu gères réellement des pointeurs de cardinal c'est conceptuellement plus juste mais l'intéret me semble limité

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
var
 p: pCardinal;
begin
  New(p);
  p^ := monCardinal;
  List.Add(p);
...
  p := List[i];
  monCardinal := p^;
...
 // sans oublier un Dispose(PCardinal(List[i])) quand il faut le retirer de la liste !
end;

2) TList.Sort() attend une procédure statique, pas une méthode de classe

PS: je ne sais si ça existe déjà, mais tu peux aussi réécrire un TList qui te proposerait un interator des ForEach() ... ou passer à Delphi 2009 qui le propose avec les générics

[Benoit_T]

Merci pour ces corrections et précision.

Je ne vois pas bien la logique de sort, que dois-je corriger ? Comme l'implémenter en procedure statique ?

Cordialement,

[Paul TOTH]

Merci pour ces corrections et précision.

Je ne vois pas bien la logique de sort, que dois-je corriger ? Comme l'implémenter en procedure statique ?

Cordialement,

voici une procédure statique

Code :

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

1
2
3
4
5
 
function toto(item1,item2:pointer):Integer;
begin
 // Self n'existe pas, nous ne somme pas dans un objet
end;

voici une méthode objet

Code :

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

1
2
3
4
5
6
7
8
9
10
 
type
  TToto = class
    procedure toto(item1, item2:pointer):Integer;
  end;
 
procedure TToto.toto(item1, item2:pointer):integer;
begin
  // Self est l'instance de TToto invoquée
end;