Bonjour à tous,
Je recontre le problème suivant pendant ma prmière migration 5.5->8 (via
la 7 bien sur ...) :
en 5.5 on pouvait parfaitement faire la chose suivante :
dans le code d'initialisation d'une fenêtre F1
GLOBAL
oF1 est un objet machin dynamique
oF1=allouer un machin(_param1)
toujours dans la fenêtre F1, avoir un bouton appelant une fenêtre F2
ayant le code d'initialisation suivant :
GLOBAL
oF2 est un objet truc dynamique
oF2=allouer un truc(_param2)
c'est là que se situe mon problème :
W8 refuse que l'on écrive
oF2=allouer un truc(oF1:membre_quelconque_de_F1)
ou de faire référence à un membre ou une méthode de oF1 dans le code de oF2
Est-ce possible ?
Y a t-il une déclaration particulière à faire ?
Je n'ai pas su trouver la solution dans l'aide de Windev 8
Merci d'avance pour votre aide
Olivier
Bonjour à tous,
Je recontre le problème suivant pendant ma prmière migration 5.5->8 (via
la 7 bien sur ...) :
en 5.5 on pouvait parfaitement faire la chose suivante :
dans le code d'initialisation d'une fenêtre F1
GLOBAL
oF1 est un objet machin dynamique
oF1=allouer un machin(_param1)
toujours dans la fenêtre F1, avoir un bouton appelant une fenêtre F2
ayant le code d'initialisation suivant :
GLOBAL
oF2 est un objet truc dynamique
oF2=allouer un truc(_param2)
c'est là que se situe mon problème :
W8 refuse que l'on écrive
oF2=allouer un truc(oF1:membre_quelconque_de_F1)
ou de faire référence à un membre ou une méthode de oF1 dans le code de oF2
Est-ce possible ?
Y a t-il une déclaration particulière à faire ?
Je n'ai pas su trouver la solution dans l'aide de Windev 8
Merci d'avance pour votre aide
Olivier
Bonjour à tous,
Je recontre le problème suivant pendant ma prmière migration 5.5->8 (via
la 7 bien sur ...) :
en 5.5 on pouvait parfaitement faire la chose suivante :
dans le code d'initialisation d'une fenêtre F1
GLOBAL
oF1 est un objet machin dynamique
oF1=allouer un machin(_param1)
toujours dans la fenêtre F1, avoir un bouton appelant une fenêtre F2
ayant le code d'initialisation suivant :
GLOBAL
oF2 est un objet truc dynamique
oF2=allouer un truc(_param2)
c'est là que se situe mon problème :
W8 refuse que l'on écrive
oF2=allouer un truc(oF1:membre_quelconque_de_F1)
ou de faire référence à un membre ou une méthode de oF1 dans le code de oF2
Est-ce possible ?
Y a t-il une déclaration particulière à faire ?
Je n'ai pas su trouver la solution dans l'aide de Windev 8
Merci d'avance pour votre aide
Olivier
Bonjour,
2 solutions s'offrent à toi !
1) Passer oF1 en paramètre à la fenêtre 2
2) Déclarer oF1 en tant que Externe
C'est a dire, dans le code d'initialisation de la fenêtre 2
ecrire
EXTERNE OF1 (verifier la syntaxe, c'est de tête ;-)
Perso, je prefere passer les paramètres en les typant, ce
qui permet de retrouver l'aide à la saisie.
Pascal
Olivier POUZIN a écrit :Bonjour à tous,
Je recontre le problème suivant pendant ma prmière migration 5.5->8
(via la 7 bien sur ...) :
en 5.5 on pouvait parfaitement faire la chose suivante :
dans le code d'initialisation d'une fenêtre F1
GLOBAL
oF1 est un objet machin dynamique
oF1=allouer un machin(_param1)
toujours dans la fenêtre F1, avoir un bouton appelant une fenêtre F2
ayant le code d'initialisation suivant :
GLOBAL
oF2 est un objet truc dynamique
oF2=allouer un truc(_param2)
c'est là que se situe mon problème :
W8 refuse que l'on écrive
oF2=allouer un truc(oF1:membre_quelconque_de_F1)
ou de faire référence à un membre ou une méthode de oF1 dans le code
de oF2
Est-ce possible ?
Y a t-il une déclaration particulière à faire ?
Je n'ai pas su trouver la solution dans l'aide de Windev 8
Merci d'avance pour votre aide
Olivier
Bonjour,
2 solutions s'offrent à toi !
1) Passer oF1 en paramètre à la fenêtre 2
2) Déclarer oF1 en tant que Externe
C'est a dire, dans le code d'initialisation de la fenêtre 2
ecrire
EXTERNE OF1 (verifier la syntaxe, c'est de tête ;-)
Perso, je prefere passer les paramètres en les typant, ce
qui permet de retrouver l'aide à la saisie.
Pascal
Olivier POUZIN a écrit :
Bonjour à tous,
Je recontre le problème suivant pendant ma prmière migration 5.5->8
(via la 7 bien sur ...) :
en 5.5 on pouvait parfaitement faire la chose suivante :
dans le code d'initialisation d'une fenêtre F1
GLOBAL
oF1 est un objet machin dynamique
oF1=allouer un machin(_param1)
toujours dans la fenêtre F1, avoir un bouton appelant une fenêtre F2
ayant le code d'initialisation suivant :
GLOBAL
oF2 est un objet truc dynamique
oF2=allouer un truc(_param2)
c'est là que se situe mon problème :
W8 refuse que l'on écrive
oF2=allouer un truc(oF1:membre_quelconque_de_F1)
ou de faire référence à un membre ou une méthode de oF1 dans le code
de oF2
Est-ce possible ?
Y a t-il une déclaration particulière à faire ?
Je n'ai pas su trouver la solution dans l'aide de Windev 8
Merci d'avance pour votre aide
Olivier
Bonjour,
2 solutions s'offrent à toi !
1) Passer oF1 en paramètre à la fenêtre 2
2) Déclarer oF1 en tant que Externe
C'est a dire, dans le code d'initialisation de la fenêtre 2
ecrire
EXTERNE OF1 (verifier la syntaxe, c'est de tête ;-)
Perso, je prefere passer les paramètres en les typant, ce
qui permet de retrouver l'aide à la saisie.
Pascal
Olivier POUZIN a écrit :Bonjour à tous,
Je recontre le problème suivant pendant ma prmière migration 5.5->8
(via la 7 bien sur ...) :
en 5.5 on pouvait parfaitement faire la chose suivante :
dans le code d'initialisation d'une fenêtre F1
GLOBAL
oF1 est un objet machin dynamique
oF1=allouer un machin(_param1)
toujours dans la fenêtre F1, avoir un bouton appelant une fenêtre F2
ayant le code d'initialisation suivant :
GLOBAL
oF2 est un objet truc dynamique
oF2=allouer un truc(_param2)
c'est là que se situe mon problème :
W8 refuse que l'on écrive
oF2=allouer un truc(oF1:membre_quelconque_de_F1)
ou de faire référence à un membre ou une méthode de oF1 dans le code
de oF2
Est-ce possible ?
Y a t-il une déclaration particulière à faire ?
Je n'ai pas su trouver la solution dans l'aide de Windev 8
Merci d'avance pour votre aide
Olivier
> Ca fonctionne :-)))
Merci beaucoup de ta réponse !
Si ce n'est pas abuser, pourrais-tu me donner plus de précision sur
> Perso, je prefere passer les paramètres en les typant, ce
> qui permet de retrouver l'aide à la saisie.
D'autre part, j'ai testé les deux cas de figure suivant :
1 - je créé un membre mobjF1 dans la classe F2 qui reçoit oF1 en
paramètre constructeur F2.
-> je peux utiliser les membres :mobjF1:membres_quelconque, j'imagine
aussi les méthodes(pas encore testé), mais je ne peux pas modifier
:mobjF1:membres_quelconque dans le code de F2
2 - je déclare GLOBAL un membre de F1
-> je peux y accèder dans le code de F2 (F1:membres_quelconque) et le
modifier.
Toutefois, je ne comprend pas la nuance entre les deux synthaxes. Dans
le premier cas, il semble que oF2:mobjF1 soit une copie de l'instance de
F1 laquelle disparait avec la libération de l'instance de F2.
Dans le second cas, je ne fais pas de référence à l'instance de F1. Que se passe
t-il si je dois distinguer plusieurs instances ? Le fait de déclarer un
membre GLOBAL dans F1 implique t-il que la modification de ce membre
dans une instance quelconque modifira le membre dans toutes les
instances comme le laisse supposer la doc ?
> Ca fonctionne :-)))
Merci beaucoup de ta réponse !
Si ce n'est pas abuser, pourrais-tu me donner plus de précision sur
> Perso, je prefere passer les paramètres en les typant, ce
> qui permet de retrouver l'aide à la saisie.
D'autre part, j'ai testé les deux cas de figure suivant :
1 - je créé un membre mobjF1 dans la classe F2 qui reçoit oF1 en
paramètre constructeur F2.
-> je peux utiliser les membres :mobjF1:membres_quelconque, j'imagine
aussi les méthodes(pas encore testé), mais je ne peux pas modifier
:mobjF1:membres_quelconque dans le code de F2
2 - je déclare GLOBAL un membre de F1
-> je peux y accèder dans le code de F2 (F1:membres_quelconque) et le
modifier.
Toutefois, je ne comprend pas la nuance entre les deux synthaxes. Dans
le premier cas, il semble que oF2:mobjF1 soit une copie de l'instance de
F1 laquelle disparait avec la libération de l'instance de F2.
Dans le second cas, je ne fais pas de référence à l'instance de F1. Que se passe
t-il si je dois distinguer plusieurs instances ? Le fait de déclarer un
membre GLOBAL dans F1 implique t-il que la modification de ce membre
dans une instance quelconque modifira le membre dans toutes les
instances comme le laisse supposer la doc ?
> Ca fonctionne :-)))
Merci beaucoup de ta réponse !
Si ce n'est pas abuser, pourrais-tu me donner plus de précision sur
> Perso, je prefere passer les paramètres en les typant, ce
> qui permet de retrouver l'aide à la saisie.
D'autre part, j'ai testé les deux cas de figure suivant :
1 - je créé un membre mobjF1 dans la classe F2 qui reçoit oF1 en
paramètre constructeur F2.
-> je peux utiliser les membres :mobjF1:membres_quelconque, j'imagine
aussi les méthodes(pas encore testé), mais je ne peux pas modifier
:mobjF1:membres_quelconque dans le code de F2
2 - je déclare GLOBAL un membre de F1
-> je peux y accèder dans le code de F2 (F1:membres_quelconque) et le
modifier.
Toutefois, je ne comprend pas la nuance entre les deux synthaxes. Dans
le premier cas, il semble que oF2:mobjF1 soit une copie de l'instance de
F1 laquelle disparait avec la libération de l'instance de F2.
Dans le second cas, je ne fais pas de référence à l'instance de F1. Que se passe
t-il si je dois distinguer plusieurs instances ? Le fait de déclarer un
membre GLOBAL dans F1 implique t-il que la modification de ce membre
dans une instance quelconque modifira le membre dans toutes les
instances comme le laisse supposer la doc ?
Ca fonctionne :-)))
Ben oui ;-)
Merci beaucoup de ta réponse !
Pas de quoi !
Si ce n'est pas abuser, pourrais-tu me donner plus de précision sur
On est la pour ça :-)
> Perso, je prefere passer les paramètres en les typant, ce
> qui permet de retrouver l'aide à la saisie.
Ca signifie que dans le code "Initialisation de la Fenêtre Fen2"
j'ai : Procedure Fen2( pObj1 est un tClasse1)
Ensuite quand tu accèdes à pObj1 dans Fen2 (et ce partout dans Fen2,
les paramètres passés à une fenêtre etant considérés comme global à
toute la fenêtre), en faison pObj1: ( la tu as la fen d'aide à la saisie
qui te donnes toutes les propriètés et méthodes de la classe).
D'autre part, j'ai testé les deux cas de figure suivant :
1 - je créé un membre mobjF1 dans la classe F2 qui reçoit oF1 en
paramètre constructeur F2.
-> je peux utiliser les membres :mobjF1:membres_quelconque, j'imagine
aussi les méthodes(pas encore testé), mais je ne peux pas modifier
:mobjF1:membres_quelconque dans le code de F2
La je ne comprend pas ! Normalement tu dois pouvoir, sauf si
tes propriétes sont privées ou protégées. Dans ce cas, effectivement
seules les méthodes de ta classe F1 peuvent modifier ces propriétés.
2 - je déclare GLOBAL un membre de F1
-> je peux y accèder dans le code de F2 (F1:membres_quelconque) et le
modifier.
En déclarant F1 en Global, tu le rends disponible pour tout les codes
qui viennent ensuite.
Toutefois, je ne comprend pas la nuance entre les deux synthaxes. Dans
le premier cas, il semble que oF2:mobjF1 soit une copie de l'instance
de F1 laquelle disparait avec la libération de l'instance de F2.
C'est comme ca que je l'interprete aussi.Dans le second cas, je ne fais pas de référence à l'instance de F1.
Que se passe t-il si je dois distinguer plusieurs instances ? Le fait
de déclarer un membre GLOBAL dans F1 implique t-il que la modification
de ce membre dans une instance quelconque modifira le membre dans
toutes les instances comme le laisse supposer la doc ?
C'est cela.
Tout dépend de ce que tu veux faire.
Si tu veux pouvoir avoir plusieurs instances de F2, ayant chacun son F1
et pouvant le modifier, sans que cela soit répercuter sur l'instance
principale, alors je te conseille de passer par des objets dynamiques
inclus dans la classe et allouer dans le constructeur ( et liberer dans
le destructeur)
Ex
F2 est une classe
membres...
M_ObjF1 est un F1 dynamique
Fin
Constructeur F2( ParamF1 est un F1)
:M_ObjF1 = allouer un F1( les parametres du constructeur de F1)
//Ensuite initialiser les membres de m_ObjF1 avec ceus de ParamF1
:M_ObjF1:Membre1 = ParamF1:Membre1
ect...
fin
Destrcuteur de F2
liberer( :M_ObjF1)
fin
Note : L'idéal est que le constructeur de F1 initialise chacun de ses
membres.
Note2 : L'autre possibilité est de créer une méthode (IE : Assign, ca
vient du Delphi) et le constructeur ne contient que peu ou pas de param.
F1:Assign( unF1)
:Membre1 = unF1:Membre1
et cela pour chaque membre
Le constructeur de F2 deviendrait alors
:M_ObjF1 = allouer un F1( )
//Ensuite initialiser les membres de m_ObjF1 avec ceus de ParamF1
:M_ObjF1:Assign( ParamF1)
Voila, j'espere avoir répondu correctement,
si tu as d'autres questions... Je suis en vacances
ce soir, alors fais vite ;-)
Ca fonctionne :-)))
Ben oui ;-)
Merci beaucoup de ta réponse !
Pas de quoi !
Si ce n'est pas abuser, pourrais-tu me donner plus de précision sur
On est la pour ça :-)
> Perso, je prefere passer les paramètres en les typant, ce
> qui permet de retrouver l'aide à la saisie.
Ca signifie que dans le code "Initialisation de la Fenêtre Fen2"
j'ai : Procedure Fen2( pObj1 est un tClasse1)
Ensuite quand tu accèdes à pObj1 dans Fen2 (et ce partout dans Fen2,
les paramètres passés à une fenêtre etant considérés comme global à
toute la fenêtre), en faison pObj1: ( la tu as la fen d'aide à la saisie
qui te donnes toutes les propriètés et méthodes de la classe).
D'autre part, j'ai testé les deux cas de figure suivant :
1 - je créé un membre mobjF1 dans la classe F2 qui reçoit oF1 en
paramètre constructeur F2.
-> je peux utiliser les membres :mobjF1:membres_quelconque, j'imagine
aussi les méthodes(pas encore testé), mais je ne peux pas modifier
:mobjF1:membres_quelconque dans le code de F2
La je ne comprend pas ! Normalement tu dois pouvoir, sauf si
tes propriétes sont privées ou protégées. Dans ce cas, effectivement
seules les méthodes de ta classe F1 peuvent modifier ces propriétés.
2 - je déclare GLOBAL un membre de F1
-> je peux y accèder dans le code de F2 (F1:membres_quelconque) et le
modifier.
En déclarant F1 en Global, tu le rends disponible pour tout les codes
qui viennent ensuite.
Toutefois, je ne comprend pas la nuance entre les deux synthaxes. Dans
le premier cas, il semble que oF2:mobjF1 soit une copie de l'instance
de F1 laquelle disparait avec la libération de l'instance de F2.
C'est comme ca que je l'interprete aussi.
Dans le second cas, je ne fais pas de référence à l'instance de F1.
Que se passe t-il si je dois distinguer plusieurs instances ? Le fait
de déclarer un membre GLOBAL dans F1 implique t-il que la modification
de ce membre dans une instance quelconque modifira le membre dans
toutes les instances comme le laisse supposer la doc ?
C'est cela.
Tout dépend de ce que tu veux faire.
Si tu veux pouvoir avoir plusieurs instances de F2, ayant chacun son F1
et pouvant le modifier, sans que cela soit répercuter sur l'instance
principale, alors je te conseille de passer par des objets dynamiques
inclus dans la classe et allouer dans le constructeur ( et liberer dans
le destructeur)
Ex
F2 est une classe
membres...
M_ObjF1 est un F1 dynamique
Fin
Constructeur F2( ParamF1 est un F1)
:M_ObjF1 = allouer un F1( les parametres du constructeur de F1)
//Ensuite initialiser les membres de m_ObjF1 avec ceus de ParamF1
:M_ObjF1:Membre1 = ParamF1:Membre1
ect...
fin
Destrcuteur de F2
liberer( :M_ObjF1)
fin
Note : L'idéal est que le constructeur de F1 initialise chacun de ses
membres.
Note2 : L'autre possibilité est de créer une méthode (IE : Assign, ca
vient du Delphi) et le constructeur ne contient que peu ou pas de param.
F1:Assign( unF1)
:Membre1 = unF1:Membre1
et cela pour chaque membre
Le constructeur de F2 deviendrait alors
:M_ObjF1 = allouer un F1( )
//Ensuite initialiser les membres de m_ObjF1 avec ceus de ParamF1
:M_ObjF1:Assign( ParamF1)
Voila, j'espere avoir répondu correctement,
si tu as d'autres questions... Je suis en vacances
ce soir, alors fais vite ;-)
Ca fonctionne :-)))
Ben oui ;-)
Merci beaucoup de ta réponse !
Pas de quoi !
Si ce n'est pas abuser, pourrais-tu me donner plus de précision sur
On est la pour ça :-)
> Perso, je prefere passer les paramètres en les typant, ce
> qui permet de retrouver l'aide à la saisie.
Ca signifie que dans le code "Initialisation de la Fenêtre Fen2"
j'ai : Procedure Fen2( pObj1 est un tClasse1)
Ensuite quand tu accèdes à pObj1 dans Fen2 (et ce partout dans Fen2,
les paramètres passés à une fenêtre etant considérés comme global à
toute la fenêtre), en faison pObj1: ( la tu as la fen d'aide à la saisie
qui te donnes toutes les propriètés et méthodes de la classe).
D'autre part, j'ai testé les deux cas de figure suivant :
1 - je créé un membre mobjF1 dans la classe F2 qui reçoit oF1 en
paramètre constructeur F2.
-> je peux utiliser les membres :mobjF1:membres_quelconque, j'imagine
aussi les méthodes(pas encore testé), mais je ne peux pas modifier
:mobjF1:membres_quelconque dans le code de F2
La je ne comprend pas ! Normalement tu dois pouvoir, sauf si
tes propriétes sont privées ou protégées. Dans ce cas, effectivement
seules les méthodes de ta classe F1 peuvent modifier ces propriétés.
2 - je déclare GLOBAL un membre de F1
-> je peux y accèder dans le code de F2 (F1:membres_quelconque) et le
modifier.
En déclarant F1 en Global, tu le rends disponible pour tout les codes
qui viennent ensuite.
Toutefois, je ne comprend pas la nuance entre les deux synthaxes. Dans
le premier cas, il semble que oF2:mobjF1 soit une copie de l'instance
de F1 laquelle disparait avec la libération de l'instance de F2.
C'est comme ca que je l'interprete aussi.Dans le second cas, je ne fais pas de référence à l'instance de F1.
Que se passe t-il si je dois distinguer plusieurs instances ? Le fait
de déclarer un membre GLOBAL dans F1 implique t-il que la modification
de ce membre dans une instance quelconque modifira le membre dans
toutes les instances comme le laisse supposer la doc ?
C'est cela.
Tout dépend de ce que tu veux faire.
Si tu veux pouvoir avoir plusieurs instances de F2, ayant chacun son F1
et pouvant le modifier, sans que cela soit répercuter sur l'instance
principale, alors je te conseille de passer par des objets dynamiques
inclus dans la classe et allouer dans le constructeur ( et liberer dans
le destructeur)
Ex
F2 est une classe
membres...
M_ObjF1 est un F1 dynamique
Fin
Constructeur F2( ParamF1 est un F1)
:M_ObjF1 = allouer un F1( les parametres du constructeur de F1)
//Ensuite initialiser les membres de m_ObjF1 avec ceus de ParamF1
:M_ObjF1:Membre1 = ParamF1:Membre1
ect...
fin
Destrcuteur de F2
liberer( :M_ObjF1)
fin
Note : L'idéal est que le constructeur de F1 initialise chacun de ses
membres.
Note2 : L'autre possibilité est de créer une méthode (IE : Assign, ca
vient du Delphi) et le constructeur ne contient que peu ou pas de param.
F1:Assign( unF1)
:Membre1 = unF1:Membre1
et cela pour chaque membre
Le constructeur de F2 deviendrait alors
:M_ObjF1 = allouer un F1( )
//Ensuite initialiser les membres de m_ObjF1 avec ceus de ParamF1
:M_ObjF1:Assign( ParamF1)
Voila, j'espere avoir répondu correctement,
si tu as d'autres questions... Je suis en vacances
ce soir, alors fais vite ;-)
Pascal R. a écrit :Ca fonctionne :-)))
Ben oui ;-)
Merci beaucoup de ta réponse !
Pas de quoi !
Si ce n'est pas abuser, pourrais-tu me donner plus de précision sur
On est la pour ça :-)
> Perso, je prefere passer les paramètres en les typant, ce
> qui permet de retrouver l'aide à la saisie.
Ca signifie que dans le code "Initialisation de la Fenêtre Fen2"
j'ai : Procedure Fen2( pObj1 est un tClasse1)
Ensuite quand tu accèdes à pObj1 dans Fen2 (et ce partout dans Fen2,
les paramètres passés à une fenêtre etant considérés comme global à
toute la fenêtre), en faison pObj1: ( la tu as la fen d'aide à la saisie
qui te donnes toutes les propriètés et méthodes de la classe).
D'autre part, j'ai testé les deux cas de figure suivant :
1 - je créé un membre mobjF1 dans la classe F2 qui reçoit oF1 en
paramètre constructeur F2.
-> je peux utiliser les membres :mobjF1:membres_quelconque, j'imagine
aussi les méthodes(pas encore testé), mais je ne peux pas modifier
:mobjF1:membres_quelconque dans le code de F2
La je ne comprend pas ! Normalement tu dois pouvoir, sauf si
tes propriétes sont privées ou protégées. Dans ce cas, effectivement
seules les méthodes de ta classe F1 peuvent modifier ces propriétés.
2 - je déclare GLOBAL un membre de F1
-> je peux y accèder dans le code de F2 (F1:membres_quelconque) et le
modifier.
En déclarant F1 en Global, tu le rends disponible pour tout les codes
qui viennent ensuite.
Toutefois, je ne comprend pas la nuance entre les deux synthaxes.
Dans le premier cas, il semble que oF2:mobjF1 soit une copie de
l'instance de F1 laquelle disparait avec la libération de l'instance
de F2.
C'est comme ca que je l'interprete aussi.Dans le second cas, je ne fais pas de référence à l'instance de F1.
Que se passe t-il si je dois distinguer plusieurs instances ? Le fait
de déclarer un membre GLOBAL dans F1 implique t-il que la
modification de ce membre dans une instance quelconque modifira le
membre dans toutes les instances comme le laisse supposer la doc ?
C'est cela.
Tout dépend de ce que tu veux faire.
Si tu veux pouvoir avoir plusieurs instances de F2, ayant chacun son F1
et pouvant le modifier, sans que cela soit répercuter sur l'instance
principale, alors je te conseille de passer par des objets dynamiques
inclus dans la classe et allouer dans le constructeur ( et liberer dans
le destructeur)
Ex
F2 est une classe
membres...
M_ObjF1 est un F1 dynamique
Fin
Constructeur F2( ParamF1 est un F1)
:M_ObjF1 = allouer un F1( les parametres du constructeur de F1)
//Ensuite initialiser les membres de m_ObjF1 avec ceus de ParamF1
:M_ObjF1:Membre1 = ParamF1:Membre1
ect...
fin
Destrcuteur de F2
liberer( :M_ObjF1)
fin
Note : L'idéal est que le constructeur de F1 initialise chacun de ses
membres.
Note2 : L'autre possibilité est de créer une méthode (IE : Assign, ca
vient du Delphi) et le constructeur ne contient que peu ou pas de param.
F1:Assign( unF1)
:Membre1 = unF1:Membre1
et cela pour chaque membre
Le constructeur de F2 deviendrait alors
:M_ObjF1 = allouer un F1( )
//Ensuite initialiser les membres de m_ObjF1 avec ceus de ParamF1
:M_ObjF1:Assign( ParamF1)
Voila, j'espere avoir répondu correctement,
si tu as d'autres questions... Je suis en vacances
ce soir, alors fais vite ;-)
Merci beaucoup pour toutes ces précisions qu'il me faut maintenant
digérer ;-)
Bonnes vacances à toi !
Pascal R. a écrit :
Ca fonctionne :-)))
Ben oui ;-)
Merci beaucoup de ta réponse !
Pas de quoi !
Si ce n'est pas abuser, pourrais-tu me donner plus de précision sur
On est la pour ça :-)
> Perso, je prefere passer les paramètres en les typant, ce
> qui permet de retrouver l'aide à la saisie.
Ca signifie que dans le code "Initialisation de la Fenêtre Fen2"
j'ai : Procedure Fen2( pObj1 est un tClasse1)
Ensuite quand tu accèdes à pObj1 dans Fen2 (et ce partout dans Fen2,
les paramètres passés à une fenêtre etant considérés comme global à
toute la fenêtre), en faison pObj1: ( la tu as la fen d'aide à la saisie
qui te donnes toutes les propriètés et méthodes de la classe).
D'autre part, j'ai testé les deux cas de figure suivant :
1 - je créé un membre mobjF1 dans la classe F2 qui reçoit oF1 en
paramètre constructeur F2.
-> je peux utiliser les membres :mobjF1:membres_quelconque, j'imagine
aussi les méthodes(pas encore testé), mais je ne peux pas modifier
:mobjF1:membres_quelconque dans le code de F2
La je ne comprend pas ! Normalement tu dois pouvoir, sauf si
tes propriétes sont privées ou protégées. Dans ce cas, effectivement
seules les méthodes de ta classe F1 peuvent modifier ces propriétés.
2 - je déclare GLOBAL un membre de F1
-> je peux y accèder dans le code de F2 (F1:membres_quelconque) et le
modifier.
En déclarant F1 en Global, tu le rends disponible pour tout les codes
qui viennent ensuite.
Toutefois, je ne comprend pas la nuance entre les deux synthaxes.
Dans le premier cas, il semble que oF2:mobjF1 soit une copie de
l'instance de F1 laquelle disparait avec la libération de l'instance
de F2.
C'est comme ca que je l'interprete aussi.
Dans le second cas, je ne fais pas de référence à l'instance de F1.
Que se passe t-il si je dois distinguer plusieurs instances ? Le fait
de déclarer un membre GLOBAL dans F1 implique t-il que la
modification de ce membre dans une instance quelconque modifira le
membre dans toutes les instances comme le laisse supposer la doc ?
C'est cela.
Tout dépend de ce que tu veux faire.
Si tu veux pouvoir avoir plusieurs instances de F2, ayant chacun son F1
et pouvant le modifier, sans que cela soit répercuter sur l'instance
principale, alors je te conseille de passer par des objets dynamiques
inclus dans la classe et allouer dans le constructeur ( et liberer dans
le destructeur)
Ex
F2 est une classe
membres...
M_ObjF1 est un F1 dynamique
Fin
Constructeur F2( ParamF1 est un F1)
:M_ObjF1 = allouer un F1( les parametres du constructeur de F1)
//Ensuite initialiser les membres de m_ObjF1 avec ceus de ParamF1
:M_ObjF1:Membre1 = ParamF1:Membre1
ect...
fin
Destrcuteur de F2
liberer( :M_ObjF1)
fin
Note : L'idéal est que le constructeur de F1 initialise chacun de ses
membres.
Note2 : L'autre possibilité est de créer une méthode (IE : Assign, ca
vient du Delphi) et le constructeur ne contient que peu ou pas de param.
F1:Assign( unF1)
:Membre1 = unF1:Membre1
et cela pour chaque membre
Le constructeur de F2 deviendrait alors
:M_ObjF1 = allouer un F1( )
//Ensuite initialiser les membres de m_ObjF1 avec ceus de ParamF1
:M_ObjF1:Assign( ParamF1)
Voila, j'espere avoir répondu correctement,
si tu as d'autres questions... Je suis en vacances
ce soir, alors fais vite ;-)
Merci beaucoup pour toutes ces précisions qu'il me faut maintenant
digérer ;-)
Bonnes vacances à toi !
Pascal R. a écrit :Ca fonctionne :-)))
Ben oui ;-)
Merci beaucoup de ta réponse !
Pas de quoi !
Si ce n'est pas abuser, pourrais-tu me donner plus de précision sur
On est la pour ça :-)
> Perso, je prefere passer les paramètres en les typant, ce
> qui permet de retrouver l'aide à la saisie.
Ca signifie que dans le code "Initialisation de la Fenêtre Fen2"
j'ai : Procedure Fen2( pObj1 est un tClasse1)
Ensuite quand tu accèdes à pObj1 dans Fen2 (et ce partout dans Fen2,
les paramètres passés à une fenêtre etant considérés comme global à
toute la fenêtre), en faison pObj1: ( la tu as la fen d'aide à la saisie
qui te donnes toutes les propriètés et méthodes de la classe).
D'autre part, j'ai testé les deux cas de figure suivant :
1 - je créé un membre mobjF1 dans la classe F2 qui reçoit oF1 en
paramètre constructeur F2.
-> je peux utiliser les membres :mobjF1:membres_quelconque, j'imagine
aussi les méthodes(pas encore testé), mais je ne peux pas modifier
:mobjF1:membres_quelconque dans le code de F2
La je ne comprend pas ! Normalement tu dois pouvoir, sauf si
tes propriétes sont privées ou protégées. Dans ce cas, effectivement
seules les méthodes de ta classe F1 peuvent modifier ces propriétés.
2 - je déclare GLOBAL un membre de F1
-> je peux y accèder dans le code de F2 (F1:membres_quelconque) et le
modifier.
En déclarant F1 en Global, tu le rends disponible pour tout les codes
qui viennent ensuite.
Toutefois, je ne comprend pas la nuance entre les deux synthaxes.
Dans le premier cas, il semble que oF2:mobjF1 soit une copie de
l'instance de F1 laquelle disparait avec la libération de l'instance
de F2.
C'est comme ca que je l'interprete aussi.Dans le second cas, je ne fais pas de référence à l'instance de F1.
Que se passe t-il si je dois distinguer plusieurs instances ? Le fait
de déclarer un membre GLOBAL dans F1 implique t-il que la
modification de ce membre dans une instance quelconque modifira le
membre dans toutes les instances comme le laisse supposer la doc ?
C'est cela.
Tout dépend de ce que tu veux faire.
Si tu veux pouvoir avoir plusieurs instances de F2, ayant chacun son F1
et pouvant le modifier, sans que cela soit répercuter sur l'instance
principale, alors je te conseille de passer par des objets dynamiques
inclus dans la classe et allouer dans le constructeur ( et liberer dans
le destructeur)
Ex
F2 est une classe
membres...
M_ObjF1 est un F1 dynamique
Fin
Constructeur F2( ParamF1 est un F1)
:M_ObjF1 = allouer un F1( les parametres du constructeur de F1)
//Ensuite initialiser les membres de m_ObjF1 avec ceus de ParamF1
:M_ObjF1:Membre1 = ParamF1:Membre1
ect...
fin
Destrcuteur de F2
liberer( :M_ObjF1)
fin
Note : L'idéal est que le constructeur de F1 initialise chacun de ses
membres.
Note2 : L'autre possibilité est de créer une méthode (IE : Assign, ca
vient du Delphi) et le constructeur ne contient que peu ou pas de param.
F1:Assign( unF1)
:Membre1 = unF1:Membre1
et cela pour chaque membre
Le constructeur de F2 deviendrait alors
:M_ObjF1 = allouer un F1( )
//Ensuite initialiser les membres de m_ObjF1 avec ceus de ParamF1
:M_ObjF1:Assign( ParamF1)
Voila, j'espere avoir répondu correctement,
si tu as d'autres questions... Je suis en vacances
ce soir, alors fais vite ;-)
Merci beaucoup pour toutes ces précisions qu'il me faut maintenant
digérer ;-)
Bonnes vacances à toi !