Que fait le code suivant ?

Bonjour,

D'après vous, sans tester dans WinDev, que devrait faire le code suivant ?

Code:

---

1 2 3 4 5

tabToto est tableau d'entiers = [1, 2, 3] tabToto = [1] Trace(tabToto..Occurrence) tabToto = [1, 2, 3, 4] Trace(tabToto..Occurrence)

---

Dans quelle version de WinDev ?

Bonjour,
Vu de loin dans le brouillard, je dirai qu'il affiche 3 et 4.

Tatayo.

Question supplémentaire, quand vous aurez vérifié ce que fait WD : trouvez-vous cela logique/intuitif ?

Citation:

---

Envoyé par Hibernatus34

Question supplémentaire, quand vous aurez vérifié ce que fait WD : trouvez-vous cela logique/intuitif ?

---

En première approche, je dirai non et non. Mais en lisant l'aide en ligne, je dirai oui et non :aie:.

Tatayo.

Bonjour,

Si je peux me permettre, tout en sachant que je ne suis pas un développeur parfait.

Un tableau d entiers ou de chaîne n'est qu'une structure avec membre de même type et valeur par défaut.
C'est d'ailleurs comme cela que je m en sers.

Code:

---

1 2 3 4 5 6 7 8 9 10 11

Mastruct est une Structure identifiant1 est un entier identifiant2 est un entier identifiant3 est un entier FIN   tabMastruct est un tableau de Mastruct tabMastruct=[[0,0,0]] tabMastruct=[[1,2,3]] tabMastruct=[[2]] tabMastruct=[[0,2]]

---

D'ailleurs sur leur page est indiqué :

Citation:

---

Un tableau est un type structuré qui permet de regrouper une série d'éléments de même type. Chaque élément du tableau est accessible directement par son numéro d'ordre.

---

https://doc.pcsoft.fr/?1514030

Citation:

---

Envoyé par Hibernatus34

Question supplémentaire, quand vous aurez vérifié ce que fait WD : trouvez-vous cela logique/intuitif ?

---

En fait, j'avais répondu autre chose, mais en y réfléchissant, c'est pas complètement illogique.

Youhou j'ai gagné.

Je me suis fait piégé je ne sais combien de fois par les tableaux sous WinDev qui se redimensionnent en agrandissement mais qui garde leur dimension alors qu'on l'a vidé ou réaffecté...:weird:

En fait la réponse est là.
Plus précisément:

Citation:

---

Si les dimensions du tableau à affecter sont insuffisantes pour stocker les éléments du tableau de valeurs, le tableau à affecter est automatiquement agrandi.
Si les dimensions du tableau à affecter sont plus grandes que celles du tableau de valeurs, les éléments non affectés conservent leurs valeurs précédentes.

---

Donc la première ligne prépare un tableau de 3 entier, la deuxième ligne ne fait que "remplacer" le contenu de la première case, et la ligne 4 agrandit le tableau de 1 (agrandissement par défaut).

Tatayo.

Vous vous en doutez, je pose la question parce que je trouve ça illogique.

Je pense que PC Soft a fait une erreur en adoptant ce comportement, parce que :

• On peut écrire tabToto = [] qui, du coup, n'a aucun effet !
• Dans un programme de "la vie réelle", je n'imagine pas un cas où j'aurai besoin d'écraser le début d'un tableau avec des valeurs en dur. En tout cas, pas un cas assez commun pour vouloir le faire avec un simple opérateur.
• Ça ne respecte pas la sémantique : le sens de l'opérateur "=" est "remplace la valeur de A par B". La valeur d'un tableau est son contenu.
• Si j'écris tabToto = tabTiti, cette fois il y a bien écrasement de tout le contenu !
• Si l'initialiseur (liste entre crochets) est passé à une fonction, celle-ci n'aura pas le même comportement selon qu'on lui passe un tableau ou l'initialiseur, ou selon qu'on type le paramètre ou pas*. (voir ci-dessous)
• Quand je fais rMonRéel = 8, je ne m'attends pas à ce que rMonRéel contienne "8.3".
• Je doute fortement qu'aucun autre langage ait ce comportement.

* Fonction dont le comportement dépend du typage du paramètre :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

