C

#include <stdio.h>
 
int sum(int x, int y)
{
    return x+y;
}
int subtract(int x, int y)
{
    return x-y;
}
int operation(int a, int b, int (*op)(int, int))
{
    return op(a, b);
}
int main(void)
{
    int a = 10;
    int b = 5;
    int result = operation(a, b, sum);
    printf("result = %d \n", result);

    result = operation(a, b, subtract);
    printf("result = %d \n", result);
    return 0;
}

С использованием псевдонимов:

#include <stdio.h>
 
typedef int (binary_op)(int, int);

int sum(int x, int y) { return x+y; }
int subtract(int x, int y) { return x-y;}

int operation(int a, int b, binary_op op) { return op(a, b);}

int main(void)
{
    int a = 10;
    int b = 5;
    int result = operation(a, b, sum);
    printf("result = %d \n", result);

    result = operation(a, b, subtract);
    printf("result = %d \n", result);
    return 0;
}

C++

#include <iostream>
 
int sum(int, int);
int subtract(int, int);
int operation(int, int, int(*)(int, int));	// третий параметр - указатель на функцию
 
int main()
{
    int a{10};
    int b{6};
    int result = operation(a, b, sum);
    std::cout << "result: " << result << std::endl;
 
    result = operation(a, b, subtract);
    std::cout << "result: " << result << std::endl;
}
 
int sum(int x, int y)
{
    return x + y;
}
int subtract(int x, int y)
{
    return x - y;
}
int operation(int a, int b, int(*op)(int, int))
{
    return op(a, b);
}

С использованием псевдонимов

#include <iostream>
 
// BinaryOp представляет указатель на функцию типа int (*)(int, int)
using BinaryOp = int (*)(int, int);

int sum(int, int);
int subtract(int, int);
void do_operation(int, int, BinaryOp);

int main()
{
    do_operation(10, 6, sum);		// 16
    do_operation(10, 6, subtract);	// 4
}
void do_operation(int a, int b, BinaryOp op)
{
	double result = op(a, b);
	std::cout << result << std::endl;
}
int sum(int x, int y){  return x + y;}
int subtract(int x, int y){  return x - y;}

C#

С использованием встроенных делегатов:

int a = 10;
int b = 6;
int result = Operation(a, b, Sum); // 16
Console.WriteLine($"Result = {result}");
result = Operation(a, b, Subtract); // 4
Console.WriteLine($"Result = {result}");


int Operation(int a, int b, Func<int, int, int> func){
    return func(a, b);
}
int Sum(int a, int b) => a+ b;
int Subtract(int a, int b) => a - b;

С определением своих делегатов:

int a = 10;
int b = 6;
int result = Operation(a, b, Sum); // 16
Console.WriteLine($"Result = {result}");
result = Operation(a, b, Subtract); // 4
Console.WriteLine($"Result = {result}");


int Operation(int a, int b, BinaryOp func){
    return func(a, b);
}
int Sum(int a, int b) => a+ b;
int Subtract(int a, int b) => a - b;
// BinaryOp представляет метод, который принимает два числа int и возвращает int
delegate int BinaryOp (int a, int b);

Dart

void main() {
     
    int a = 10;
    int b = 6;
    int result = operation(a, b, sum); // 16
    print("Result = $result");
    result = operation(a, b, subtract); // 4
    print("Result = $result");
}
int operation(int a, int b, Function func){
    return func(a, b);
}
int sum(int a, int b) => a+ b;
int subtract(int a, int b) => a - b;

F#

let operation a b func =  func a b

let sum a b  = a+ b
let subtract a b = a - b

let a = 10;
let b = 6;
let mutable result = operation a b sum   // 16
printfn $"Result = {result}"
result <- operation a b subtract         // 4
printfn $"Result = {result}"

JavaScript

function operation(a, b, func){
    return func(a, b);
}
function sum(a, b) { return a + b};
function subtract(a, b) { return a - b};

const a = 10;
const b = 6;
let result = operation(a, b, sum); // 16
console.log("Result = ",result);
result = operation(a, b, subtract); // 4
console.log("Result = ",result);

Kotlin

fun main() {
    val a = 10
    val b = 6
    var result = operation(a, b, ::sum)     // 16
    println("Result = $result")
    result = operation(a, b, ::subtract)    // 4
    println("Result = $result")
}
fun operation(a: Int, b: Int, func: (Int, Int)->Int) : Int{
    return func(a, b)
}
fun sum(a: Int, b: Int) = a + b
fun subtract(a: Int, b: Int) = a - b

Python

def operation(a, b, func): 
    return func(a, b)

def sum(a, b): return a + b
def subtract(a, b):  return a - b

a = 10
b = 6
result = operation(a, b, sum)   # 16
print("Result = ", result)

result = operation(a, b, subtract)  # 4
print("Result = ", result)

Rust

fn operation(a: i32, b: i32, func: fn(i32, i32)->i32) -> i32{
    return func(a, b);
}
fn sum(a: i32, b: i32) -> i32 { a + b}
fn subtract(a: i32, b: i32) -> i32 { a - b}

fn main(){
  
    let a = 10;
    let b = 6;
    let mut result = operation(a, b, sum);     // 16
    println!("Result = {}", result);
    result = operation(a, b, subtract);    // 4
    println!("Result = {}", result);
}