Perché nella complessità ciclomatica aggiungiamo 1 per gli operatori in una condizione?

Naviga le tue risposte
3

So che, in pratica, CC può essere calcolato come numero di decisioni + 1. Inoltre, ogni operatore logico nella condizione fa aumentare il CC di 1. Ma perché?

Avere il codice if(A || B || C) else... del diagramma del flusso di controllo sarebbe semplicemente un nodo con due risultati: due rami. Quindi ho sempre pensato che la copertura delle filiali riguardasse i bordi del grafico, le diramazioni, il che significherebbe la condizione di calcolo per valutare VERO e FALSO. Per quanto riguarda i percorsi, i percorsi possono essere solo VERO o FALSO, quindi perché il CC inceppa con gli operatori se non ci sono altri rami di codice eseguiti?

    
posta user144171 12.11.2014 - 20:40
fonte

2 risposte

4

Solo perché il linguaggio di programmazione astrae i rami in un'espressione booleana, non significa che non ci siano. Se hai guardato cosa viene effettivamente eseguito, assomiglia a questo: 

 +-----------+                           
 |is A true? +------------------+       
 +----+------+                  |       
      |                         |       
 +----v------+                  |       
 |is B true? +------------------+       
 +----+------+                  |       
      |                         |       
 +----v------+                  |       
 |is C true? +------------------+       
 +----+------+                  |       
      |                         |       
+-----v-------------+   +-------v------+
| Do something else |   | Do something |
+-------------------+   +--------------+

Anche senza valutazione di cortocircuito, si ha un caso che aumenta la complessità, perché ci sono diversi modi per scegliere un determinato percorso, e devi testarli e mantenerli tutti.

    
risposta data 12.11.2014 - 21:47
fonte
2

Nell'esempio che usi, ci sono quattro (4) possibili percorsi di esecuzione, e quindi quattro (4) test che devono essere eseguiti. Possono essere enumerati come segue, dove x indica "non importa":

  • 1xx: A è vero, non importa di B e C - quindi percorso
  • 01x: A è falso, B è vero, non importa di C - quindi percorso
  • 001: A e B sono falsi, C è vero - quindi percorso
  • 000: A, B e C sono tutti falsi - altro percorso

(Potrebbe essere più facile vedere se si considera il linguaggio di assemblaggio generato.)

La complessità ciclomatica ha lo scopo di darti una mano sul numero possibile di test che devi eseguire.

    
risposta data 12.11.2014 - 21:46
fonte

Leggi altre domande sui tag

Come tenere traccia del codice sicuro del thread in una base di codice C ++ Rich Legacy per lo più thread non sicura Devo usare expect o should durante la scrittura delle specifiche RSpec? [chiuso]