Une expression étrange en C++ - qu'est-ce que cela signifie?

Question

J'ai vu ce code pour trouver une mineure d'une matrice:

RegMatrix RegMatrix::Minor(const int row, const int col)const{ 
    //printf("minor(row=%i, col=%i), rows=%i, cols=%i\n", row, col, rows, cols); 
assert((row >= 0) && (row < numRow) && (col >= 0) && (col < numCol)); 

RegMatrix result(numRow-1,numCol-1); 

// copy the content of the matrix to the minor, except the selected 
    for (int r = 0; r < (numRow - (row >= numRow)); r++){ 
    for (int c = 0; c < (numCol - (col > numCol)); c++){ 
    //printf("r=%i, c=%i, value=%f, rr=%i, cc=%i \n", r, c, p[r-1][c-1], r - (r > row), c - (c > col)); 
    result.setElement(r - (r > row), c - (c > col),_matrix[r-1][c-1]); 
    } 
} 
    return result; 
} 

C'est la première fois que je rencontre une ligne de code comme ceci: r < (numRow - (rangée> = numRow)).

Qu'est-ce que cela signifie?

Answer 1

(row >= numRow) est une expression booléenne. Si operator>= n'a pas été surchargé, il doit évaluer à true si row est supérieur ou égal à numRow, et à false sinon. Lorsque vous convertissez ce booléen en entier pour la soustraction, il devient 1 si vrai, 0 sinon.

Answer 2

(row >= numRow) est une expression booléenne, qui, lorsqu'il est utilisé comme celui-ci est converti en un int, avec true devenir 1 et false devenir 0

Answer 3

Une façon un peu plus claire pour l'exprimer peut-être:

r < (row >= numRow ? numRow - 1 : numRow)

Answer 4

row >= numRow retournera un booléen vrai ou faux, et qui est le implicitement dans un cast entier 0 ou 1. Alors qu'est-ce que cela fait est fondamentalement identique:

r < (numRow - (row >= numRow ? 1 : 0)) 

Answer 5

row >= numRow renverra 1 si row est supérieur ou égal à numRow, sinon 0.

Ainsi, la ligne de code est équivalent à une fonction comme ceci:

bool foo() { 
    if(row >= numRow) 
     return r < numRow - 1; 
    else 
     return r < numRow; 
} 

Answer 6

Le résultat de l'utilisation d'un opérateur de comparaison est soit un true de false qui, lorsqu'il est utilisé comme un nombre entier ou est 10.

r < (numRow - (row >= numRow))

est la même que

r < (numRow - 1) si (row >= numRow)

sinon il est r < numRow

Answer 7

Comme d'autres l'ont dit, il est juste une expression bool qui est jeté dans une int avant soustraction (cela signifie: soustrait 1 si row >= numRow).

Mais j'ajouterais que c'est assez absurde. Vous avez déjà affirmé que row < numRow, donc row >= numRow violerait les conditions préalables à votre utilisation. Et la même chose se passe pour col > numCol dans la ligne suivante.