PROCÉDURE Test1(tabTiti est tableau d'entiers) tabToto est tableau d'entiers = [1, 2, 3] tabToto = tabTiti Trace(tabToto..Occurrence)   PROCÉDURE Test2(tabTiti) tabToto est tableau d'entiers = [1, 2, 3] tabToto = tabTiti Trace(tabToto..Occurrence)   PROCEDURE Test() Test1([1]) // Affiche 1 Test2([1]) // Affiche 3 tabTest est tableau d'entiers = [1] Test2(tabTest) // Affiche 1

---

Bref pour moi c'est à mettre sur le même compte que :

Code:

---

1 2 3 4

vVar est Variant = Null SI vVar = "WinDev" ALORS Info("WinDev est nul. C'est pas moi qui le dis !") FIN

---

Et si vous vous demandez pourquoi ils ont choisi ce comportement, c'est pour le cas suivant :

Code:

---

tabToto est tableau de 3 entiers = [1] // J'ai demandé 3 entiers

---

Mais l'initialisation n'est pas l'affectation (en C++ par exemple), et j'aurais trouvé logique que :

Code:

---

tabToto est tableau de 3 entiers = [1]

---

soit différent de :

Code:

---

1 2	tabToto est tableau de 3 entiers // Implicitement = [0, 0, 0] tabToto = [1]

---

Code:

---

1 2 3 4 5 6

tabToto est tableau d'entiers = [1, 2, 3] TableauSupprimeTout(tabToto) tabToto = [1] Trace(tabToto..Occurrence) tabToto = [1, 2, 3, 4] Trace(tabToto..Occurrence)

---

Dans ce cas, on a 1 et 4

TableauSupprimeTout, c'est magique :)

Pas si magique ! Il en faudrait un avant chaque affectation, en imaginant qu'on ne connaisse pas la taille précédente du tableau.

Sinon il y a ça :

Code:

---

1 2	tabToto est tableau d'entiers = [1, 2, 3] tabToto <= []

---

Il faut le savoir, mais une fois qu'on le sait, finalement c'est pas si mal.

C'est juste qu'on a 2 cas plutôt encombrants :

Code:

---

1 2	tabToto est tableau de 2 entiers <= [1, 2, 3] // Finalement ça sera 3 tabToto = [1] // Finalement, on reste sur 3

---

Du coup on peut se donner la règle suivante :

• En initialisation j'utilise =
• En affectation j'utilise <=

Code:

---

1 2 3 4

tabToto est tableau de 3 entiers = [1] // BIEN tabTiti est tableau de 3 entiers <= [1] // PAS BIEN tabToto <= [1] // BIEN tabToto = [1] // PAS BIEN

---

Citation:

---

En initialisation j'utilise =- En affectation j'utilise <=

---

J'avais oublié cette syntaxe. Ca a du bon de le rappeler...:merci:

Pour utiliser windev depuis pas mal de temps maintenant, le comportement ne me surprend pas.
En revanche, oui la logique n'est pas top.

Oui, il est fortement recommandé de bien typer ses paramètres pour éviter les surprises de (re)cast.
L'agrandissement, le retypage automatique est souvent appréciable mais à aussi ces contrepartie.

Windev et la manipulation de tableau réserve quasiment toujours des (mauvaise) surprise.
Dernièrement, dans un projet tout neuf en 23, j'ai une classe contenant un tableau d'objet (autre classe).
Je veux faire une copie de ma première classe, et évidemment du tableau.
Mais rien à faire, même avec l'attribut LOCAL (cf aide), windev me gardait toujours la même référence du tableau pour mes deux instances...
J'ai dus me faire ma propre procédure de copie.

Citation:

---

Envoyé par tatayo

En fait la réponse est là.
Plus précisément:
Si les dimensions du tableau à affecter sont insuffisantes pour stocker les éléments du tableau de valeurs, le tableau à affecter est automatiquement agrandi.
Si les dimensions du tableau à affecter sont plus grandes que celles du tableau de valeurs, les éléments non affectés conservent leurs valeurs précédentes.
Donc la première ligne prépare un tableau de 3 entier, la deuxième ligne ne fait que "remplacer" le contenu de la première case, et la ligne 4 agrandit le tableau de 1 (agrandissement par défaut).

Tatayo.

---

Eh bien on dirait que PCSoft, ne connait pas bien Windev:

Code:

---

1 2 3 4 5 6 7 8 9 10 11

tabTypeUl est tableau de chaînes   tabTypeUl = ["07", "10", "03"] POUR i = 1 _À_ tabTypeUl..Occurrence Trace(tabTypeUl[i]) FIN tabTypeUl = ["10", "03"] POUR i = 1 _À_ tabTypeUl..Occurrence Trace(tabTypeUl[i] = "" ? "Bordel" SINON tabTypeUl[i]) FIN

---

Vous pouvez essayer d'initialiser le tableau avec les valeurs ou de déclarer un tableau sans donner de taille, ça ne change rien...
Vous pouvez essayer aussi avec des entiers....

Ah oui, bien vu !
J'avais testé qu'avec le ..Occurrence, mais effectivement les valeurs sont perdues.

Windev est un peu trop "dynamique". Il est loin le temps où l'on devait dimensionner ses tableaux "en dur".

J'ai repris l'exemple de Hibernatus en WD22, en le modifiant :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

tabTypeUl est tableau de chaînes   tabTypeUl = ["07", "10", "03"] POUR i = 1 _A_ tabTypeUl..Occurrence Trace(tabTypeUl[i]) FIN TableauSupprimeTout(tabTypeUl) tabTypeUl = ["10", "03"] POUR i = 1 _A_ tabTypeUl..Occurrence Trace(tabTypeUl[i] = "" ? "pas glop" SINON tabTypeUl[i]) FIN

---

le TableauSupprimeTout remet les compteurs à 0 si je puis dire.

Mais il ne faut pas oublier le plus important : cela nous permets de coder 10 fois plus vite.

Quand on ne compte pas les heures passées à chercher les merdes.