tableau de variables dans une fonction afin de les schtroumpfer sans pointeurs .

Question

Salut a tous!

aller autant faire le boulet jusqu'au bout en postant dans la tristement celebre rubrique "BORDELAYARGLAFOUK".

j'ai recement rencontrer un probleme dans l'elaboration d'une fonction.

cette fonction permet de schtroumpfer plusieurs booleans en meme temps a une valeur donn&#233;e par un parametre.
vous avez bien lus, cette fonction schtroumpf les booleans.

j'ai appeler cette methode la methode Schtroumpf, car il est plus facile de la definir en langage Schtroumpf qu'en fran&#231;ais.

et a la question que vous poserez : "elle fait quoi ?" 
je repondrais : "ele schtroumpf les booleans..."

1er cas :

function Schtroumpfise(Bool : array of boolean; const value : boolmode = bmTrue);

j'injecte des variables globale ou meme locale dans ma fonction qu'elle soit boolean ou type array of boolean

Schtroumpfise([b1,b2,b3]);

pouf ... rien n'est modifier. sUx!

ma solution :

type
   PasGlop : ^boolean;

function Schtroumpfise(const bool : array of PasGlop; const value : boolmode = bmtrue);

probleme :

je doit forcement injecter avec cette syntaxe ... logique...

Schtroumpfise([@b1,@b2,@b3]);

cette fonction, fonctionne c'est le cas de le dire, et mes booleans sont bien schtroumpf&#233;s ...
mais j'aimerais savoir pourquoi je suis oblig&#233; de pass&#233; par des pointeurs.

j'aimerais ne pas utiliser de pointeurs pour eviter que delphiprog ou d'autre viennent me dire "oui mais .net ceci cela", 
si quelqu'un a la solution ... 
je cherche mais je provoque que des erreurs de compil. 
je n'y arrive tout simplement paaaaas.

la ma signature colle parfaitement a mon probleme... 

vus qu'en pratique il est possible de passer une variable dans une fonction et que cette fonction modifie cette variable.

vus qu'en theorie il doit etre possible de passer des variables en tableau dans une fonction et que cette fonction puisse modifier les variables contenue dans le tableau.

vus qu'en pratique la theorie sus-cit&#233;e ne fonctionne pas avec ma methode qui pourtant en theorie devrait fonctionn&#233;e ce qui me resoud a utiliser des pointeurs ce qui n'est pas forcement pratique dans la pratique.

 La theorie c'est quand on sait tout, mais que rien ne fonctionne.
La pratique c'est quand tout fonctionne, mais que personne ne sait pourquoi.
<hr>

jlen100 · Answer

salut f0xi

1er tu d&#233;clare une fonction mais tu ne renvoie pas de resultat dans ce cas passe par une procedure ce sera plus logique

2e tu passes bool en constante comme argument ---> les valeurs sont
copi&#233;es dans l'espace de travail mais pas retroun&#233;es si tu veux
qu'elles soient retourn&#233;es passent les en variables:

procedure Schtroumpfise( var 
Bool : array of boolean; const value : boolmode = bmTrue);

l&#224; je pense que &#231;a devrait marcher

@+

jlen

jlen100 · Answer

au fait en passant tes paramatres par pointeurs DELPHI copie ces
parametres en espace de travail et les uitilise comme pointeurs il va
donc modifier les variables &#224; l'adresse contenue dans le pointeur il
est donc logique dans ce cas que les variables soient modifi&#233;e.
Maintenant tant on passe des parametres par variable DELPHI ne transmet
que l'adresse de la variable et affecte directement les r&#233;sultats &#224; ces
variables ce qui revient exactement &#224; ce que tu fais en passant les
pointeurs.

@+

jlen

cs_Kenavo · Answer

C'est l&#224; d'ailleurs tout l'int&#233;r&#234;t du mot cl&#233; var qui permet de dissimuler le m&#233;canisme du passage des variables (par valeur ou par adresse) tel qu'on peut le conna&#238;tre en C. 

L'inconv&#233;nient de cette facilit&#233; est que nombreux sont les programateurs Pascal qui ignorent les pointeurs !

Ken@vo

 Code, Code, Codec !

[%3C/body ]

Cirec · Answer

Salut f0xi,
L'abus de stroumpf est dangereux pour la sant&#233; 

