Label (ciência da computação) - Label (computer science)
Um rótulo em uma linguagem de programação é uma sequência de caracteres que identifica um local dentro do código-fonte . Na maioria dos idiomas, os rótulos assumem a forma de um identificador , geralmente seguido por um caractere de pontuação (por exemplo, dois pontos ). Em muitas linguagens de programação de alto nível, o objetivo de um rótulo é atuar como o destino de uma GOTO instrução. Em assembly, os rótulos podem ser usados em qualquer lugar que um endereço possa (por exemplo, como o operando de uma instrução JMP ou MOV ). Também em Pascal e suas variações derivadas. Alguns idiomas, como Fortran e BASIC , oferecem suporte a rótulos numéricos. Os rótulos também são usados para identificar um ponto de entrada em uma seqüência compilada de instruções (por exemplo, durante a depuração ).
C
Em C, um rótulo identifica uma instrução no código. Uma única instrução pode ter vários rótulos. Os rótulos apenas indicam locais no código e chegar a um rótulo não afeta a execução real.
Rótulos de função
Os rótulos de função consistem em um identificador, seguido por dois pontos. Cada rótulo aponta para uma instrução em uma função e seu identificador deve ser exclusivo dentro dessa função. Outras funções podem usar o mesmo nome para um rótulo. Identificadores de rótulo ocupam seu próprio namespace - pode-se ter variáveis e funções com o mesmo nome de um rótulo.
void foo(int number)
{
if (number < 0)
goto error;
bar(number);
return;
error:
fprintf(stderr, "Invalid number!\n");
}
Aqui, o erro é o rótulo. A instrução goto pode ser usada para pular para uma instrução rotulada no código. Depois de a goto , a execução do programa continua com a instrução após o rótulo.
Trocar rótulos
Dois tipos de rótulos podem ser colocados em uma instrução switch. Um rótulo de caso consiste na palavra-chave case , seguida por uma expressão que é avaliada como constante inteira. Um rótulo padrão consiste na palavra-chave default . Rótulos de caso são usados para associar um valor inteiro a uma instrução no código. Quando uma instrução switch é alcançada, a execução do programa continua com a instrução após o rótulo case com valor que corresponde ao valor entre parênteses da switch. Se não houver esse rótulo de caso, mas houver um rótulo padrão, a execução do programa continua com a instrução após o rótulo padrão. Se não houver um rótulo padrão, a execução do programa continuará após a troca.
switch (die)
{
default:
printf("invalid\n");
break;
case 1:
case 3:
case 5:
printf("odd\n");
break;
case 2:
case 4:
case 6:
printf("even\n");
break;
}
Em uma única instrução switch , a constante inteira associada a cada rótulo de caso deve ser única. Pode ou não haver uma declaração padrão. Não há restrição na ordem dos rótulos em um switch. O requisito de que os valores dos rótulos de caso sejam avaliados como constantes inteiras dá ao compilador mais espaço para otimizações.
Exemplos
Javascript
Na linguagem JavaScript, as instruções de sintaxe podem ser precedidas pelo rótulo:
top: //Label the outermost for-loop.
for (var i = 0; i < 4; i++) {
for (var j = 0; j < 4; j++) {
if (j === 3 && i === 2) {
alert("i=" + i + ", j=" + j); //i=2, j=3
break top;
}
}
}
alert("i=" + i + ", j=" + j); //i=2, j=3
Também é possível usar a break instrução para quebrar os blocos de código:
top: {
console.log("foo")
console.log("bar")
break top
console.log("baz")
}
// Which would output:
// > foo
// > bar
Lisp Comum
Em Common Lisp existem duas maneiras de definir rótulos. O primeiro envolve o tagbody operador especial. Distinguindo seu uso de muitas outras linguagens de programação que permitem navegação global, como C , os rótulos só são acessíveis no contexto desse operador. Dentro de um, os tagbody rótulos são definidos como formulários que começam com um símbolo; a go forma especial permite uma transferência de controle entre esses rótulos.
(let ((iteration NIL))
(tagbody
start
(print 'started)
(setf iteration 0)
increase
(print iteration)
(incf iteration 1)
(go check)
check
(if (>= iteration 10)
(go end)
(go increase))
end
(print 'done)))
Um segundo método utiliza as macros do leitor e , o primeiro que rotula o objeto imediatamente a seguir, o último refere-se ao seu valor avaliado. Os rótulos, neste sentido, constituem antes uma alternativa às variáveis, declarando e inicializando uma “variável” e acessando-a. O espaço reservado n designa um inteiro decimal sem sinal escolhido que identifica o rótulo.
#n=#n##n=#n#
(progn
#1="hello"
(print #1#))
Além disso, alguns formulários permitem ou obrigam a declaração de um rótulo para posterior encaminhamento, incluindo o formulário especial block que prescreve uma nomenclatura e a loop macro que pode ser identificada por uma named cláusula. A saída imediata de um formulário nomeado é possível usando o return-from operador especial.
(block myblock
(loop for iteration from 0 do
(if (>= iteration 10)
(return-from myblock 'done)
(print iteration))))
(loop
named myloop
for iteration from 0
do (if (>= iteration 10)
(return-from myloop 'done)
(print iteration)))
De forma semelhante a C, as macros case , ccase , ecase , typecase , ctypecase e etypecase definir instruções switch.
(let ((my-value 5))
(case my-value
(1 (print "one"))
(2 (print "two"))
((3 4 5) (print "three four or five"))
(otherwise (print "any other value"))))
(let ((my-value 5))
(typecase my-value
(list (print "a list"))
(string (print "a string"))
(number (print "a number"))
(otherwise (print "any other type"))))