interprétation du point d'exclamation

Bonjour à tous.

Dans les extraits de code suivants :

Code:

---

1 2 3 4

m.v1=!m.v1 m.v2=!m.v2 m.v3=!m.v3

---

Code:

---

1 2 3 4 5

v->x= m.v2.z-m.v3.y; v->y= m.v3.x-m.v1.z; v->z= m.v1.y-m.v2.x; *v = !(*v);

---

Je ne comprends pas la signification du point d'exclamation car placé après le signe égal.

J'ai besoin de transcrire ces petites fonctions en python, et là je suis sec.

Pourriez-vous me donner le sens de ces deux écritures, d'autant que je me demande si c'est bien le même dans les deux cas.

Par avance, merci.

Il ne s'agit pas ici d'un hypothétique opérateur =! mais d'expressions impliquant l'opérateur unaire ! et placées à droite de l'opérateur d'affectation =.

Ca peut être l'occasion de retourner lire la documentation: sur cppereference.com par exemple.

En l'occurence, ! est la négation logique: il retourne true pour toute valeur convertible en false (false, 0, nullptr), et false pour toutes les autres.

Merci à vous deux pour votre aide, mais j'ai besoin d'un peu de confirmation.

Si je comprends bien, dans la première expression, on affecte à m.vx sa propre valeur dès lors qu'elle ne vaut pas 0 ?

Même chose dans la seconde si ce n'est qu'on à affaire à un pointeur.

Dès lors, si la négation logique est true (donc pour une valeur de 0), dans l'un ou l'autre cas, que se passe-t-il ?

Code:

---

m.v1=!m.v1

---

est équivalent à :

Code:

---

m.v1 = (!(m.v1))

---

Citation:

---

on affecte à m.vx sa propre valeur dès lors qu'elle ne vaut pas 0 ?

---

Non.
On calcule le résultat de l'opération "!" sur la valeur "m.v1".
La nature de l'opération "!" est fonction du type de "m.v1".
Si "m.v1" est un nombre, c'est déjà du bricolage en C++ avec des UB (Undefined behaviour) à la clé.
Sur une variable de type "bool", cela fait passer de true à false et de false à true.
Sur des nombres entiers, sinon c'est encore plus le bordel, ça mimique les trucs tous moisis du C :
https://www.le.ac.uk/users/rjm1/cotter/page_37.htm

Après ce calcule, on affecte TOUJOURS le résultat du calcule à la variable indiqué à gauche du signe =.

Citation:

---

Même chose dans la seconde si ce n'est qu'on à affaire à un pointeur.

---

Non.
"v" est un pointeur, mais "*v" est une variable comme une autre.
Déjà que l'opérateur "!" sur autre chose qu'un bool, c'est bien de la me...., sur un pointeur, c'est à proscrire (c'est accepté par le compilateur pour des sales bidouilles d’arithmétique de pointeurs, mais c'est a éviter).

Citation:

---

Envoyé par KonTiKI

Code:

---

1 2 3 4

m.v1=!m.v1 m.v2=!m.v2 m.v3=!m.v3

---

Code:

---

1 2 3 4 5

v->x= m.v2.z-m.v3.y; v->y= m.v3.x-m.v1.z; v->z= m.v1.y-m.v2.x; *v = !(*v);

---

---

Ici, v est un pointeur vers une instance d'une structure qu'on va appeler, par exemple, type_vecteur.
type_vecteur possède des variables membres x, y et z et une fonction membre dont la déclaration ressemble probablement à type_vecteur operator!() const (à moins que ce soit un opérateur global du style type_vecteur operator!(type_vecteur param)).
m est une instance d'une structure qu'on va appeler, par exemple, type_matrice.
type_matrice possède des variables membres v1, v2 et v3 de type type_vecteur.
Pour répondre à ta question, dans ce code, les 4 points d'exclamation sont bien des appels à la même fonction, à savoir la fonction operator! qui retourne un type_vecteur.
Par contre, on ne peut pas savoir ce que fait cette fonction. Peut-être qu'elle renvoie un vecteur avec les valeurs !x, !y et !z, ou peut-être pas. Pour le savoir, il faut chercher l'implémentation de la fonction operator! qui retourne un type_vecteur.