pour la r&#233;ponse jlen100 &#224; mis le doigt dessus remplace le mot r&#233;serv&#233; Const par Var et le tour est jou&#233; 
Ex:
Var XX : Integer =  20;
 Procedure  Stroumpf (Const x : Integer);
Begin  X : 50 * 2 ; //  100
 End ;

si tu fais Stroumpf ( XX); 
XX restera &#224; 20.

Par contre
Var XX : Integer  = 20;
Procedure Stroumpf (Var x : Integer);
Begin  X :50 * 2 ; // 100
End;

l&#224; si tu fais Stroumpf ( XX); 
XX aura comme valeur  100.

@+
Cirec

f0xi · Answer

hola en effet, j'ai bug&#233; a la restranscription memorielle.

c'est une procedure et non une fonction ... plop

ensuite :

VAR BOOL : ARRAY OF BOOLEAN

voila ce qu'il me renvois le bougre : Un objet constante ne peut etre pass&#233; comme parametre Var ...
no comment.


apparement Array n'accepte que des constantes et pas de variable donc
impossible de passer une variable dans un tableau en pensant que celle
ci pourrat etre modifi&#233;e sans utiliser les pointeurs. 


faut savoir si quand je declare :



VAR 

   VAR1 : boolean;



VAR1 est une constante ou une variable ... pfff... la c'est trop nul ...

c'est logique ... quand on declare VAR c'est forcement une constante ... on se demande meme a quoi &#231;a sert la declaration CONST a ce moment... 

j'ai essayer :

VAR BOOL
CONST BOOL
BOOL tout court

et meme :

var bool : array of var boolean < pffff lol
const bool : array of var < re lol
bool : array of TuMeCasseLesBool < marche pas, type inconnus
bool : array of CoupDBool < pareil...

donc seule soluce, array of pointeur

j'ai meme essayer (bool[x] as Boolean) := value ... pouf &#231;a marche pas non plus.

bon aller, je laisse ma methode en pointeur et au diable .Net.

alors apr&#233;s quelque reflexion :

quand j'ecris :

SetBooleans([var1,var2,var3]); 

reviens a ecrire 

SetBooleans([true,false,true]); // par exemple

donc on ne peu pas modifier les variables ... donc pointeurs. PAAAAAR contre, si j'utilise une variable Array of boolean (grace a un type array of boolean), elle serat bien modifi&#233;e car elle passe en parametre VAR.

en faitje geule mais c'est tr&#233;s logique. 

c'est juste qu'il n'existe pas de Array of Var.

 La theorie c'est quand on sait tout, mais que rien ne fonctionne.
La pratique c'est quand tout fonctionne, mais que personne ne sait pourquoi.
<hr>

f0xi · Answer

et pour finir, que j'ai oublier en fait :

quand j'ecris : 

procedure SetBooleans(var Bool : Array of boolean ....);

et que j'apel comme &#231;a :

setbooleans([var1,var2,var3]);

Bool correspond bien a [var1,var2,var3] mais ne pointe pas sur les variables var1, var2 et var3 
vus que les valeurs de ces variables sont affect&#233;e au tableau Bool. (vous me suivez ?)

donc point de vue adresse memoire, quand j'assigne une valeur a Bool[x], il envois cette valeur partout sauf dans Var1, var2 ou var3 vus qu'il ne pointe pas dessus mais sur Bool lui meme.

si j'utilise des pointeurs par contre, l'adresse memoire des valeurs de Bool devient l'adresse memoire de mes variables et donc la modification devient possible.

par contre comme j'ai dit tout a l'heure, si je passe une variable de type  array of boolean en arguments, var bool pointeras bien sur cette variable et donc l'affectation a Bool[x] reviendras a affecter directement a Varb[x]

donc c'est bien ce que je disais tout a l'heure, il manque un "Array of var" dans delphi ... 
pourtant "array of const" existe alors pourquoi pas &#231;a!?

et cela n'est pas seulement specifique au type boolean mais egalement aux autre.

alors il faudrait trouver une solution pour pouvoir avoir un equivalent pratique du theorique "array of var type"

sans pointeur ... &#231;a risque de pas etre possible.

 La theorie c'est quand on sait tout, mais que rien ne fonctionne.
La pratique c'est quand tout fonctionne, mais que personne ne sait pourquoi.
<hr>

Cirec · Answer

J&#146;avoue que j'ai un peut de mal &#224; te suivre 

