Passando Funções como Argumentos

Parte da seção Programação Orientada a Objetos do Journey de C da Coddy. Lição 36 de 61.

Um dos usos mais poderosos dos ponteiros para funções é passá-los como argumentos para outras funções. Isso permite injetar um comportamento personalizado em uma função sem modificar seu código: uma técnica às vezes chamada de callback.

Considere uma função que realiza um cálculo com dois números. Em vez de codificar a operação diretamente, você pode aceitar um ponteiro para função que define qual operação realizar:

typedef int (*Operation)(int, int);

int compute(int a, int b, Operation op) {
    return op(a, b);
}

A função compute não sabe se está somando, subtraindo ou fazendo algo completamente diferente. Ela simplesmente chama qualquer função que seja passada para ela:

int add(int a, int b) { return a + b; }
int multiply(int a, int b) { return a * b; }

int main() {
    printf("%d\n", compute(5, 3, add));       // Saída: 8
    printf("%d\n", compute(5, 3, multiply));  // Saída: 15
    return 0;
}

Observe como a mesma função compute produz resultados diferentes com base na função que passamos. Esse padrão é fundamental para escrever código flexível e reutilizável. Você escreve a estrutura uma vez, e os usuários da sua função fornecem a lógica específica de que precisam.

Desafio

Fácil

Escreva uma função apply_twice que receba dois inteiros e um código de operação, aplique a operação aos números duas vezes em sequência e retorne o resultado final.

Sua função receberá um código de operação que determina qual operação usar. Você deve definir as funções de operação dentro da sua solução e passá-las para uma função auxiliar compute que aceite um ponteiro para função.

Observação: somente as funções são necessárias. Os testes chamam apply_twice diretamente e verificam seu valor de retorno; portanto, não leia a entrada nem imprima nada.

Estrutura obrigatória:

Defina um typedef chamado Operation para um ponteiro para função que receba dois parâmetros int e retorne um int
Defina duas funções de operação: add (retorna a + b) e multiply (retorna a * b)
Defina uma função compute que receba dois inteiros e um ponteiro para função Operation, e então retorne o resultado da chamada da operação
Em apply_twice, selecione a operação apropriada com base no código e use compute duas vezes: primeiro com os números originais e depois com o resultado e o segundo número novamente

Lógica:

Selecione a função de operação com base em op_code (1 = add, 2 = multiply)
Chame compute(a, b, operation) para obter um resultado intermediário
Chame compute(intermediate, b, operation) para obter o resultado final
Retorne o resultado final

Parâmetros:

a (int): Primeiro número
b (int): Segundo número
op_code (int): Código de operação (1 para add, 2 para multiply)

Retorno: O resultado após aplicar a operação duas vezes em sequência (int)

Exemplo: Com a = 5, b = 3, op_code = 1 (add):

Primeiro cálculo: 5 + 3 = 8
Segundo cálculo: 8 + 3 = 11
Retorno: 11

Com a = 2, b = 4, op_code = 2 (multiply):

Primeiro cálculo: 2 × 4 = 8
Segundo cálculo: 8 × 4 = 32
Retorno: 32

Experimente você mesmo

int apply_twice(int a, int b, int op_code) {
    // Escreva o código aqui
}

Teste seus conhecimentos

Esta lição inclui um quiz rápido. Comece a lição para respondê-lo e acompanhar seu progresso.

Todas as lições de Programação Orientada a Objetos

1Fundamentos da Programação Modular

Arquivos de Cabeçalho Include Guards Arquivos-Fonte Funções Estáticas Recapitulação: Calculadora Modular

4Encapsulamento

Conceito de Ponteiros Opacos Definindo Structs Opacas Getters e Setters Validação em Setters Recapitulação: Caixa Secreta

7Ponteiros para Funções

Declarando Ponteiros para Funções Chamando Ponteiros para Funções Typedef para Ponteiros para FunçõesPassando Funções como ArgumentosRecapitulação: Dispatch de Calculadora

10Contêineres Genéricos

Revisão de Ponteiros Void Wrapper Genérico Troca Genérica Comparação Genérica Revisão: Array Genérico

3Ciclo de Vida de Objetos

Padrão de Construtor Padrão de Destrutor Inicialização na Stack Cópia Profunda Recapitulação: String Wrapper

6Herança via Composição

Incorporação de Structs A Regra do Primeiro Membro Acessando Membros Pai Upcasting Recapitulação: Hierarquia de Formas

9Projeto: Desenhador de Formas

Visão Geral do Projeto Implementação do Círculo Implementação do Retângulo Uso Polimórfico Container de Formas

12Desafios Finais

Personagem de RPG Construtor de Strings Dinâmico Pilha Genérica Sistema de Eventos

Pratique por conta própria: Compilador de C online