Tempo de compilação e tempo de execução são os dois termos de programação usados ​​no desenvolvimento de software. O tempo de compilação é o momento em que o código-fonte é convertido em um código executável, enquanto o tempo de execução é o momento em que o código executável começa a ser executado. Tanto o tempo de compilação quanto o tempo de execução referem-se a diferentes tipos de erro.

Erros em tempo de compilação

Erros em tempo de compilação são os erros que ocorreram quando escrevemos a sintaxe errada. Se escrevermos a sintaxe ou semântica errada de qualquer linguagem de programação, os erros em tempo de compilação serão gerados pelo compilador. O compilador não permitirá a execução do programa até que todos os erros sejam removidos do programa. Quando todos os erros forem removidos do programa, o compilador irá gerar o arquivo executável.

Os erros em tempo de compilação podem ser:

• Erros de sintaxe
• Erros semânticos

Erros de sintaxe

Quando o programador não segue a sintaxe de nenhuma linguagem de programação, o compilador lançará o erro de sintaxe.

Por exemplo,

int a, b:

A declaração acima gera o erro em tempo de compilação como em C, toda instrução termina com ponto e vírgula, mas colocamos dois pontos (:) no final da instrução.

tipos de dados SQL

Erros semânticos

Os erros semânticos existem quando as instruções não são significativas para o compilador.

Por exemplo,

uma+b=c;

A instrução acima gera erros em tempo de compilação. Na instrução acima, estamos atribuindo o valor de 'c' à soma de 'a' e 'b', o que não é possível na linguagem de programação C, pois pode conter apenas uma variável à esquerda do operador de atribuição enquanto à direita de o operador de atribuição pode conter mais de uma variável.

A afirmação acima pode ser reescrita como:

c=a+b;

Erros de tempo de execução

Os erros de tempo de execução são os erros que ocorrem durante a execução e após a compilação. Os exemplos de erros de tempo de execução são divisão por zero, etc. Esses erros não são fáceis de detectar porque o compilador não aponta para esses erros.

Vamos explorar alguns típicos C tipos de erros de tempo de execução, casos e seus possíveis efeitos.

Divisão por zero:

Como a divisão por zero é matematicamente indefinível , tentando dividir um número inteiro por zero leva a um erro de tempo de execução . Este erro faz com que o programa trave ou produza uma exceção. Aqui está um exemplo:

 #include int main() { int a = 10; int b = 0; int result = a / b; // Division by zero printf('Result: %d
', result); return 0; } 

Saída:

 Floating point exception (core dumped) 

Explicação:

A 'Exceção de ponto flutuante' mensagem de erro é produzida quando o programa encontra um problema de tempo de execução devido à divisão por zero.

Acessando o array fora dos limites:

A erro de tempo de execução ocorre quando um elemento da matriz é acessado fora de certos limites. Um erro ocorre quando um índice é maior que o tamanho do array e as leis de acesso à memória são violadas. Aqui está um exemplo:

 #include int main() { int arr[5] = {1, 2, 3, 4, 5}; int index = 10; int value = arr[index]; // Accessing array out of bounds printf('Value: %d
', value); return 0; } 

Saída:

 Segmentation fault (core dumped) 

Explicação:

O elemento em índice 10 está além dos limites do array quando o programa tenta acessá-lo. Como resultado, um falha de segmentação ocorre , e o programa termina com um erro.

java matemática aleatória

Desreferência de ponteiro nulo:

A erro de tempo de execução acontece quando você tenta acessar um memória do ponteiro nulo endereço, conhecido como desreferenciação um ponteiro nulo. Acessar ponteiros nulos resulta em comportamento imprevisível porque eles não apontam para locais de memória legítimos . Aqui está um exemplo:

 #include int main() { int* ptr = NULL; // Null pointer int value = *ptr; // Null pointer dereference printf('Value: %d
', value); return 0; } 

Saída:

 Segmentation fault (core dumped) 

Explicação:

A tentativa de desreferência um ponteiro nulo resulta em um falha de segmentação , o que faz com que o programa trave com uma mensagem de erro.

Estouro de pilha:

A estouro de pilha acontece quando a pilha de chamadas fica maior do que o pretendido, contendo informações sobre chamadas de função. Um recursão infinita geralmente resulta quando as funções recursivas não possuem critérios de terminação apropriados. Aqui está um exemplo:

 #include void recursiveFunction() { recursiveFunction(); // Recursive call without termination condition } int main() { recursiveFunction(); return 0; } 

Saída:

 Segmentation fault (core dumped) 

Explicação:

O programa inicia um recursão sem fim , que transborda a pilha e causa uma falha de segmentação.

Variáveis ​​não utilizadas:

Porque variáveis ​​não inicializadas ter valores indefinidos , usá-los pode resultar em erros de tempo de execução. O programa pode fornecer resultados surpreendentes ou travar, dependendo das circunstâncias. Aqui está um exemplo:

 #include int main() { int uninitializedVariable; printf('Value: %d
', uninitializedVariable); // Using uninitialized variable return 0; } 

Saída:

 Some random value (varies each time) 

Explicação:

Neste exemplo, o valor de um variável não inicializada pode ser qualquer valor aleatório escolhido aleatoriamente da região de memória designada para essa variável.

Vejamos as diferenças entre tempo de compilação e tempo de execução:

analisando string para int

Exemplo de erro em tempo de compilação

 #include int main() { int a=20; printf('The value of a is : %d',a): return 0; } 

No código acima, tentamos imprimir o valor de 'a', mas ocorreu um erro. Colocamos dois pontos no final da instrução em vez de ponto e vírgula, portanto, esse código gera um erro em tempo de compilação.

Saída

Exemplo de erro de tempo de execução

 #include int main() { int a=20; int b=a/0; // division by zero printf('The value of b is : %d',b): return 0; } 

No código acima, tentamos dividir o valor de ‘b’ por zero e isso gera um erro de tempo de execução.

Saída

Conclusão:

Concluindo, os períodos de desenvolvimento de software conhecido como tempo de compilação e erros de tempo de execução são separados e cada um tem um conjunto único de falhas, panes isso pode ocorrer. Erros em tempo de compilação acontece quando o código é convertido em formato executável durante a etapa de compilação. Esses erros incluem erros semânticos , que produzem ilógico ou código absurdo , e falhas de sintaxe , que vão contra as leis da linguagem de programação. Esses erros são identificados pelo compilador e relatado, bloqueando a execução do código até que sejam corrigidos.

Por outro lado, erros de tempo de execução ocorrem quando um programa está em execução e não são capturados pelo compilador. Eles podem resultar de diversas condições, incluindo divisão por zero, acesso incorreto à memória , ou outros eventos imprevistos. Erros de tempo de execução são mais difíceis de descobrir e depurar, pois frequentemente resultam em travamentos do programa ou comportamento inesperado. Para gerenciar com elegância os erros de execução e garantir a estabilidade do programa, os desenvolvedores usam técnicas de tratamento de erros como manipulação de exceção .