pourrais-tu m'envoyer cette partie de code qui te fait souffrir  cela m'int&#233;resserai beaucoup

@+
Cirec

jlen100 · Answer

bon voil&#224; ce que j'ai test&#233; et apparament &#231;a marche:

var

  Form1: TForm1;

  bool:array of boolean;



implementation



{$R *.dfm}

procedure Schtroumpfise( var bool:array of boolean;  value : boolean);

var i:integer;

begin

for i:=0 to 8 do// l&#224; je ne me suis pas emm...

bool[i]:=value ;

end;





procedure TForm1.Button1Click(Sender: TObject);

begin

setlength(bool,10);

Schtroumpfise(bool,checkbox1.Checked);

if bool[2]then edit1.text:='vrai' else edit1.Text:='faux';//et l&#224; non plus d'ailleurs!!



end;

f0xi · Answer

alors oui JLen, no probleme quand tu utilise un tableau &#231;a c'est bon.

le probleme c'est quand tu fait :

var
var1, var2, var3 : boolean;

init des boolean
et

SetBooleans([var1,var2,var3]);

et pouf &#231;a marche pas.

donc obliger de travailler avec des pointeurs... c'est presque normal en fait plus j'y pense.

par contre, oblig&#233; de cr&#233;er un type TArBoolean = array of boolean pour eviter les apels ambigus a SetBooleans que j'ai overloader sur une version pour les tableau type TArBoolean et une autre pour les Pointeurs.

car je rapel que SetBooleans permet d'assigner en une seule declaration la meme valeur bool&#233;ene a plusieurs variable boolean.

tr&#233;s utile quand on a beaucoup de variable de control de ce type par exemple a initialis&#233; a False ou True ce qui me fait gagner du temps.
procedure declin&#233;e egalement pour pouvoir travailler sur les propri&#233;t&#233;s Enabled, Visible, Checked des objet de type TControl, TCheckBox, TRadioButton, TCheckListBox ect... ect...
(procedure qui elles fonctionne parfaitement sans pointeurs et sans "var")

@cirec : je pense pasque le code soit vraiment utile, mais si tu y tiens :

interface

type
  BoolMode   = (bmTrue,bmFalse,bmSwap);
  pBool      = ^boolean;
  TArBoolean = array of boolean;

implementation

procedure SetBooleans(const bool: array of pBool; const Value: BoolMode= bmTrue);
var x : integer;
begin
  for x := 0 to length(bool)-1 do
      case value of
         bmTrue : bool[x]^ := true;
         bmFalse: bool[x]^ := false;
         bmSwap : bool[x]^ := NOT bool[x]^;
      end;
end;

procedure SetBooleans(var bool: TArBoolean; const Value: BoolMode= bmTrue);
var x : integer;
begin
  for x := 0 to length(bool)-1 do
      case value of
         bmTrue : bool[x] := true;
         bmFalse: bool[x] := false;
         bmSwap : bool[x] := NOT bool[x];
      end;
end;

 La theorie c'est quand on sait tout, mais que rien ne fonctionne.
La pratique c'est quand tout fonctionne, mais que personne ne sait pourquoi.
<hr>

jlen100 · Answer

ton probleme si j'ai tout compris c'est que var1, var2, var3 sont des
variables independantes et possedent donc des adresses qui ne sont pas
forc&#233;ment contigues. Or DELPHi (comme tout autre langage d'ailleurs) &#224;
besoin que les adresses des variables soient contigues pour pouvoir
g&#233;rer les index de tableau (en fait des pointeurs) ce qui rend
impossible les structures du type array of var ce qui oblige &#224; passer
par les addresses des variables Une  fa&#231;on de passer une liste de
variables ind&#233;pendantes serait de cr&#233;er une Tlist (qui est un tableau
de pointeurs)et de la passer en param&#232;tres mais l&#224; aussi on repasse par
les pointeurs.

cs_Kenavo · Answer

f0xi

Ton truc, c'est comme si avec une proc&#233;dure :




procedure Double(var a : integer);

begin

  a:= a*2;

 end ;

//on appelle :


Double(5);



... Un objet constante ne peut etre pass&#233; comme parametre Var ...



