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 .
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 .
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 .
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é
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é
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é
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.
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
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.
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
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.
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
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.
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.
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.