Soit des objets référencés A, B, C , D etc ...
chaque objet a des caractéristiques connus, par exemple :
le poids : p(A) = 5, p(B) = 10 etc
le volume : V(A) = 12 , V(B) = 7 etc
un objet E peut être composé de plusieurs objets
par exemple : E = 4 A + 5 B
pour calculer le poids de E : p(E) = 4 x p(A) + 5 x P(B)
on peut avoir aussi un objet F = 3 E + 5 D
ou encore U = 4 F + 5 V
Les objets peuvent donc s'imbriquer de manière récursive.
Je recherche quelle est la meilleure structure à donner au(x) fichier(s)
pour :
1- pouvoir avoir une représentation graphique d'un objet et de ses
composants ( dans un treeview par exemple ? )
2- pouvoir manipuler les objets ,
créer un nouvel objet
substituer un objet à un autre
fusionner des objets
3- calculer les caractéristiques ( poids, volume ) de n'importe quel
objet de la manière la plus rapide
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Pascal ROY
LCharles a écrit :
Bonjour,
Voilà le problème que j'ai à résoudre :
Soit des objets référencés A, B, C , D etc ... chaque objet a des caractéristiques connus, par exemple : le poids : p(A) = 5, p(B) = 10 etc le volume : V(A) = 12 , V(B) = 7 etc
un objet E peut être composé de plusieurs objets par exemple : E = 4 A + 5 B pour calculer le poids de E : p(E) = 4 x p(A) + 5 x P(B)
on peut avoir aussi un objet F = 3 E + 5 D ou encore U = 4 F + 5 V Les objets peuvent donc s'imbriquer de manière récursive.
Je recherche quelle est la meilleure structure à donner au(x) fichier(s) pour :
1- pouvoir avoir une représentation graphique d'un objet et de ses composants ( dans un treeview par exemple ? )
2- pouvoir manipuler les objets , créer un nouvel objet substituer un objet à un autre fusionner des objets
3- calculer les caractéristiques ( poids, volume ) de n'importe quel objet de la manière la plus rapide
Merci d'avance pour vos sujétions .
Le mieux à mon avis est de définir une table (ou fichier) ObjetBase, qui contient le nom, l'identifiant, et le type (base ou structuré). Dans le cas d'une base, les informations Poids, Volume, ... sont saisis dans le cas d'un type structuré, les mêmes informations sont calculées.
Ensuite avoir une table (ou fichier ;-) ) StructureObjet contenant ObjetStructure, ObjetBase, Quantité
Ainsi tu retrouveras dans ObjetBase Id / Nom / Poids / Volume / Type 1 / A / 5 / 12 / B 2 / B / 10 / 7 / B 3 / E / 70 / 76 / S
L'IdFils pouvant être un ObjetBase de type structuré. Pour effectué les calculs rapidement, le mieux et de créer une procédure récursive.
En espérant t'avoir aidé -- Pascal ROY (Service Informatique - SODALEC)
LCharles a écrit :
Bonjour,
Voilà le problème que j'ai à résoudre :
Soit des objets référencés A, B, C , D etc ...
chaque objet a des caractéristiques connus, par exemple :
le poids : p(A) = 5, p(B) = 10 etc
le volume : V(A) = 12 , V(B) = 7 etc
un objet E peut être composé de plusieurs objets
par exemple : E = 4 A + 5 B
pour calculer le poids de E : p(E) = 4 x p(A) + 5 x P(B)
on peut avoir aussi un objet F = 3 E + 5 D
ou encore U = 4 F + 5 V
Les objets peuvent donc s'imbriquer de manière récursive.
Je recherche quelle est la meilleure structure à donner au(x) fichier(s)
pour :
1- pouvoir avoir une représentation graphique d'un objet et de ses
composants ( dans un treeview par exemple ? )
2- pouvoir manipuler les objets ,
créer un nouvel objet
substituer un objet à un autre
fusionner des objets
3- calculer les caractéristiques ( poids, volume ) de n'importe quel
objet de la manière la plus rapide
Merci d'avance pour vos sujétions .
Le mieux à mon avis est de définir une table (ou fichier) ObjetBase, qui
contient le nom, l'identifiant, et le type (base ou structuré). Dans le
cas d'une base, les informations Poids, Volume, ... sont saisis
dans le cas d'un type structuré, les mêmes informations sont calculées.
Ensuite avoir une table (ou fichier ;-) ) StructureObjet contenant
ObjetStructure, ObjetBase, Quantité
Ainsi tu retrouveras dans ObjetBase
Id / Nom / Poids / Volume / Type
1 / A / 5 / 12 / B
2 / B / 10 / 7 / B
3 / E / 70 / 76 / S
Soit des objets référencés A, B, C , D etc ... chaque objet a des caractéristiques connus, par exemple : le poids : p(A) = 5, p(B) = 10 etc le volume : V(A) = 12 , V(B) = 7 etc
un objet E peut être composé de plusieurs objets par exemple : E = 4 A + 5 B pour calculer le poids de E : p(E) = 4 x p(A) + 5 x P(B)
on peut avoir aussi un objet F = 3 E + 5 D ou encore U = 4 F + 5 V Les objets peuvent donc s'imbriquer de manière récursive.
Je recherche quelle est la meilleure structure à donner au(x) fichier(s) pour :
1- pouvoir avoir une représentation graphique d'un objet et de ses composants ( dans un treeview par exemple ? )
2- pouvoir manipuler les objets , créer un nouvel objet substituer un objet à un autre fusionner des objets
3- calculer les caractéristiques ( poids, volume ) de n'importe quel objet de la manière la plus rapide
Merci d'avance pour vos sujétions .
Le mieux à mon avis est de définir une table (ou fichier) ObjetBase, qui contient le nom, l'identifiant, et le type (base ou structuré). Dans le cas d'une base, les informations Poids, Volume, ... sont saisis dans le cas d'un type structuré, les mêmes informations sont calculées.
Ensuite avoir une table (ou fichier ;-) ) StructureObjet contenant ObjetStructure, ObjetBase, Quantité
Ainsi tu retrouveras dans ObjetBase Id / Nom / Poids / Volume / Type 1 / A / 5 / 12 / B 2 / B / 10 / 7 / B 3 / E / 70 / 76 / S
L'IdFils pouvant être un ObjetBase de type structuré. Pour effectué les calculs rapidement, le mieux et de créer une procédure récursive.
En espérant t'avoir aidé -- Pascal ROY (Service Informatique - SODALEC)
Charles
Pascal ROY a écrit :
LCharles a écrit :
Bonjour,
Voilà le problème que j'ai à résoudre :
Soit des objets référencés A, B, C , D etc ... chaque objet a des caractéristiques connus, par exemple : le poids : p(A) = 5, p(B) = 10 etc le volume : V(A) = 12 , V(B) = 7 etc
un objet E peut être composé de plusieurs objets par exemple : E = 4 A + 5 B pour calculer le poids de E : p(E) = 4 x p(A) + 5 x P(B)
on peut avoir aussi un objet F = 3 E + 5 D ou encore U = 4 F + 5 V Les objets peuvent donc s'imbriquer de manière récursive.
Je recherche quelle est la meilleure structure à donner au(x) fichier(s) pour :
1- pouvoir avoir une représentation graphique d'un objet et de ses composants ( dans un treeview par exemple ? )
2- pouvoir manipuler les objets , créer un nouvel objet substituer un objet à un autre fusionner des objets
3- calculer les caractéristiques ( poids, volume ) de n'importe quel objet de la manière la plus rapide
Merci d'avance pour vos sujétions .
Le mieux à mon avis est de définir une table (ou fichier) ObjetBase, qui contient le nom, l'identifiant, et le type (base ou structuré). Dans le cas d'une base, les informations Poids, Volume, ... sont saisis dans le cas d'un type structuré, les mêmes informations sont calculées.
Ensuite avoir une table (ou fichier ;-) ) StructureObjet contenant ObjetStructure, ObjetBase, Quantité
Ainsi tu retrouveras dans ObjetBase Id / Nom / Poids / Volume / Type 1 / A / 5 / 12 / B 2 / B / 10 / 7 / B 3 / E / 70 / 76 / S
L'IdFils pouvant être un ObjetBase de type structuré. Pour effectué les calculs rapidement, le mieux et de créer une procédure récursive.
En espérant t'avoir aidé
Merci pour ta réponse. Ok pour la structure des fichiers. Le premier contient tous les objets, et le 2eme décrit la composition d'un objet structuré. Par contre la procédure récursive, c'est pas clair pour moi. Je suppose qu'on parcourt ObjetStructure pour calculer les valeurs. Mais il faut faire plusieurs parcours pour traiter les imbrications d'objet. Comment peut-on être certain que les valeurs calculées sont à jour ? Faut-il mettre un booléen dans le fichier ObjetBase qui indique que le calcul est à jour ?
Pascal ROY a écrit :
LCharles a écrit :
Bonjour,
Voilà le problème que j'ai à résoudre :
Soit des objets référencés A, B, C , D etc ...
chaque objet a des caractéristiques connus, par exemple :
le poids : p(A) = 5, p(B) = 10 etc
le volume : V(A) = 12 , V(B) = 7 etc
un objet E peut être composé de plusieurs objets
par exemple : E = 4 A + 5 B
pour calculer le poids de E : p(E) = 4 x p(A) + 5 x P(B)
on peut avoir aussi un objet F = 3 E + 5 D
ou encore U = 4 F + 5 V
Les objets peuvent donc s'imbriquer de manière récursive.
Je recherche quelle est la meilleure structure à donner au(x)
fichier(s) pour :
1- pouvoir avoir une représentation graphique d'un objet et de ses
composants ( dans un treeview par exemple ? )
2- pouvoir manipuler les objets ,
créer un nouvel objet
substituer un objet à un autre
fusionner des objets
3- calculer les caractéristiques ( poids, volume ) de n'importe quel
objet de la manière la plus rapide
Merci d'avance pour vos sujétions .
Le mieux à mon avis est de définir une table (ou fichier) ObjetBase, qui
contient le nom, l'identifiant, et le type (base ou structuré). Dans le
cas d'une base, les informations Poids, Volume, ... sont saisis
dans le cas d'un type structuré, les mêmes informations sont calculées.
Ensuite avoir une table (ou fichier ;-) ) StructureObjet contenant
ObjetStructure, ObjetBase, Quantité
Ainsi tu retrouveras dans ObjetBase
Id / Nom / Poids / Volume / Type
1 / A / 5 / 12 / B
2 / B / 10 / 7 / B
3 / E / 70 / 76 / S
L'IdFils pouvant être un ObjetBase de type structuré.
Pour effectué les calculs rapidement, le mieux et de
créer une procédure récursive.
En espérant t'avoir aidé
Merci pour ta réponse.
Ok pour la structure des fichiers.
Le premier contient tous les objets, et le 2eme décrit la composition
d'un objet structuré.
Par contre la procédure récursive, c'est pas clair pour moi.
Je suppose qu'on parcourt ObjetStructure pour calculer les valeurs.
Mais il faut faire plusieurs parcours pour traiter les imbrications
d'objet.
Comment peut-on être certain que les valeurs calculées sont à jour ?
Faut-il mettre un booléen dans le fichier ObjetBase qui indique que le
calcul est à jour ?
Soit des objets référencés A, B, C , D etc ... chaque objet a des caractéristiques connus, par exemple : le poids : p(A) = 5, p(B) = 10 etc le volume : V(A) = 12 , V(B) = 7 etc
un objet E peut être composé de plusieurs objets par exemple : E = 4 A + 5 B pour calculer le poids de E : p(E) = 4 x p(A) + 5 x P(B)
on peut avoir aussi un objet F = 3 E + 5 D ou encore U = 4 F + 5 V Les objets peuvent donc s'imbriquer de manière récursive.
Je recherche quelle est la meilleure structure à donner au(x) fichier(s) pour :
1- pouvoir avoir une représentation graphique d'un objet et de ses composants ( dans un treeview par exemple ? )
2- pouvoir manipuler les objets , créer un nouvel objet substituer un objet à un autre fusionner des objets
3- calculer les caractéristiques ( poids, volume ) de n'importe quel objet de la manière la plus rapide
Merci d'avance pour vos sujétions .
Le mieux à mon avis est de définir une table (ou fichier) ObjetBase, qui contient le nom, l'identifiant, et le type (base ou structuré). Dans le cas d'une base, les informations Poids, Volume, ... sont saisis dans le cas d'un type structuré, les mêmes informations sont calculées.
Ensuite avoir une table (ou fichier ;-) ) StructureObjet contenant ObjetStructure, ObjetBase, Quantité
Ainsi tu retrouveras dans ObjetBase Id / Nom / Poids / Volume / Type 1 / A / 5 / 12 / B 2 / B / 10 / 7 / B 3 / E / 70 / 76 / S
L'IdFils pouvant être un ObjetBase de type structuré. Pour effectué les calculs rapidement, le mieux et de créer une procédure récursive.
En espérant t'avoir aidé
Merci pour ta réponse. Ok pour la structure des fichiers. Le premier contient tous les objets, et le 2eme décrit la composition d'un objet structuré. Par contre la procédure récursive, c'est pas clair pour moi. Je suppose qu'on parcourt ObjetStructure pour calculer les valeurs. Mais il faut faire plusieurs parcours pour traiter les imbrications d'objet. Comment peut-on être certain que les valeurs calculées sont à jour ? Faut-il mettre un booléen dans le fichier ObjetBase qui indique que le calcul est à jour ?
Pascal ROY
Charles a écrit :
Pascal ROY a écrit :
LCharles a écrit :
Bonjour,
Voilà le problème que j'ai à résoudre :
Soit des objets référencés A, B, C , D etc ... chaque objet a des caractéristiques connus, par exemple : le poids : p(A) = 5, p(B) = 10 etc le volume : V(A) = 12 , V(B) = 7 etc
un objet E peut être composé de plusieurs objets par exemple : E = 4 A + 5 B pour calculer le poids de E : p(E) = 4 x p(A) + 5 x P(B)
on peut avoir aussi un objet F = 3 E + 5 D ou encore U = 4 F + 5 V Les objets peuvent donc s'imbriquer de manière récursive.
Je recherche quelle est la meilleure structure à donner au(x) fichier(s) pour :
1- pouvoir avoir une représentation graphique d'un objet et de ses composants ( dans un treeview par exemple ? )
2- pouvoir manipuler les objets , créer un nouvel objet substituer un objet à un autre fusionner des objets
3- calculer les caractéristiques ( poids, volume ) de n'importe quel objet de la manière la plus rapide
Merci d'avance pour vos sujétions .
Le mieux à mon avis est de définir une table (ou fichier) ObjetBase, qui contient le nom, l'identifiant, et le type (base ou structuré). Dans le cas d'une base, les informations Poids, Volume, ... sont saisis dans le cas d'un type structuré, les mêmes informations sont calculées.
Ensuite avoir une table (ou fichier ;-) ) StructureObjet contenant ObjetStructure, ObjetBase, Quantité
Ainsi tu retrouveras dans ObjetBase Id / Nom / Poids / Volume / Type 1 / A / 5 / 12 / B 2 / B / 10 / 7 / B 3 / E / 70 / 76 / S
L'IdFils pouvant être un ObjetBase de type structuré. Pour effectué les calculs rapidement, le mieux et de créer une procédure récursive.
En espérant t'avoir aidé
Merci pour ta réponse. Ok pour la structure des fichiers. Le premier contient tous les objets, et le 2eme décrit la composition d'un objet structuré. Par contre la procédure récursive, c'est pas clair pour moi. Je suppose qu'on parcourt ObjetStructure pour calculer les valeurs. Mais il faut faire plusieurs parcours pour traiter les imbrications d'objet. Comment peut-on être certain que les valeurs calculées sont à jour ? Faut-il mettre un booléen dans le fichier ObjetBase qui indique que le calcul est à jour ?
Par exemple, mais tu peux aussi relancer les calculs à chaque modification d'un objet base. Avec une procédure inverse, tu peux obtenir toutes les structures auxquelles l'objet base appartient.
-- Pascal ROY (Service Informatique - SODALEC)
Charles a écrit :
Pascal ROY a écrit :
LCharles a écrit :
Bonjour,
Voilà le problème que j'ai à résoudre :
Soit des objets référencés A, B, C , D etc ...
chaque objet a des caractéristiques connus, par exemple :
le poids : p(A) = 5, p(B) = 10 etc
le volume : V(A) = 12 , V(B) = 7 etc
un objet E peut être composé de plusieurs objets
par exemple : E = 4 A + 5 B
pour calculer le poids de E : p(E) = 4 x p(A) + 5 x P(B)
on peut avoir aussi un objet F = 3 E + 5 D
ou encore U = 4 F + 5 V
Les objets peuvent donc s'imbriquer de manière récursive.
Je recherche quelle est la meilleure structure à donner au(x)
fichier(s) pour :
1- pouvoir avoir une représentation graphique d'un objet et de ses
composants ( dans un treeview par exemple ? )
2- pouvoir manipuler les objets ,
créer un nouvel objet
substituer un objet à un autre
fusionner des objets
3- calculer les caractéristiques ( poids, volume ) de n'importe quel
objet de la manière la plus rapide
Merci d'avance pour vos sujétions .
Le mieux à mon avis est de définir une table (ou fichier) ObjetBase,
qui contient le nom, l'identifiant, et le type (base ou structuré).
Dans le
cas d'une base, les informations Poids, Volume, ... sont saisis
dans le cas d'un type structuré, les mêmes informations sont calculées.
Ensuite avoir une table (ou fichier ;-) ) StructureObjet contenant
ObjetStructure, ObjetBase, Quantité
Ainsi tu retrouveras dans ObjetBase
Id / Nom / Poids / Volume / Type
1 / A / 5 / 12 / B
2 / B / 10 / 7 / B
3 / E / 70 / 76 / S
L'IdFils pouvant être un ObjetBase de type structuré.
Pour effectué les calculs rapidement, le mieux et de
créer une procédure récursive.
En espérant t'avoir aidé
Merci pour ta réponse.
Ok pour la structure des fichiers.
Le premier contient tous les objets, et le 2eme décrit la composition
d'un objet structuré.
Par contre la procédure récursive, c'est pas clair pour moi.
Je suppose qu'on parcourt ObjetStructure pour calculer les valeurs.
Mais il faut faire plusieurs parcours pour traiter les imbrications
d'objet.
Comment peut-on être certain que les valeurs calculées sont à jour ?
Faut-il mettre un booléen dans le fichier ObjetBase qui indique que le
calcul est à jour ?
Par exemple, mais tu peux aussi relancer les calculs à chaque modification
d'un objet base. Avec une procédure inverse, tu peux obtenir toutes les
structures auxquelles l'objet base appartient.
Soit des objets référencés A, B, C , D etc ... chaque objet a des caractéristiques connus, par exemple : le poids : p(A) = 5, p(B) = 10 etc le volume : V(A) = 12 , V(B) = 7 etc
un objet E peut être composé de plusieurs objets par exemple : E = 4 A + 5 B pour calculer le poids de E : p(E) = 4 x p(A) + 5 x P(B)
on peut avoir aussi un objet F = 3 E + 5 D ou encore U = 4 F + 5 V Les objets peuvent donc s'imbriquer de manière récursive.
Je recherche quelle est la meilleure structure à donner au(x) fichier(s) pour :
1- pouvoir avoir une représentation graphique d'un objet et de ses composants ( dans un treeview par exemple ? )
2- pouvoir manipuler les objets , créer un nouvel objet substituer un objet à un autre fusionner des objets
3- calculer les caractéristiques ( poids, volume ) de n'importe quel objet de la manière la plus rapide
Merci d'avance pour vos sujétions .
Le mieux à mon avis est de définir une table (ou fichier) ObjetBase, qui contient le nom, l'identifiant, et le type (base ou structuré). Dans le cas d'une base, les informations Poids, Volume, ... sont saisis dans le cas d'un type structuré, les mêmes informations sont calculées.
Ensuite avoir une table (ou fichier ;-) ) StructureObjet contenant ObjetStructure, ObjetBase, Quantité
Ainsi tu retrouveras dans ObjetBase Id / Nom / Poids / Volume / Type 1 / A / 5 / 12 / B 2 / B / 10 / 7 / B 3 / E / 70 / 76 / S
L'IdFils pouvant être un ObjetBase de type structuré. Pour effectué les calculs rapidement, le mieux et de créer une procédure récursive.
En espérant t'avoir aidé
Merci pour ta réponse. Ok pour la structure des fichiers. Le premier contient tous les objets, et le 2eme décrit la composition d'un objet structuré. Par contre la procédure récursive, c'est pas clair pour moi. Je suppose qu'on parcourt ObjetStructure pour calculer les valeurs. Mais il faut faire plusieurs parcours pour traiter les imbrications d'objet. Comment peut-on être certain que les valeurs calculées sont à jour ? Faut-il mettre un booléen dans le fichier ObjetBase qui indique que le calcul est à jour ?
Par exemple, mais tu peux aussi relancer les calculs à chaque modification d'un objet base. Avec une procédure inverse, tu peux obtenir toutes les structures auxquelles l'objet base appartient.
-- Pascal ROY (Service Informatique - SODALEC)
JB
Le Wed, 21 May 2008 20:20:53 +0200, Charles a écrit:
Pascal ROY a écrit :
LCharles a écrit :
Bonjour,
Voilà le problème que j'ai à résoudre :
Soit des objets référencés A, B, C , D etc ... chaque objet a des caractéristiques connus, par exemple : le poids : p(A) = 5, p(B) = 10 etc le volume : V(A) = 12 , V(B) = 7 etc
un objet E peut être composé de plusieurs objets par exemple : E = 4 A + 5 B pour calculer le poids de E : p(E) = 4 x p(A) + 5 x P(B)
on peut avoir aussi un objet F = 3 E + 5 D ou encore U = 4 F + 5 V Les objets peuvent donc s'imbriquer de manière récursive.
Je recherche quelle est la meilleure structure à donner au(x) fichier(s) pour :
1- pouvoir avoir une représentation graphique d'un objet et de ses composants ( dans un treeview par exemple ? )
2- pouvoir manipuler les objets , créer un nouvel objet substituer un objet à un autre fusionner des objets
3- calculer les caractéristiques ( poids, volume ) de n'importe quel objet de la manière la plus rapide
Merci d'avance pour vos sujétions .
Le mieux à mon avis est de définir une table (ou fichier) ObjetBase, qui contient le nom, l'identifiant, et le type (base ou structuré). Dans le cas d'une base, les informations Poids, Volume, ... sont saisis dans le cas d'un type structuré, les mêmes informations sont calculées. Ensuite avoir une table (ou fichier ;-) ) StructureObjet contenant ObjetStructure, ObjetBase, Quantité Ainsi tu retrouveras dans ObjetBase Id / Nom / Poids / Volume / Type 1 / A / 5 / 12 / B 2 / B / 10 / 7 / B 3 / E / 70 / 76 / S et dans ObjetStructure IdStructure / IdFils / Quantite 3 (=E) / 1 (=A) / 4 3 (=E) / 2 (=B) / 5 L'IdFils pouvant être un ObjetBase de type structuré. Pour effectué les calculs rapidement, le mieux et de créer une procédure récursive. En espérant t'avoir aidé
Merci pour ta réponse. Ok pour la structure des fichiers. Le premier contient tous les objets, et le 2eme décrit la composition d'un objet structuré. Par contre la procédure récursive, c'est pas clair pour moi. Je suppose qu'on parcourt ObjetStructure pour calculer les valeurs. Mais il faut faire plusieurs parcours pour traiter les imbrications d'objet.
[...]
Utiliser une procédure appelée récursivement (cela marche en WD) en faisant attention à la définition des variables (locales/globales).
Ou si base SQL vraie utiliser les fonctions SQL adaptées aus structure hiérarchiques.
Le Wed, 21 May 2008 20:20:53 +0200, Charles <nomail@free.fr> a écrit:
Pascal ROY a écrit :
LCharles a écrit :
Bonjour,
Voilà le problème que j'ai à résoudre :
Soit des objets référencés A, B, C , D etc ...
chaque objet a des caractéristiques connus, par exemple :
le poids : p(A) = 5, p(B) = 10 etc
le volume : V(A) = 12 , V(B) = 7 etc
un objet E peut être composé de plusieurs objets
par exemple : E = 4 A + 5 B
pour calculer le poids de E : p(E) = 4 x p(A) + 5 x P(B)
on peut avoir aussi un objet F = 3 E + 5 D
ou encore U = 4 F + 5 V
Les objets peuvent donc s'imbriquer de manière récursive.
Je recherche quelle est la meilleure structure à donner au(x)
fichier(s) pour :
1- pouvoir avoir une représentation graphique d'un objet et de ses
composants ( dans un treeview par exemple ? )
2- pouvoir manipuler les objets ,
créer un nouvel objet
substituer un objet à un autre
fusionner des objets
3- calculer les caractéristiques ( poids, volume ) de n'importe quel
objet de la manière la plus rapide
Merci d'avance pour vos sujétions .
Le mieux à mon avis est de définir une table (ou fichier) ObjetBase,
qui contient le nom, l'identifiant, et le type (base ou structuré).
Dans le
cas d'une base, les informations Poids, Volume, ... sont saisis
dans le cas d'un type structuré, les mêmes informations sont calculées.
Ensuite avoir une table (ou fichier ;-) ) StructureObjet contenant
ObjetStructure, ObjetBase, Quantité
Ainsi tu retrouveras dans ObjetBase
Id / Nom / Poids / Volume / Type
1 / A / 5 / 12 / B
2 / B / 10 / 7 / B
3 / E / 70 / 76 / S
et dans ObjetStructure
IdStructure / IdFils / Quantite
3 (=E) / 1 (=A) / 4
3 (=E) / 2 (=B) / 5
L'IdFils pouvant être un ObjetBase de type structuré.
Pour effectué les calculs rapidement, le mieux et de
créer une procédure récursive.
En espérant t'avoir aidé
Merci pour ta réponse.
Ok pour la structure des fichiers.
Le premier contient tous les objets, et le 2eme décrit la composition
d'un objet structuré.
Par contre la procédure récursive, c'est pas clair pour moi.
Je suppose qu'on parcourt ObjetStructure pour calculer les valeurs.
Mais il faut faire plusieurs parcours pour traiter les imbrications
d'objet.
[...]
Utiliser une procédure appelée récursivement (cela marche en WD) en
faisant attention à la définition des variables
(locales/globales).
Ou si base SQL vraie utiliser les fonctions SQL adaptées aus structure
hiérarchiques.
Le Wed, 21 May 2008 20:20:53 +0200, Charles a écrit:
Pascal ROY a écrit :
LCharles a écrit :
Bonjour,
Voilà le problème que j'ai à résoudre :
Soit des objets référencés A, B, C , D etc ... chaque objet a des caractéristiques connus, par exemple : le poids : p(A) = 5, p(B) = 10 etc le volume : V(A) = 12 , V(B) = 7 etc
un objet E peut être composé de plusieurs objets par exemple : E = 4 A + 5 B pour calculer le poids de E : p(E) = 4 x p(A) + 5 x P(B)
on peut avoir aussi un objet F = 3 E + 5 D ou encore U = 4 F + 5 V Les objets peuvent donc s'imbriquer de manière récursive.
Je recherche quelle est la meilleure structure à donner au(x) fichier(s) pour :
1- pouvoir avoir une représentation graphique d'un objet et de ses composants ( dans un treeview par exemple ? )
2- pouvoir manipuler les objets , créer un nouvel objet substituer un objet à un autre fusionner des objets
3- calculer les caractéristiques ( poids, volume ) de n'importe quel objet de la manière la plus rapide
Merci d'avance pour vos sujétions .
Le mieux à mon avis est de définir une table (ou fichier) ObjetBase, qui contient le nom, l'identifiant, et le type (base ou structuré). Dans le cas d'une base, les informations Poids, Volume, ... sont saisis dans le cas d'un type structuré, les mêmes informations sont calculées. Ensuite avoir une table (ou fichier ;-) ) StructureObjet contenant ObjetStructure, ObjetBase, Quantité Ainsi tu retrouveras dans ObjetBase Id / Nom / Poids / Volume / Type 1 / A / 5 / 12 / B 2 / B / 10 / 7 / B 3 / E / 70 / 76 / S et dans ObjetStructure IdStructure / IdFils / Quantite 3 (=E) / 1 (=A) / 4 3 (=E) / 2 (=B) / 5 L'IdFils pouvant être un ObjetBase de type structuré. Pour effectué les calculs rapidement, le mieux et de créer une procédure récursive. En espérant t'avoir aidé
Merci pour ta réponse. Ok pour la structure des fichiers. Le premier contient tous les objets, et le 2eme décrit la composition d'un objet structuré. Par contre la procédure récursive, c'est pas clair pour moi. Je suppose qu'on parcourt ObjetStructure pour calculer les valeurs. Mais il faut faire plusieurs parcours pour traiter les imbrications d'objet.
[...]
Utiliser une procédure appelée récursivement (cela marche en WD) en faisant attention à la définition des variables (locales/globales).
Ou si base SQL vraie utiliser les fonctions SQL adaptées aus structure hiérarchiques.
