|
MC102 |
| STRINGS |
Até agora vimos como ler, escrever e lidar com caracteres. O problema é que, muitas vezes, queremos lidar com palavras ou frases. Como fazemos, então, para ler uma frase que o usuário digita?
Um possível algoritmo seria:
enquanto o usuário não digitou < enter >
leio o caracter
guardo o caracter lido
|
e onde guardaríamos esses caracteres? Poderia ser em um vetor de caracteres. Um tanto quanto complicado, não? Bom, acontece que o Pascal descomplicou isso, criando o tipo String
PROGRAM P;
VAR s : String;
BEGIN
writeln('Sua frase: ');
readln(s);
writeln('Você disse: ',s)
END.
|
O tipo string guarda uma cadeia de caracteres, da mesma forma que um vetor de caracteres. Assim, ao rodar o programa acima teríamos
sua frase: essa é minha frase< enter > Você disse: essa é minha frase |
Simples, não?
Uma coisa interessante sobre Strings é que o Pascal os trata como vetores de caracteres. Na verdade, String não é exatamente um ARRAY[1..255] OF char, mas é quase.
Agora espera um pouco. De onde veio esse 1..255? Pois é! String, em Pascal, é limitado a 255 caracteres.
Mas, e se quisermos um string maior ou menor? Basta definir o tamanho quando da declaração da variável:
VAR s1 : String[10]; {s1 conterá no máximo 10 caracteres}
s2 : String[1000]; {s2 conterá no máximo 1000 caracteres}
|
Ou seja, de uma forma geral:
VAR nome : String[limite];
ou
VAR nome : String; {255 é o limite}
|
Também posso declarar tipos com strings:
TYPE nomes : String[20];
endereco : String[300];
VAR nome : nomes;
end : endereco;
|
Pelo fato do String ser semelhante a um vetor, posso fazer:
PROGRAM P;
VAR s : String;
BEGIN
writeln('Sua frase: ');
readln(s);
writeln('Você disse: ',s);
writeln(s[4]); {escreve o "a" de "essa é minha frase"}
s[5] := 'z'; {agora s contém "essazé minha frase" - mudei o 5º caracter}
END.
|
Ou seja, posso usar o String como vetor de caracteres.
mas será que a única vantagem de Strings é dar um nome a ARRAY[1..255] OF char? Não! Pascal tem facilidades embutidas. Por exemplo, para concatenar (juntar) 2 strings basta usar o sinal "+":
PROGRAM P;
VAR s1,s2,s3 : String;
BEGIN
readln(s1);
readln(s2);
writeln(s1+s2);
s3 := s1 + s2;
writeln(s3)
END.
|
Nesse caso, se a entrada for:
Alô Mundo |
A saída será:
AlôMundo AlôMundo |
Sendo o segundo "AlôMundo" o conteúdo da variável s3.
Agora, como abastecemos uma variável string?
PROGRAM P;
VAR s1,s2,s3,s4 : String;
BEGIN
readln(s1); {leio s1}
readln(s2); {leio s2}
s4 := 'Alô mundão!'; {carrego s4}
s3 := s1 + ' -- ' + s2;
s2 := s4;
writeln('s1: ',s3);
writeln('s2: ',s3);
writeln('s3: ',s3);
writeln('s4: ',s3)
END.
|
Repare nas aspas simples. É como em char. Se a entrada para esse programa for:
Alô Mundo |
A saída será:
Alô Alô mundão! Alô -- Mundo Alô mundão! |
Agora vamos ver algumas funções para tratamento de strings:
Length(s : String) : Integer: Retorna o número de caracteres do string s.
VAR s : string;
n : integer;
BEGIN
s := 'Alô mundo!';
n := Length(s); {n terá 10}
n := Length('Teste do length'); {n terá 15}
END.
|
Copy(s : String; inicio, tamanho : integer) : String: Retorna um substring de s, começando em início e com o tamanho especificado.
VAR s : string;
l : string;
BEGIN
s := 'Alô mundo!';
l := Copy(s,2,5); {l terá 'lô mu'}
l := Copy('Testando copy!',5,4); {l terá 'ando'}
END.
|
Delete(VAR s : String; começo, tamanho : integer): Elimita parte do string s, começa em início com o tamanho especificado.
VAR s : string;
l : string;
BEGIN
s := 'Alô mundo!';
Delete(s,3,5); {s terá 'Aldo', eliminando 'ô mun'}
END.
|
Str(x; VAR s : string) ou str(x:largura; VAR s : string) ou str(x:largura:decimais; VAR s : string): Transforma um número x em sua prepresentação string. x pode ser integer ou real, s terá x na forma string com largura e casas decimais especificadas.
VAR s : string;
x : real;
BEGIN
x := 3.14;
Str(x,s); {s terá '3.14'}
Str(-12,s); {s terá '-12'}
END.
|