что означает обратный вызов в следующем коде? [Дубликат]

«В компьютерном программировании обратный вызов является ссылкой на исполняемый код или часть исполняемого кода, который передается в качестве аргумента другому коду. Это позволяет программному слою более низкого уровня вызывать подпрограмму (или функцию), определенную на уровне более высокого уровня ». - Wikipedia

Обратный вызов в C с использованием указателя функции

В C, обратный вызов реализуется с помощью Function Pointer. Функциональный указатель - как следует из названия, является указателем на функцию.

Например, int (* ptrFunc) ();

Здесь ptrFunc является указателем на функцию, которая не принимает аргументов и возвращает целое число. Не забудьте указать в скобках, иначе компилятор предположит, что ptrFunc - это нормальное имя функции, которое ничего не принимает и возвращает указатель на целое число.

Вот какой код для демонстрации функции.

#include<stdio.h>
int func(int, int);
int main(void)
{
    int result1,result2;
    /* declaring a pointer to a function which takes
       two int arguments and returns an integer as result */
    int (*ptrFunc)(int,int);

    /* assigning ptrFunc to func's address */                    
    ptrFunc=func;

    /* calling func() through explicit dereference */
    result1 = (*ptrFunc)(10,20);

    /* calling func() through implicit dereference */        
    result2 = ptrFunc(10,20);            
    printf("result1 = %d result2 = %d\n",result1,result2);
    return 0;
}

int func(int x, int y)
{
    return x+y;
}

Теперь попробуем понять концепцию Callback в C, используя указатель функции.

Полная программа имеет три файла: callback.c, reg_callback.h и reg_callback. c.

/* callback.c */
#include<stdio.h>
#include"reg_callback.h"

/* callback function definition goes here */
void my_callback(void)
{
    printf("inside my_callback\n");
}

int main(void)
{
    /* initialize function pointer to
    my_callback */
    callback ptr_my_callback=my_callback;                        
    printf("This is a program demonstrating function callback\n");
    /* register our callback function */
    register_callback(ptr_my_callback);                          
    printf("back inside main program\n");
    return 0;
}

/* reg_callback.h */
typedef void (*callback)(void);
void register_callback(callback ptr_reg_callback);


/* reg_callback.c */
#include<stdio.h>
#include"reg_callback.h"

/* registration goes here */
void register_callback(callback ptr_reg_callback)
{
    printf("inside register_callback\n");
    /* calling our callback function my_callback */
    (*ptr_reg_callback)();                               
}

Если мы запустим эту программу, выход будет

. Это программа, демонстрирующая обратный вызов функции внутри register_callback внутри my_callback внутри основной программы

Функция более высокого уровня вызывает функцию нижнего уровня как обычный вызов, а механизм обратного вызова позволяет функции нижнего уровня вызывать функцию более высокого уровня с помощью указателя на функцию обратного вызова.

Обратный вызов в Java с использованием интерфейса

Java не имеет понятия указателя функции Он реализует механизм обратного вызова через свой интерфейсный механизм ism Здесь вместо указателя функции мы объявляем интерфейс, имеющий метод, который будет вызываться, когда вызывающий заканчивает свою задачу

. Позвольте мне продемонстрировать это через пример:

Интерфейс обратного вызова

public interface Callback
{
    public void notify(Result result);
}

Caller или класс более высокого уровня

public Class Caller implements Callback
{
Callee ce = new Callee(this); //pass self to the callee

//Other functionality
//Call the Asynctask
ce.doAsynctask();

public void notify(Result result){
//Got the result after the callee has finished the task
//Can do whatever i want with the result
}
}

Функция Callee или нижнего уровня

public Class Callee {
Callback cb;
Callee(Callback cb){
this.cb = cb;
}

doAsynctask(){
//do the long running task
//get the result
cb.notify(result);//after the task is completed, notify the caller
}
}

Обратный вызов с использованием шаблона EventListener

• Элемент списка

Этот шаблон используется для уведомления от 0 до n номеров наблюдателей / слушателей о завершении конкретной задачи

• Элемент списка

