Neste artigo, exploraremos como implementar a inversão de strings utilizando ponteiros em linguagem C. Este é um problema clássico que demonstra eficamzente o poder dos ponteiros na manipulação de dados.

Requisitos do Problema

Desenvolver uma função capaz de inverter o conteúdo de uma string, incluindo espaços e caracteres especiais.

1. Captura de Entrada do Teclado

Para inverter uma string, primeiro precisamos capturar a entrada do usuário. Existem diferentes abordagens para esta tarefa em C:

1.1. Utilizando a função scanf()

A função scanf() pode capturar entrada, mas tem limitações com espaços:

#include <stdio.h>
int main() {
    char texto[128];
    scanf("%s", texto);
    printf("Capturado: %s\n", texto);
    return 0;
}</stdio.h>

Exemplo:

• Entrada: "ola mundo"
• Saída: "ola" (apenas a primeira palavra)

1.2. Utilizando a função fgets()

Uma alternativa mais adequada é a função fgets(), que captura toda a linha incluindo espaços:

#include <stdio.h>
int main() {
    char texto[128];
    printf("Digite uma string: ");
    fgets(texto, sizeof(texto), stdin);
    printf("String capturada: %s", texto);
    return 0;
}</stdio.h>

1.3. Comparando as funções de entrada

Após análise, optamos por utiilzar fgets() por sua capacidade de capturar strings com espaços completas.

2. Implementação Básica com Arrays

Antes de utilizar ponteiros, podemos resolver o problema com arrays:

#include <stdio.h>
#include <string.h>
void inverter_com_array(char texto[], int tamanho) {
    char temp[tamanho];
    for (int i = 0; i < tamanho; i++) {
        temp[i] = texto[i];
    }
    for (int j = 0; j < tamanho; j++) {
        texto[j] = temp[tamanho - 1 - j];
    }
}

int main() {
    char meu_texto[100];
    printf("Digite uma string: ");
    fgets(meu_texto, sizeof(meu_texto), stdin);
    
    int tamanho = strlen(meu_texto);
    if (tamanho > 0 && meu_texto[tamanho-1] == '\n') {
        meu_texto[tamanho-1] = '\0';
        tamanho--;
    }
    
    inverter_com_array(meu_texto, tamanho);
    printf("String invertida: %s\n", meu_texto);
    return 0;
}</string.h></stdio.h>

3. Implementação com Ponteiros

Agora, vamos resolver o problema utilizando ponteiros, que é a aboradgem mais eficiente:

#include <stdio.h>
#include <string.h>

void inverter_com_ponteiros(char *texto) {
    char *inicio = texto;
    char *fim = texto + strlen(texto) - 1;
    
    while (inicio < fim) {
        // Troca de caracteres usando ponteiros
        char temp = *inicio;
        *inicio = *fim;
        *fim = temp;
        
        // Movimentação dos ponteiros
        inicio++;
        fim--;
    }
}

int main() {
    char entrada[128];
    
    printf("Digite uma string: ");
    fgets(entrada, sizeof(entrada), stdin);
    
    // Remover o caractere de nova linha, se presente
    size_t tam = strlen(entrada);
    if (tam > 0 && entrada[tam-1] == '\n') {
        entrada[tam-1] = '\0';
    }
    
    inverter_com_ponteiros(entrada);
    printf("Resultado invertido: %s\n", entrada);
    
    return 0;
}</string.h></stdio.h>

4. Otimização para Entrada Contínua

Para permitir múltiplas entradas sem reiniciar o programa, podemos implementar um loop com limpeza de memória:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

void inverter_string(char *texto) {
    char *inicio = texto;
    char *fim = texto + strlen(texto) - 1;
    
    while (inicio < fim) {
        char temp = *inicio;
        *inicio = *fim;
        *fim = temp;
        inicio++;
        fim--;
    }
}

int main() {
    char buffer[128];
    
    while (1) {
        printf("Digite uma string (ou 'sair' para encerrar): ");
        fgets(buffer, sizeof(buffer), stdin);
        
        // Remover nova linha
        size_t tam = strlen(buffer);
        if (tam > 0 && buffer[tam-1] == '\n') {
            buffer[tam-1] = '\0';
        }
        
        // Verificar condição de saída
        if (strcmp(buffer, "sair") == 0) {
            break;
        }
        
        inverter_string(buffer);
        printf("Invertida: %s\n", buffer);
        
        // Limpar o buffer
        memset(buffer, 0, sizeof(buffer));
    }
    
    return 0;
}</stdlib.h></string.h></stdio.h>

Esta implementação permite que o usuário continue inserindo strings até digitar "sair", com a memória sendo limpa a cada iteração para evitar problemas com dados residuais.