Para as questões abaixo, suponha que você já tem a struct a seguir:
struct data {
    int dia, mes, ano;
};
struct pessoa {
    char nome[40];
    struct data nasc, admissao, saida;
    int identidade, cpf;
};
e também um vetor de funcionários
struct pessoa funcs [50];
Escreva um algoritmo que recebe o nome de um funcionário e imprime sua identidade.

Passo 1

O que o enunciado pede e quais informações temos:
  • Pede: escrever um algoritmo que recebe o nome de um funcionário e imprime sua identidade.
  • Dados já fornecidos no enunciado:
    • A struct dos dados de data:
      struct data {
          int dia, mes, ano;
      };
      
    • A struct da pessoa/funcionário:
      struct pessoa {
          char nome[40];
          struct data nasc, admissao, saida;
          int identidade, cpf;
      };
      
    • Um vetor de funcionários disponível:
      struct pessoa funcs[50];
      
  • Informações implícitas que precisamos assumir/usar:
    • Precisamos saber quantos elementos válidos existem em funcs (vou chamar isso de n_funcs). Sem esse número não dá para saber até onde procurar — então o algoritmo receberá também n_funcs (número de funcionários preenchidos) ou usará um critério de término.
    • O nome armazenado em funcs[i].nome é uma string C terminada em '\0' e tem até 39 caracteres úteis.
  • O que o algoritmo deve fazer exatamente:
    • Receber um nome (string) como entrada.
    • Procurar no vetor funcs por um funcionário cujo nome coincida com esse nome.
    • Se encontrar, imprimir o valor de identidade desse funcionário.
    • Se não encontrar, informar que não foi encontrado.

Passo 2

Plano de resolução (alto nível), sem codificar ainda:
  • Usar uma busca linear no vetor funcs (ou seja, verificar funcs[0], depois funcs[1], …, até funcs[n_funcs-1]) comparando o nome recebido com funcs[i].nome.
  • Para comparar strings em C usamos funções da biblioteca <string.h>, a mais direta é strcmp (compara exatamente, sensível a maiúsculas/minúsculas).
  • Como nomes frequentemente vêm com diferenças de caixa (ex.: “João” vs “joão”), vou implementar a comparação em modo case-insensitive para ser mais amigável na prova. Para isso converto as duas strings para minúsculas temporariamente e uso strcmp.
  • Ler o nome de entrada com fgets (seguro para evitar overflow) e remover o newline que fgets deixa.
  • Se encontrar correspondência, imprimir identidade e terminar. Se não encontrar após varrer todo o vetor, imprimir mensagem de “não encontrado”.

Passo 3

Explicando detalhadamente como comparar strings em C (a parte teórica que precisa ficar clara):
  • Em C, strings são vetores de char terminados em '\0'.
  • A função strcmp(const char *s1, const char *s2) (em <string.h>) retorna:
    • 0 se as strings forem exatamente iguais (mesmos caracteres na mesma ordem).
    • < 0 se s1 for lexicograficamente menor que s2.
    • 0 se s1 for maior que s2.
  • strcmp é sensível a maiúsculas/minúsculas. Para uma comparação “case-insensitive”, não padrão em ISO C, duas abordagens comuns:
    1. Usar strcasecmp (funciona em sistemas POSIX, mas não é padrão C).
    2. Converter ambas as strings para minúsculas (ou maiúsculas) temporariamente e usar strcmp. Essa opção é portátil e simples — é a que vou adotar.
  • Para converter para minúsculas usamos tolower em <ctype.h> para cada unsigned char da string.

Passo 4

Como ler o nome de entrada de forma segura e tratar o newline:
  • fgets(buffer, sizeof buffer, stdin) lê até sizeof buffer - 1 caracteres e garante terminação com '\0'.
  • Se o usuário pressionar Enter, fgets inclui o '\n' no final da string (se houver espaço). Então é necessário remover o '\n' final: descobrir o comprimento len = strlen(buffer) e, se len > 0 e buffer[len-1] == '\n', fazer buffer[len-1] = '\0'.
  • Essa rotina previne overflow e deixa a string pronta para comparar.

Passo 5

