Declaração (ciência da computação) - Statement (computer science)

Na programação de computadores , uma instrução é uma unidade sintática de uma linguagem de programação imperativa que expressa alguma ação a ser executada. Um programa escrito em tal linguagem é formado por uma sequência de uma ou mais instruções. Uma instrução pode ter componentes internos (por exemplo, expressões ).

Muitas linguagens de programação (por exemplo , Ada , Algol 60 , C , Java , Pascal ) fazem uma distinção entre instruções e definições / declarações . Uma definição ou declaração especifica os dados nos quais um programa deve operar, enquanto uma instrução especifica as ações a serem tomadas com esses dados.

As declarações que não podem conter outras declarações são simples ; aqueles que podem conter outras declarações são compostos .

A aparência de uma instrução (e de fato de um programa) é determinada por sua sintaxe ou gramática. O significado de uma declaração é determinado por sua semântica .

Afirmações simples

As declarações simples são completas em si mesmas; isso inclui atribuições, chamadas de sub-rotina e algumas instruções que podem afetar significativamente o fluxo de controle do programa (por exemplo , ir para , retornar , parar / interromper). Em algumas linguagens, entrada e saída, asserções e saídas são tratadas por instruções especiais, enquanto outras linguagens usam chamadas para sub-rotinas predefinidas.

  • atribuição
    • Fortran: variable = expression
    • Pascal, Algol 60, Ada: variable := expression;
    • C, C #, C ++, PHP, Java: variable = expression;
  • ligar
    • Fortran: CALL subroutine name(parameters)
    • C, C ++, Java, PHP, Pascal, Ada: subroutine name(parameters);
  • afirmação
    • C, C ++, PHP: assert(relational expression);
    • Java: assert relational expression;
  • vamos para
    • Fortran: GOTO numbered-label
    • Algol 60: goto label;
    • C, C ++, PHP, Pascal: goto label;
  • Retorna
    • Fortran: RETURN value
    • C, C ++, Java, PHP: return value;

Declarações compostas

As declarações compostas podem conter (sequências de) declarações, aninhadas em qualquer profundidade razoável e geralmente envolvem testes para decidir se devem ou não obedecer ou repetir as declarações contidas.

Notação para os seguintes exemplos:
  • <statement> é qualquer declaração única (pode ser simples ou composta).
  • <sequence> é qualquer sequência de zero ou mais <statements>
Algumas linguagens de programação fornecem uma maneira geral de agrupar instruções, de modo que qualquer <instrução> única possa ser substituída por um grupo:
  • Algol 60: begin <sequence> end
  • Pascal: begin <sequence> end
  • C, PHP, Java: { <sequence> }
Outras linguagens de programação têm um terminador especial diferente em cada tipo de instrução composta, de modo que uma ou mais instruções são tratadas automaticamente como um grupo:
  • Ada: if test then <sequence> end if;

Muitas instruções compostas são comandos de loop ou comandos de escolha. Em teoria, apenas um de cada um desses tipos de comandos é necessário. Na prática, existem vários casos especiais que ocorrem com bastante frequência; eles podem tornar um programa mais fácil de entender, podem tornar a programação mais fácil e, muitas vezes, podem ser implementados com muito mais eficiência. Existem muitas sutilezas não mencionadas aqui; consulte os artigos vinculados para obter detalhes.

  • loop controlado por contagem :
    • Algol 60: for index := 1 step 1 until limit do <statement> ;
    • Pascal: for index := 1 to limit do <statement> ;
    • C, Java: for ( index = 1; index <= limit; index += 1) <statement> ;
    • Ada: for index in 1..limit loop <sequence> end loop
    • Fortran 90:
Índice DO = 1, limite
<sequência>
FIM DO
  • loop controlado por condição com teste no início do loop:
    • Algol 60: for index := expression while test do <statement> ;
    • Pascal: while test do <statement> ;
    • C, Java: while (test) <statement> ;
    • Ada: while test loop <sequence> end loop
    • Fortran 90:
FAÇA ENQUANTO (teste)
<sequência>
FIM DO
  • loop controlado por condição com teste no final do loop:
    • Pascal: repeat <sequence> until test; { note reversed test}
    • C, Java: do { <sequence> } while (test) ;
    • Ada: loop <sequence> exit when test; end loop;
  • loop controlado por condição com teste no meio do loop:
    • C: do { <sequence> if (test) break; <sequence> } while (true) ;
    • Ada: loop <sequence> exit when test; <sequence> end loop;
  • Situação simples de instrução if :
    • Algol 60:if test then <unconditional statement> ;
    • Pascal:if test then <statement> ;
    • C, Java: if (test) <statement> ;
    • Ada: if test then <sequence> end if;
    • Fortran 77+:
SE (teste) ENTÃO
<sequência>
FIM SE
  • escolha bidirecional da instrução if :
    • Algol 60:if test then <unconditional statement> else <statement> ;
    • Pascal:if test then <statement> else <statement> ;
    • C, Java: it (test) <statement> else <statement> ;
    • Ada: if test then <sequence> else <sequence> end if;
    • Fortran 77+:
SE (teste) ENTÃO
<sequência>
OUTRO
<sequência>
FIM SE
  • Escolha de múltiplas vias de instrução case / switch :
    • Pascal: case c of 'a': alert(); 'q': quit(); end;
    • Ada: case c is when 'a' => alert(); when 'q' => quit(); end case;
    • C, Java: switch (c) { case 'a': alert(); break; case 'q': quit(); break; }
  • Tratamento de exceções :
    • Ada: begin protected code except when exception specification => exception handler
    • Java: try { protected code } catch (exception specification) { exception handler } finally { cleanup }
    • Pitão: try: protected code except exception specification: exception handler else: no exceptions finally: cleanup