Remarque : Le code que l'on te fait traduire en Python ne respecte pas les bonnes pratiques du C++.

Merci à tous.

Voici donc l'intégralité du code, qui fait partie d'une api :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

void MatrixToRotAxis(const Matrix& mm, Vector* v, Float* w) { Matrix m = mm; // MatrixVectoren MUESSEN normiert sein!!! m.v1 = !m.v1; m.v2 = !m.v2; m.v3 = !m.v3;   // Winkel berechnen *w = ACos((m.v1.x + m.v2.y + m.v3.z - (Float) 1.0) / (Float) 2.0);   // Achse berechnen v->x = m.v2.z - m.v3.y; v->y = m.v3.x - m.v1.z; v->z = m.v1.y - m.v2.x; *v = !(*v);   if (*v == 0.0) { *v = Vector(0.0, 1.0, 0.0); *w = 0.0; } }

---

m est une matrice, tableau de tableau constitués de float.

La structure est la suivante pour Matrix : https://developers.maxon.net/docs/Ci..._matrix64.html
m.v1 comporte donc 3x3 float, x,y,z ; x,y,z ; x,y,z.

du coup, je développe et simplifie la première syntaxe (m.v1 = !m.v1) comme ceci :

Code:

---

1 2	x,y,z ; x,y,z ; x,y,z = !( x,y,z ; x,y,z ; x,y,z)

---

ou en français : "On affecte au vecteur1 de la matrice m, le vecteur1 de la matrice m s'il n'est pas nul" ?

Pour la seconde difficulté, même si c'est un pointeur, le principe est le même.

v est un vecteur, tableau de 3 float, x,y et z. Ces trois valeurs sont calculées à partir des données de la matrice ci-dessus. Et en final, on trouve *v = !(*v).

là aussi faut-il interpréter comme quoi on affecte les valeurs si celles-ci ne sont pas nulles ?

Alors que se passe-t-il si la condition de l'operator ! est vérifiée ?

Citation:

---

Pour le savoir, il faut chercher l'implémentation de la fonction operator! qui retourne un type_vecteur.

---

J'ai cherché et je n'ai trouvé aucune surcharge de cet opérateur dans les sources communiquées.

Merci encore pour votre aide.

Il n'y a pas d'autre si en C++ que if et cond? a : b.
! est une opération mathématique, au même titre que -x. !x est équivalent à (static_cast<bool>(x) == true) ? false : true.

On appelle ça l'opérateur not et en python le mot-clé est... not. :calim2:

Notons que v est une structure, donc si le code compile, c'est que l'opérateur ! a été surchargé dessus.
Je suis prête à parier qu'il s'agit d'une fonction retournant une copie normée du vecteur.

Citation:

---

Envoyé par KonTiKI

J'ai cherché et je n'ai trouvé aucune surcharge de cet opérateur dans les sources communiquées.

---

Regarde du côté de la classe Vector.

Il y a fort à parier que cet opérateur réalise la normalisation du vecteur.

EDIT: comme mon VDD.

Citation:

---

Envoyé par ternel

Notons que v est une structure, donc si le code compile, c'est que l'opérateur ! a été surchargé dessus.
Je suis prête à parier qu'il s'agit d'une fonction retournant une copie normée du vecteur.

---

Citation:

---

Regarde du côté de la classe Vector.

Il y a fort à parier que cet opérateur réalise la normalisation du vecteur.

---

Bingo ! Ca semble bien être cela. En piochant plus en profondeur, j'ai trouvé ce code :

Code:

---

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

//---------------------------------------------------------------------------------------- /// Calculates the normalized vector @formatParam{v}. /// @see GetNormalized() /// @param[in] v                                                                        The vector. /// @return                                                                                             The normalized vector. //---------------------------------------------------------------------------------------- friend const Vector64 operator ! (const Vector64& v) { Float64 l = Sqrt(v.x * v.x + v.y * v.y + v.z * v.z); if (l == 0.0) return Vector64(0.0); l = 1.0 / l; return Vector64(v.x * l, v.y * l, v.z * l); }

---

Merci à vous tous, maintenant le code m'est beaucoup plus compréhensible.