Dans ton cas, le tableau [b1,b2,b3] est une constante (m&#234;me si ses &#233;l&#233;ments sont des variables).



et taper :



  SetLength(UnBool,3);     // UnBool  = array of boolean

  UnBool[0] :=  b1;

  UnBool[1] := b2;

  UnBool[2] := b3;

  Schtroumpfise(UnBool);   // procedure Schtroumpfise(var Bool : array of boolean);


  b1 := UnBool[0];

  b2 := UnBool[1];

  b3 := UnBool[2];



ne simplifie pas l'&#233;criture



Ta solution (table de pointeurs sur boolean) me semble la plus l&#233;g&#232;re
(qu'en pensera Delphiprog ?). J'y retrouve mes quelques souvenirs du C
o&#249;  var  n'existant pas, il faut toujours passer le pointeur lors
du passage de param&#232;tres que l'on d&#233;sire variables (on ne passe que des
valeurs en C) 

 

Ken@vo

<hr size ="2" width="100%">Code, Code, Codec !

[%3C/body ]

f0xi · Answer

voila tu as tout compris.

en fait je penser que le probleme pouvais etre resolus sans l'utilisation des pointeurs ce qui semble totalement impossible dans le cas present.

merci a tous pour votre participations, toute nouvelle suggestions sont bien sur les bienvenues.

 La theorie c'est quand on sait tout, mais que rien ne fonctionne.
La pratique c'est quand tout fonctionne, mais que personne ne sait pourquoi.
<hr>

cs_Kenavo · Answer

Il est
vrai qu'un Array of Var (comme tu dit) aurait la couleur du Pascal,
tout en &#233;tant en r&#233;alit&#233; un Array of Pointer (ce que tu as utilis&#233;)



Ken@vo

 Code, Code, Codec !

[%3C/body ]

f0xi · Answer

oui, d'ailleur ce serait pas difficile je pense de programmer cela dans le compilateur pour qu'il ajuste correctement un array of var en array of pointeur...

mais bon ... apr&#233;s tout ce qui me derange c'est juste les @ a ajouter devant les variables ... c'est tout.

 La theorie c'est quand on sait tout, mais que rien ne fonctionne.
La pratique c'est quand tout fonctionne, mais que personne ne sait pourquoi.
<hr>

Cirec · Answer

J'ai fait les testes de mon cot&#233; effectivement il faut passer des pointeurs, en fait j'avais pas saisis la petite nuance (d'ou ma demande de code) entre Schtroumpfise( un_Array_Of_Bool) et Schtroumpfise([Bool1, Bool2, Bool3]) qui je le reconfirme ne fonctionne pas  

si non pour changer une o&#249;  plusieurs propri&#233;t&#233;es d'un o&#249; plusieurs composant tu peux utiliser cette Proc&#233;dure tr&#232;s pratique 


Procedure SetPropertys(ClassName: String; SomeProperty: Array Of String; Value:
  Array Of Variant);
Var
  i, j              : integer;
  PropInfo          : PPropInfo;
  Component         : TComponent;
  Prop_and_Value    : Boolean;
Begin  Prop_And_Value :High(SomeProperty) High(Value);
   With  AOwner Do // aOwner est la Form contenant les composants
    Begin
      For i : = 0 To ComponentCount - 1 Do
        Begin
          Component :=  Components[i]; // n'est pas absolument indispensable
           If  (Component Is TControl) And ((Component.ClassName  = ClassName)
            Or (ClassName =  'AllComponents'))  Then 
            Begin
              For j : = 0 To High(SomeProperty) Do
                Begin
                  PropInfo := GetPropInfo(Component.ClassInfo, SomeProperty[j]);
                  If Assigned(PropInfo) Then
                    If Prop_And_Value Then
                      SetPropValue(Component, PropInfo, Value[j])
                    Else
                      SetPropValue(Component, PropInfo, Value[0]);
                End;
            End;
        End;
    End;
End;

Ex:
  SetPropertys('AllComponents', ['ViSibLe', 'Enabled', 'Checked', 'Text'], [True, True, False, '']);

Met tous les composants &#224;    Visible      >   True
                                            Enable      >   True
                                            Checked   >   False
                                            Text          >   ''  

&#224; la place AllComponents tu peux mettre TButton o&#249; TEdit ..........

ps : ne pas oublier d'ajouter l'unit&#233; TypInfo dans la clause Uses



@+


Cirec

Tableau de variables dans une fonction afin de les schtroumpfer sans pointeurs .

15 réponses

Votre réponse

Discussions similaires