was ist "late binding"?



  • hallo,

    ich hab neulich was von "late binding" gehört. dort ging es irgendwie darum, dass einige dinge erst zur laufzeit feststehen usw. aber so richtig hab ich die sache nicht verstanden. kann mir vielleicht jemand kurz erklären, was "late binding" ist. vielleicht könnt ihr ja auch ein kleines beispiel geben, damit ich diese sache auch besser verstehen kann. danke schon einmal im voraus.



  • Hallo,
    Meistens ist zur Compilezeit die Adresse der aufzurufenden Funktion/Methode eines Objekts bekannt. Dies nennt man frühe oder statische Bindung.

    class Foo
    {
          int val;
    
          public:
                 Foo(const int v) : val(v) { }
                 int get_val() const { return val; }
    };
    
    int main()
    {
          Foo obj(9);
          // Hier weiß der Compiler bereits die Adresse der Funktion get_val(), denn obj hat hier immer den Typ Foo.
          int r = obj.get_val();
    
          ...
          return 0;
    }
    

    Teilweise wird eine virtuelle Methode aber über einen Zeiger oder eine Referenz angesprochen. Hier weiß der Compiler zur compilezeit noch nicht, welche Methode aufgerufen werden soll. (Welche Methode letzendlich aufgerufen wirde hängt davon ab welches Objekt der Zeiger/die Referenz referenziert). Der Compiler muss hier Code generieren, wo erst zur Laufzeit entschieden wird, welche Funktion aufgerufen wird. Dies geschieht über VMT's (Virtual Method Table). Diese Bindung nennt man dynamische oder späte Bindung.

    class Foo
    {
          int val;
    
          public:
                 Foo(const int v) : val(v) { }
                 int get_val() const { return val; }
                 virtual void print() const { cout << "\n val (int): " << val; }
    };
    
    class Bar : public Foo
    {
           double val;
    
           public:
                  Bar(const int v1, const double v2) : Foo(v1), val(v2) { }
                  virtual void print() const { cout << "\n val (double): " << val << "\tval (int): " <<  get_val(); }
    };
    
    int main()
    {
          Foo obj1(9);
          Bar obj2(9, 9.99);
          Foo* ptr = &obj1;
    
          // Hier weiß der Compiler erst zur Laufzeit welche Funktion er aufrufen soll, denn ptr kann die Adresse von Foo _oder_ Bar enthalten.
          ptr->print();
          ptr = &obj2;
          ptr->print();
    
          return 0;
    }
    

    Caipi


Anmelden zum Antworten