Re: Il y a plusieurs formes de commentaires.

Je ne suis pas sûr de comprendre ce que tu veux dire?

Si j'ai une fonction de 50 lignes (j'ai rarement plus) qui s'appelle "printPage(int number)" le pourquoi appeler cette fonction est déjà commenté dans le nom, et on sait que tout ce qu'elle fera sera avec l'objectif d'afficher le contenu de la page number, non?

Après, logiquement, si tu modifies un programme, tu devrais savoir à quoi il sert, et en creusant couche après couche, si les noms sont corrects (pas toujours simple cela dis) le pourquoi devrait (conditionnel) se situer dans le nommage, pour moi…

Idem, si tu as une grosse expression type:

return (x*y+j<2?callFoo(x,y):callBar(j,k);

Si on y comprend rien c'est clairement parce que les noms sont foireux, et que le développeur à tout mis sur une seule ligne pour rien…

int FooBarCaller(...)
{
int ret;
if((x*y+j<<k%tmp)>2)
 ret=callFoo(x,y);
else
 ret=callBar(j,k);
}

Bien que plus lisible, on s'aperçoit encore une fois qu'on ne comprend rien, mais forcément avec des noms à la con… (en même temps, c'est pas un exemple tiré de la vie réelle)

J'ai un bout de code la (je n'irai pas dire que c'est super propre hein, et c'est de moi il y a quelques mois… :/):

void Camera::AutoCalibration(void)
{
...
...
...
 CvRect r; //will contain final values of used rectangle
...
...
...
 if(r.x && r.y && !InsideTolerance(r))
 {
 m_roi=r;
 SetSize(m_roi.width,m_roi.height);
 }
}
bool Camera::InsideTolerance(CvRect const &target)
{
 if(m_tolEnabled)
 return CheckSingleTolerance(target.x,m_roi.x,m_tolX)
 &&CheckSingleTolerance(target.y,m_roi.y,m_tolY)
 &&CheckSingleTolerance(target.width,m_roi.width,m_tolX)
 &&CheckSingleTolerance(target.height,m_roi.height,m_tolY);
 return false;
}
...
...
...
bool Camera::CheckSingleTolerance(double value, double base, double percent)
{
 return value*(1+percent)>base && value*(1-percent)<base;
}

1er constat: j'ai un commentaire qui explique le pourquoi de l'existence de la variable "r"… un meilleur nom aurait suffit. Pour m_roi, l'abréviation est un peu plus justifiée, mais pas terrible quand même (RegionOfInterest au cas où. Vu que c'est une classe qui manipule des images prises d'une caméra…).

2nd constat (où je voulais en venir au final):

if(r.x && r.y && !InsideTolerance(r))

ici, "InsideTolerance" ne sers qu'une seule fois dans tout le code, et sert justement à nommer le "pourquoi" de son code.
Les quelques lignes se traduisent en "si on a des valeurs non-nulles ou en dehors de la zone de tolérance, on les utilise comme nouvelle région d'intérêt.".

PS:
Le nommage pourrait vraiment être amélioré d'ailleurs… j'ai limite honte de foutre ça sur un forum… j'aurai aussi du diviser ce bazard en plusieurs classes, rétrospectivement. Pour le coup Camera fait clairement office de fourre-tout, ce qui aide pas du tout à avoir des noms cohérents et clairs: si j'avais encapsulé cette histoire de région dans sa propre classe, avec ses méthodes dédiées donc, l'ensemble aurait été plus simple à lire et comprendre.

PPS:
Le code complet de la fonction en question:

void Camera::AutoCalibration(void)
{
 if(!m_objectDetect)
 return;
 ObjectDetect();
 unsigned short decalX,decalY;
 CvRect r; //will contain final values of used rectangle
 r.x=10000;r.y=10000; //dumb values. I should have used a macro like INT_MAX in stdint.h, but VC9 doesn't respect C++03 standard
 r.width=0;r.height=0;
 for( int i = 0; i < m_Objects->total; ++i )
 {
 CvRect rt=GetObjectN(i);
 if( rt.height<= 0 || rt.width<= 0 ||rt.x<= 0||rt.y<= 0 )
 continue;//!\todo verify that following code (from an example on the web) is not useless
 //enlarge rt rectangle with decal values
 decalX=static_cast<unsigned short>(rt.width*m_decalX);
 decalY=static_cast<unsigned short>(rt.height*m_decalY);
 //calculate the final rectangle, which will contain both previous r rectangle and current rt rectangle
 r.x=std::min(rt.x-decalX,r.x);
 r.y=std::min( rt.y-decalY,r.y);
 r.width=std::max(rt.x+rt.width+decalX,r.width);
 r.height=std::max(rt.y+rt.height+decalY,r.height);
 }
 //ensure (x,y) contain the lowest coordinates
 if(r.y>r.height)
 std::swap(r.y,r.height);
 if(r.x>r.width)
 std::swap(r.x,r.width);
 //transform width and height into dimensions (they are actually coordinates)
 r.width-=r.x;
 r.height-=r.y;
 //checking if new roi should be applyed (tolerance and sigsegv fault checks)
 if(r.x && r.y && !InsideTolerance(r))
 {
 m_roi=r;
 SetSize(m_roi.width,m_roi.height);
 }
}

//checking if new roi should be applyed (tolerance and sigsegv fault checks)

comme quoi je commente quand même un peu. Mais ce commentaire aurait sûrement pu sauter si la méthode avait été proprement découpée et ne faisait pas le café. (je suis vraiment pas fier de ce truc)