Definir a função que implementa o algoritmo (estrutura e assinatura):
  • Vou implementar uma função com essa assinatura:
    • void imprime_identidade(struct pessoa funcs[], int n_funcs, const char *nome_busca);
    • Parâmetros:
      • funcs[]: vetor de funcionários (já preenchido).
      • n_funcs: número de funcionários válidos no vetor (0 a 50).
      • nome_busca: o nome a procurar (string C).
  • O que essa função fará passo a passo:
    1. Converter nome_busca para uma versão minúscula temporária.
    2. Iterar i de 0 até n_funcs-1:
      • Converter funcs[i].nome para minúsculas em um buffer temporário.
      • Comparar os dois buffers com strcmp.
      • Se strcmp == 0, imprimir funcs[i].identidade e sair da função.
    3. Se terminar o loop sem encontrar, imprimir “Funcionário não encontrado” (ou mensagem similar).

Passo 6

Complexidade e justificativa do método:
  • A busca linear tem complexidade temporal O(n_funcs) no pior caso — é o método mais simples e suficiente aqui, já que n_funcs ≤ 50.
  • Complexidade espacial adicional é pequena (buffers temporários para as strings).
  • Método escolhido por ser:
    • Simples de implementar (boa para prova).
    • Razoável para o tamanho máximo conhecido (50).
    • Portátil (usa apenas funções padrão C como fgets, strlen, strcmp, tolower).

Passo 7

Código completo (explicado passo a passo acima). Este código:
  • Mostra a função imprime_identidade.
  • Mostra um main demonstrando como chamar a função (com um pequeno exemplo de preenchimento do vetor).
  • Observação: em sua prova provavelmente os dados já estarão preenchidos em funcs e haverá uma variável n_funcs; adapte chamando imprime_identidade(funcs, n_funcs, nome_lido);.

Resposta

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

struct data {
    int dia, mes, ano;
};
struct pessoa {
    char nome[40];
    struct data nasc, admissao, saida;
    int identidade, cpf;
};

/* Converte src para minúsculas em dst.
   dst deve ter espaço suficiente. */
void str_to_lower(const char *src, char *dst) {
    while (*src) {
        *dst = (char) tolower((unsigned char) *src);
        src++;
        dst++;
    }
    *dst = '\0';
}

/* Remove newline final deixado por fgets, se houver. */
void remove_newline(char *s) {
    size_t len = strlen(s);
    if (len > 0 && s[len - 1] == '\n') s[len - 1] = '\0';
}

/* Função que procura pelo nome e imprime a identidade.
   - funcs: vetor de funcionários (preenchido)
   - n_funcs: número de funcionários válidos no vetor
   - nome_busca: nome a procurar (string C) */
void imprime_identidade(struct pessoa funcs[], int n_funcs, const char *nome_busca) {
    char nome_baixo[40];
    char temp[40];

    /* converte nome buscado para minúsculas */
    str_to_lower(nome_busca, nome_baixo);

    for (int i = 0; i < n_funcs; i++) {
        /* converte o nome do funcionário para minúsculas em temp */
        str_to_lower(funcs[i].nome, temp);
        /* compara as versões em minúsculas */
        if (strcmp(temp, nome_baixo) == 0) {
            printf("Identidade: %d\n", funcs[i].identidade);
            return;
        }
    }
    printf("Funcionario nao encontrado\n");
}

/* Exemplo de uso */
int main(void) {
    struct pessoa funcs[50];
    int n_funcs = 2;

    /* Exemplo: preencher dois funcionários para demonstração */
    strncpy(funcs[0].nome, "Joao Silva", sizeof(funcs[0].nome));
    funcs[0].nome[sizeof(funcs[0].nome)-1] = '\0';
    funcs[0].identidade = 123456;

    strncpy(funcs[1].nome, "Maria Souza", sizeof(funcs[1].nome));
    funcs[1].nome[sizeof(funcs[1].nome)-1] = '\0';
    funcs[1].identidade = 654321;

    /* Ler o nome a procurar */
    char nome_busca[100];
    printf("Digite o nome do funcionario: ");
    if (fgets(nome_busca, sizeof(nome_busca), stdin) == NULL) return 0;
    remove_newline(nome_busca);

    /* Chamar a função que imprime a identidade */
    imprime_identidade(funcs, n_funcs, nome_busca);

    return 0;
}

Exercícios relacionados