Sintaxe

Artigo principal: Sintaxe (linguagens de programação)

Além de atribuições e chamadas de sub-rotina, a maioria dos idiomas inicia cada instrução com uma palavra especial (por exemplo, goto, if, while, etc.), conforme mostrado nos exemplos acima. Vários métodos foram usados ​​para descrever a forma de declarações em diferentes linguagens; os métodos mais formais tendem a ser mais precisos:

  • Algol 60 usou a forma Backus – Naur (BNF) que estabeleceu um novo nível para a especificação da gramática da linguagem.
  • Até o Fortran 77, o idioma era descrito em prosa inglesa com exemplos, do Fortran 90 em diante, o idioma era descrito usando uma variante do BNF.
  • Cobol usou uma metalinguagem bidimensional.
  • Pascal usou diagramas de sintaxe e BNF equivalente.

O BNF usa recursão para expressar repetição, então várias extensões foram propostas para permitir a indicação direta de repetição.

Declarações e palavras-chave

Algumas gramáticas de linguagens de programação reservam palavras-chave ou marcam-nas de maneira especial e não permitem que sejam usadas como identificadores . Isso geralmente leva a gramáticas que são mais fáceis de analisar , exigindo menos antecipação .

Sem palavras-chave distintas

Fortran e PL / 1 não possuem palavras-chave reservadas, permitindo afirmações como:

  • em PL / 1:
    • IF IF = THEN THEN ... (o segundo IFe o primeiro THENsão variáveis).
  • em Fortran:
    • IF (A) X = 10... declaração condicional (com outras variantes)
    • IF (A) = 2 atribuição a uma variável subscrita chamada IF
Como os espaços eram opcionais até o Fortran 95, um erro de digitação poderia mudar completamente o significado de uma declaração:
  • DO 10 I = 1,5 início de um loop com I correndo de 1 a 5
  • DO 10 I = 1.5 atribuição do valor 1,5 à variável DO10I

Palavras sinalizadas

Artigo principal: Stropping (sintaxe)

Em Algol 60 e Algol 68, tokens especiais foram distinguidos explicitamente: para publicação, em negrito, por exemplo begin; para programação, com alguma marcação especial, por exemplo, uma bandeira ( 'begin), aspas ( 'begin') ou sublinhado ( beginno Elliott 503 ). Isso é chamado de "stropping".

Os tokens que fazem parte da sintaxe da linguagem, portanto, não entram em conflito com os nomes definidos pelo programador.

Palavras-chave reservadas

Artigo principal: Palavra reservada

Certos nomes são reservados como parte da linguagem de programação e não podem ser usados ​​como nomes definidos pelo programador. A maioria das linguagens de programação mais populares usa palavras-chave reservadas. Os primeiros exemplos incluem FLOW-MATIC (1953) e COBOL (1959). Desde 1970, outros exemplos incluem Ada, C, C ++, Java e Pascal. O número de palavras reservadas depende do idioma: C tem cerca de 30, enquanto COBOL tem cerca de 400.

Semântica

Artigo principal: Semântica (ciência da computação)

A semântica se preocupa com o significado de um programa. Os documentos de padrões para muitas linguagens de programação usam BNF ou algum equivalente para expressar a sintaxe / gramática de uma maneira bastante formal e precisa, mas a semântica / significado do programa é geralmente descrito usando exemplos e prosa em inglês. Isso pode resultar em ambiguidade. Em algumas descrições de linguagem, o significado de declarações compostas é definido pelo uso de construções 'mais simples', por exemplo, um loop while pode ser definido por uma combinação de testes, saltos e rótulos, usando ife goto.

O artigo de semântica descreve vários formalismos matemáticos / lógicos que foram usados ​​para especificar a semântica de uma maneira precisa; estes são geralmente mais complicados do que o BNF, e nenhuma abordagem única é geralmente aceita como o caminho a percorrer. Algumas abordagens definem efetivamente um intérprete para a linguagem, algumas usam lógica formal para raciocinar sobre um programa, algumas anexam afixos a entidades sintáticas para garantir consistência, etc.

Expressões

Freqüentemente, é feita uma distinção entre instruções, que são executadas, e expressões , que são avaliadas. O valor obtido de uma expressão é frequentemente usado como parte de uma instrução, por exemplo, atribuição variable := expression;

Algumas linguagens de programação (por exemplo, C, C ++) permitem que algumas instruções forneçam um resultado (tecnicamente todas as instruções fornecem um resultado, mas esse resultado é frequentemente do tipo 'void' e não pode ser usado para nada). A declaração mais útil que fornece um resultado é uma atribuição, o resultado sendo o valor recém-atribuído.

Isso pode ser útil para inicialização múltipla:

i = j = 0; que é tratado como i = (j = 0);

Isso também pode resultar em um simples problema com o dedo, alterando completamente o significado de algum código:

if (i == j) {. . . };testa para ver se ié igual aj
if (i = j) { . . . };atribui o valor de ja ie testa para ver se esse valor é diferente de zero.

Algumas linguagens (Algol 60, Pascal) permitem atribuições múltiplas, mas não permitem que as atribuições apareçam nas expressões.

Extensibilidade

A maioria das linguagens tem um conjunto fixo de instruções definidas pela linguagem, mas houve experimentos com linguagens extensíveis que permitem ao programador definir novas instruções.

Veja também

Referências

links externos