Разница между механизмом обратного вызова и механизмом EventListener / Observer заключается в том, что при обратном вызове вызывающий абонент уведомляет одного вызывающего абонента, тогда как в Eventlisener / Observer вызывающий может уведомить любого, кто интересуется в этом случае (уведомление может перейти к некоторым другим частям приложения, которое не вызвало задачу).

Позвольте мне объяснить это на примере.

Интерфейс событий

public interface Events {

public void clickEvent();
public void longClickEvent();
}

package com.som_itsolutions.training.java.exampleeventlistener;

import java.util.ArrayList;
import java.util.Iterator;

public class Widget implements Events{

    ArrayList<OnClickEventListener> mClickEventListener = new ArrayList<OnClickEventListener>(); 
    ArrayList<OnLongClickEventListener> mLongClickEventListener = new ArrayList<OnLongClickEventListener>();

    @Override
    public void clickEvent() {
        // TODO Auto-generated method stub
        Iterator<OnClickEventListener> it = mClickEventListener.iterator();
                while(it.hasNext()){
                    OnClickEventListener li = it.next();
                    li.onClick(this);
                }   
    }
    @Override
    public void longClickEvent() {
        // TODO Auto-generated method stub
        Iterator<OnLongClickEventListener> it = mLongClickEventListener.iterator();
        while(it.hasNext()){
            OnLongClickEventListener li = it.next();
            li.onLongClick(this);
        }

    }

    public interface OnClickEventListener
    {
        public void onClick (Widget source);
    }

    public interface OnLongClickEventListener
    {
        public void onLongClick (Widget source);
    }

    public void setOnClickEventListner(OnClickEventListener li){
        mClickEventListener.add(li);
    }
    public void setOnLongClickEventListner(OnLongClickEventListener li){
        mLongClickEventListener.add(li);
    }
}

Клавиша класса

public class Button extends Widget{
private String mButtonText;
public Button (){
} 
public String getButtonText() {
return mButtonText;
}
public void setButtonText(String buttonText) {
this.mButtonText = buttonText;
}
}

Клавиша класса

public class CheckBox extends Widget{
private boolean checked;
public CheckBox() {
checked = false;
}
public boolean isChecked(){
return (checked == true);
}
public void setCheck(boolean checked){
this.checked = checked;
}
}

Класс активности

package com. som_itsolutions.training.java.exampleeventlistener;

public class Activity implements Widget.OnClickEventListener
{
    public Button mButton;
    public CheckBox mCheckBox;
    private static Activity mActivityHandler;
    public static Activity getActivityHandle(){
        return mActivityHandler;
    }
    public Activity ()
    {
        mActivityHandler = this;
        mButton = new Button();
        mButton.setOnClickEventListner(this);
        mCheckBox = new CheckBox();
        mCheckBox.setOnClickEventListner(this);
        } 
    public void onClick (Widget source)
    {
        if(source == mButton){
            mButton.setButtonText("Thank you for clicking me...");
            System.out.println(((Button) mButton).getButtonText());
        }
        if(source == mCheckBox){
            if(mCheckBox.isChecked()==false){
                mCheckBox.setCheck(true);
                System.out.println("The checkbox is checked...");
            }
            else{
                mCheckBox.setCheck(false);
                System.out.println("The checkbox is not checked...");
            }       
        }
    }
    public void doSomeWork(Widget source){
        source.clickEvent();
    }   
}

Другой класс

public class OtherClass implements Widget.OnClickEventListener{
Button mButton;
public OtherClass(){
mButton = Activity.getActivityHandle().mButton;
mButton.setOnClickEventListner(this);//interested in the click event                        //of the button
}
@Override
public void onClick(Widget source) {
if(source == mButton){
System.out.println("Other Class has also received the event notification...");
}
}

Основной класс

public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Activity a = new Activity();
OtherClass o = new OtherClass();
a.doSomeWork(a.mButton);
a.doSomeWork(a.mCheckBox);
}
}

