Porém, há uma diferença crucial: o CAPL, sendo uma linguagem projetada para o ambiente de testes automotivos, não possui conceito de ponteiros. Portanto, operadores como * (desreferência) e & (endereço) simplesmente não existem. Para engenheiros vindos do C/C++, isso pode soar estranho inicialmente, mas faz sentido. Em testes, interagimos primariamente com sinais, mensagens e variáveis de ambiente, tornando a manipulação direta de endereços de memória irrelevante e até insegura.

Trate os operadores do CAPL como um subconjunto especializado do C. A familiariadde é uma vantagem, e as limitações direcionam seu foco para a tarefa específica de teste.

Operadores Aritméticos: Além do Básico

Operadores como +, -, *, / e % são fundamentais, mas seu uso em scripts CAPL para testes automotivos requer atenção. Embora as regras de precedência sejam as mesmas da matemática, é uma excelente prática utilizar parênteses para tornar expressões complexas claras e sem ambiguidades. Isso não é uma questão de competência, mas de manutenibilidade do código, especialmente em cálculos que simulam condições de teste como taxa de deslizamento ou cálculo de torque.

variáveis
{
  int rpmMotor = 2500; // Rotação do motor em RPM
  float relacaoTransmissao = 2.5; // Relação de transmissão
  int rpmRoda; // Rotação da roda
}

na tecla 'c'
{
  // Escrita clara: os parênteses definem a intenção explicitamente
  rpmRoda = (rpmMotor + 100) * relacaoTransmissao;
  write("RPM da Roda: %f", rpmRoda);
}

Um erro sutil e comum ocorre com a divisão de números inteiros. No CAPL, quando dois operandos inteiros são divididos, o resultado também é um inteiro, e a parte fracionária é simplesmente descartada (truncamento), sem arredondamento.

variáveis
{
  int quilometragemTotal = 100; // Quilometragem total em km
  int numViagens = 3; // Número de viagens
  int mediaDistancia; // Distância média por viagem (resultado truncado)
}

na tecla 'd'
{
  mediaDistancia = quilometragemTotal / numViagens;
  write("Média por viagem (INCORRETO): %d km", mediaDistancia); // Imprime 33
  // O valor real é 33.333... km, a precisão é perdida.
}

Em um contexto de teste, esse truncamento pode levar a conclusões errôneas. Por exemplo, ao calcular consumo médio, velocidade média ou variação do estado de carga (SoC) de uma bateria, a perda de decimais pode alterar um resultado de teste.

Existem soluções diretas para este problema:

1. Conversão de tipo explícita: Converta pelo menos um operando para ponto fluutante antes da operação.

float mediaPrecisa;
mediaPrecisa = (float)quilometragemTotal / numViagens;
write("Média por viagem (PRECISO): %f km", mediaPrecisa); // Imprime 33.333332

2. Uso de literais de ponto flutuante: Use um número com casas decimais na expressão.

mediaPrecisa = quilometragemTotal / 3.0; // O literal '3.0' força a conversão

3. Declaração de variável com tipo adequado: Se a precisão é necessária, declare a variável como float ou double desde o início.

variáveis { float quilometragemTotal = 100.0; }

A regra geral é: sempre que uma divisão puder resultar em uma fração e a precisão for importante, garanta que a aritmética seja feita em ponto flutuante.