Skip to main content

Complexidade

  • Complexidade

A complexidade ciclomática e a complexidade aciclomática são métricas relacionadas ao fluxo de controle de um programa, geralmente usadas para medir a complexidade do código e a quantidade de caminhos possíveis que podem ser seguidos durante a execução de um software.

Complexidade Ciclomática​

A complexidade ciclomática (ou métrica de McCabe) é uma métrica usada para medir a quantidade de caminhos independentes possíveis em um programa. Esses caminhos independentes correspondem ao número de decisões que podem ser tomadas, como estruturas de controle (condicionais e laços) que afetam o fluxo do programa. Ela é útil para determinar a quantidade mínima de testes necessários para cobrir todos os caminhos lógicos de um software.

A fórmula para calcular a complexidade ciclomática é:

V(G) = E - N + 2P

Onde:

  • ( E ) = número de arestas no grafo de controle de fluxo (transições entre nós);
  • ( N ) = número de nós no grafo de controle de fluxo (instruções ou blocos de código);
  • ( P ) = número de componentes conectados no grafo (geralmente 1, para um único programa ou função).

Ou, de forma simplificada, pode ser calculada como:

V(G) = número de regiões no grafo

Exemplo: Em uma função simples com uma estrutura condicional (if-else), haveria dois caminhos: um para o if e outro para o else. A complexidade ciclomática seria 2.

Complexidade Aciclomática​

A complexidade aciclomática é uma variação da complexidade ciclomática, mas leva em consideração apenas os ciclos que são executados em laços ou repetições no fluxo de controle do programa. Ou seja, ela mede o número de ciclos no código sem contar outros tipos de caminhos independentes. O foco está no comportamento repetitivo (laços como for, while, e do-while), não em ramificações ou condições simples.

Geralmente, a complexidade aciclomática é usada em combinação com a complexidade ciclomática para uma análise mais detalhada. Ela não tem uma fórmula padrão amplamente utilizada como a ciclomática, mas a ideia principal é que se concentra nos ciclos do código.

Diferenças entre as duas métricas​

  • A complexidade ciclomática considera todos os caminhos lógicos possíveis, incluindo os ciclos e as ramificações, enquanto a complexidade aciclomática foca apenas em ciclos no código (estruturas de repetição).
  • A ciclomática é usada para analisar a cobertura de testes e a testabilidade do software, enquanto a aciclomática é mais específica para entender a complexidade de código que envolve loops e repetições.

Resumo:

  • Complexidade ciclomática: mede o número total de caminhos independentes em um código, incluindo ramificações e loops.
  • Complexidade aciclomática: mede apenas os ciclos (loops) presentes no código, focando na repetição de fluxos.

Essas métricas são essenciais para a análise da qualidade do código e para identificar possíveis áreas de complexidade excessiva que podem ser alvo de refatoração ou melhorias.

Exemplo na prática​

Exemplo em C#​

using System;

public class Program
{
    public static void Exemplo(int x)
    {
        if (x > 10)
        {
            for (int i = 0; i < x; i++)
            {
                Console.WriteLine(i);
            }
        }
        else if (x == 10)
        {
            Console.WriteLine("x é igual a 10");
        }
        else
        {
            Console.WriteLine("x é menor que 10");
        }
    }

    public static void Main()
    {
        Exemplo(5);
    }
}

1. Complexidade Ciclomática​

A complexidade ciclomática mede o número de caminhos independentes possíveis no código, levando em consideração as estruturas de controle como if, else if, e for. Vamos analisar a função Exemplo:

  • O código tem um if (quando x > 10), um else if (quando x == 10), e um else.
  • Dentro do bloco if, existe um for loop.

Para calcular a complexidade ciclomática, usamos a fórmula:

V(G) = E - N + 2

Onde:

  • ( E ) é o número de arestas (transições no fluxo de controle);
  • ( N ) é o número de nós (blocos de código);
  • ( 2 ) é uma constante que representa o ponto de entrada e saída.

Mas há uma fórmula mais prática para pequenos exemplos:

V(G) = Número de decisões + 1

Agora vamos contar os pontos de decisão:

  • 1 ponto de decisão para o if (x > 10);
  • 1 ponto de decisão para o else if (x == 10);
  • O else não conta como decisão, pois é uma alternativa direta.

Portanto, temos 2 decisões.

Agora, somamos 1 (que é o caminho básico de execução):

V(G) = 2 + 1 = 3

Então, a complexidade ciclomática do código é 3, o que significa que há 3 caminhos independentes no fluxo de controle.

2. Complexidade Aciclomática​

A complexidade aciclomática foca nos ciclos presentes no código, ou seja, loops como for, while, etc.

Neste exemplo, há apenas um loop for dentro do if (x > 10).

Portanto, a complexidade aciclomática aqui seria simplesmente 1, que é o número de ciclos presentes no código.

Resumo​

  • Complexidade ciclomática: 3 (há 3 caminhos diferentes: um para x > 10, um para x == 10 e um para x < 10).
  • Complexidade aciclomática: 1 (há um ciclo for no código).

Essas métricas indicam a quantidade de caminhos possíveis e a presença de loops no código, ajudando a entender a complexidade do fluxo de controle.