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 de ponteiros para funções é passá-los como argumentos para outras funções. Isso permite inserir 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 definir a operação diretamente no código, 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 a função que for 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 dependendo de qual função passamos. Esse padrão é fundamental para escrever código flexível e reutilizável. Você escreve a estrutura uma vez, e quem usa sua função fornece a lógica específica de que precisa.

Desafio

Fácil

Escreva uma função apply_twice que receba dois números 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 aceita um ponteiro para função.

Observação: são necessárias apenas as funções. Os testes chamam apply_twice diretamente e verificam o valor retornado, então não leia a entrada nem imprima nada.

Estrutura necessária:

Defina um typedef chamado Operation para um ponteiro para função que recebe dois parâmetros int e retorna um int
Defina duas funções de operação: add (retorna a + b) e multiply (retorna a * b)
Defina uma função compute que recebe dois números inteiros e um ponteiro para função Operation e, em seguida, retorna o resultado da chamada à operação
Em apply_twice, selecione a operação apropriada com base no código e, em seguida, 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 Proteções de inclusão Arquivos-fonte Funções estáticas Revisão: calculadora modular

4Encapsulamento

Conceito de ponteiros opacos Definindo structs opacas Getters e setters Validação em setters Revisã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 ArgumentosRevisão: Despacho da Calculadora

10Contêineres Genéricos

Revisão de ponteiros void Invólucro genérico Troca genérica Comparação genérica Revisão: array genérico

3Ciclo de vida do objeto

Padrão de construtor Padrão de destrutor Inicialização da pilha Cópia profunda Revisão: wrapper de String

6Herança por composição

Incorporação de struct Regra do primeiro membro Acessando membros do tipo pai Upcasting Revisã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 Contêiner de formas

12Desafios Finais

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

Pratique por conta própria: Compilador de C online