Introdução as strings: o que são, como declarar e inicializar – O Operador \0

 Após nosso estudo sobre vetores e das noções sobre ponteiros, vamos usar esses conhecimentos obtidos em nosso curso online de C.

Tente achar um programa que não tenha nada escrito. Que não seja necessário ler ou informar alguma letra ou palavra.

Até nas calculadoras temos que inserir caracteres (+, -, *, % etc).

Essa seção é totalmente dedicada a escrita, suas bibliotecas, funções, funcionamento e detalhes. Sim, vamos aprender a escrever em C, nesta seção de nossa apostila.

• Download de nossa apostila: Apostila de C
• Clique aqui e tire seu certificado!

 O que são Strings em linguagem C

Não foi à toa que ensinamos vetores antes de ensinarmos strings.

String é um vetor de caracteres com um delimitador que indica o final da string: \0

Por exemplo, para escrever “ C Progressivo”, seria necessário declararmos 13 caracteres e preenchê-los um por um, o que, obviamente é inviável, pois daria muito trabalho.

Imagine escrever textos longos com variáveis do tipo char puras.

Para contornar isso, o C trata vetores de caracteres de uma forma muito especial, com certas ‘regalias’, detalhes e opções, em relação aos outros tipos de vetores.

Na verdade, já vínhamos usando strings em nosso curso de C, dentro da função printf.

Podemos diferenciar as strings dos caracteres, porquê as strings aparecem dentro de aspas duplas, e os caracteres dentro de aspas simples.

“Curso C Progressivo” -> String

“C” -> String

‘C’ -> Caractere

O caractere especial delimitador de strings: \0

Antes, porém, de ensinarmos a declarar, inicializar e usar strings em C, temos que falar sobre esse caractere especial: \0

Esse caractere é o 0 do código ASCII (não é o caractere 0, é o elemento de número 0 do código ASCII), e é o delimitador de final de string.

Ou seja, ele representa o fim de uma string.

Se não tiver o delimitador ao fim de um vetor de caracteres, não é string, é apenas um vetor de caracteres (sim, são coisas diferentes).

Como declarar e inicializar Strings em C

Para declarar string em C, não há segredo, pois é a mesma coisa de declarar um vetor de variáveis do tipo char.

A sintaxe é sempre a seguinte:

char nome_da_string[tamanho];

Aqui, porém, vale uma ressalva muito importante que geralmente os programadores C iniciantes esquecem: o caractere delimitador - \0 – também fará parte da string.

Ou seja, ele conta no número de caracteres, no tamanho da String.

Por exemplo: “C Progressivo”

Quantos caracteres existem? 13 não é? Mas o número total de caracteres é 14, pois o caractere \0 também vai ‘comer’ uma variável do tipo char.

Então, para declarar uma string que vai armazenar “C Progressivo”, temos que fazer:

char curso_de_C[14];

Logo, sempre que formos declarar uma string, temos que levar em consideração no seu tamanho o caractere delimitador. No exemplo que demos, temos que declarar uma string que armazene 14 caracteres ou mais.

Como inicializar strings em C

Lembrando que as strings estão entre aspas, podemos ter declarado e inicializado essa string assim:

char curso[14] = “C Progressivo”;

E o caractere delimitador? O C coloca, automaticamente, ao fim da string.

Podemos fazer assim também:

char curso[] = “C Progressivo”;

Que lembra o que fazíamos nos vetores. Desse jeito, o C vai alocar o número exato de caracteres necessários, que no caso é 14 (13 para nossa frase mais 1 para o \0).

Outra possibilidade de carga automática, onde o C aloca o número certo de caracteres, é através de ponteiros. Lembra que dissemos que o nome do vetor é,  na verdade, um endereço de memória? Endereço do primeiro elemento do vetor?

Podemos então inicializar uma string através de um ponteiro para o tipo char:

char *curso = “C Progressivo”;

Quando formos estudar e criar as funções da biblioteca string.h, que nos fornece diversas opções para trabalhar com strings, vamos usar bastante os conceitos de ponteiros.

Por fim, podemos inicializar as strings da maneira mais ‘trabalhosa’, que é caractere por caractere onde,
mais uma vez, o C colocar o delimitador de string \0 na última posição:

char curso[14] = {‘C’, ‘ ‘, ‘P’, ‘r’, ‘o’, ‘g’, ‘r’, ‘e’, ‘s’, ‘s’, ‘i’, ‘v’, ’o’};

E se declararmos com um tamanho maior que o texto? Por exemplo:

char curso[2112] = “C Progressivo”;

Da posição 0 até a 12, existirão os caracteres da frase.

Na posição 13,  o C coloca o caractere delimitador, sinalizando o final da string.

E nas outras posições? Lixo.

Exemplo de código: Declarando, Inicializando e Exibindo strings em C

Declare uma string e inicialize. A seguir, exiba essa string na tela.

Vamos declarar uma string de 20 caracteres.

Podemos preencher a string com que caractere quisermos, mas a última posição da string é sempre o delimitador \0.

O C coloca esse delimitador sempre após o último caractere inserido.

Como nosso vetor tem 20 posições, podemos preencher, no máximo, até a posição 18.

Como usamos somente a frase “C Progressivo”, de 13 caracteres, o caractere \0 será o 14º caractere.

Vamos usar o primeiro laço for para imprimir todos os caracteres da string ‘curso’.

Note que o C imprime todos os caracteres antes do \0, e depois dele, nenhum.

O segundo laço for faz com que nossa variável auxiliar inicie na posição 0 da string e vá até a posição em que encontra o \0. Quando encontra, o laço para e mostramos em que posição encontrou o delimitador.

#include <stdio.h>
// Curso C Progressivo: www.cprogessivo.net
// O melhor curso de C! Online e gratuito !
// Artigos, apostilas, tutoriais e vídeo-aulas sobre
// a linguagem de programação C !
 
int main(void)
{
    char curso[20] = "C Progressivo";
    int count;
 
    for(count=0 ; count < 20 ; count++)
        printf("%c",curso[count]);
 
    for(count=0 ; curso[count] != '\0' ; count++)
            ;
    printf("\nO '\\0' esta na posicao %d da string\n", count);

    return 0;
}

Na verdade, existem maneiras bem mais simples de se exibir strings, que você aprenderá no próximo tutorial de nosso curso online de C.
Decidimos ensinar dessa maneira para você saber o que ocorre por debaixo dos panos, ver o caractere delimitador atuando de verdade.