Как вы можете видеть из приведенного выше кода , что у нас есть интерфейс, называемый событиями, который в основном перечисляет все события, которые могут произойти для нашего приложения. Класс Widget является базовым классом для всех компонентов пользовательского интерфейса, таких как Button, Checkbox. Эти компоненты пользовательского интерфейса являются объектами, которые фактически получают события из кода структуры. Класс Widget реализует интерфейс Events, а также имеет два вложенных интерфейса: OnClickEventListener & amp; OnLongClickEventListener

Эти два интерфейса отвечают за прослушивание событий, которые могут возникнуть в компонентах пользовательского интерфейса, созданных Widget, таких как Button или Checkbox. Поэтому, если мы сравним этот пример с предыдущим примером обратного вызова с использованием интерфейса Java, эти два интерфейса работают как интерфейс обратного вызова. Таким образом, код более высокого уровня (здесь Activity) реализует эти два интерфейса. И всякий раз, когда событие возникает с виджетами, вызывается код более высокого уровня (или метод этих интерфейсов, реализованный в коде более высокого уровня, который является здесь Activity).

Теперь позвольте мне обсудить основную разницу между обратным вызовом и шаблоном Eventlistener. Как мы уже упоминали, используя Callback, Callee может уведомлять только одного Caller. Но в случае шаблона EventListener любая другая часть или класс приложения может регистрироваться для событий, которые могут возникнуть на кнопке или флажке. Примером такого класса является OtherClass. Если вы видите код OtherClass, вы обнаружите, что он зарегистрировался как прослушиватель ClickEvent, который может возникнуть в Button, определенной в Activity. Интересная часть состоит в том, что помимо Activity (Caller) этот OtherClass также будет уведомлен о каждом событии click на Button.

Функция обратного вызова - это функция, которая должна вызываться, когда выполняется определенное условие. Вместо того, чтобы немедленно вызываться, функция обратного вызова вызывается в определенную точку в будущем.

Обычно она используется, когда задача запускается, которая завершится асинхронно (т.е. закончится через некоторое время после вызова функции )

Например, функция запроса веб-страницы может потребовать от своего вызывающего пользователя функции обратного вызова, которая будет вызываться, когда веб-страница закончит загрузку.

Функция обратного вызова - это функция, которую вы передаете (как ссылку или указатель) определенной функции или объекту. Эта функция или объект будет вызывать эту функцию в любое время позже, возможно, несколько раз для любой цели:

• , уведомляя о завершении задачи
• , запрашивая сравнение между двумя item (например, в c qsort ())
• сообщает о ходе процесса
• , уведомляя события
• делегируя инициализацию объекта
• делегирование картины области

...

Таким образом, описание обратного вызова как функции, вызываемой в конце другой функции или задачи, слишком упрощается (даже если это общий прецедент).

Я считаю, что этот «обратный вызов» жаргон был ошибочно использован во многих местах. Мое определение будет выглядеть примерно так:

Функция обратного вызова - это функция, которую вы передаете кому-то, и позвольте им называть ее в некоторый момент времени.

Я думаю, что люди просто прочитали первое предложение определения wiki:

обратный вызов - это ссылка на исполняемый код или часть исполняемого кода, которая передается как аргумент другому коду.

Я работал с большим количеством API-интерфейсов, смотрю различные плохие примеры. Многие люди имеют тенденцию называть указатель на функцию (ссылку на исполняемый код) или анонимные функции (часть исполняемого кода) «обратный вызов», если они являются просто функциями, для чего вам нужно другое имя для этого?

Фактически только второе предложение в определении wiki показывает различия между функцией обратного вызова и нормальной функцией:

Это позволяет программному уровню более низкого уровня вызывать подпрограмму (или функцию), определенную в более высоком слой уровня.

, поэтому разница заключается в том, кто вы собираетесь передать функцию и как будет передана ваша переданная функция. Если вы просто определяете функцию и передаете ее другой функции и называете ее непосредственно в этом теле функции, не называйте ее обратным вызовом. Определение говорит, что ваша переданная функция будет вызвана функцией «нижнего уровня».

Я надеюсь, что люди могут перестать использовать это слово в неоднозначном контексте, это не поможет людям лучше понять только хуже.