Какие вызовы функций не разрешаются во время компиляции в объектно-ориентированном программировании?

Question

Какие вызовы функций разрешаются во время компиляции, а какие - во время выполнения?Я где-то читал, что не все вызовы функций разрешаются во время компиляции, я не знаю, какие именно.

Answer 1

Механизмы вызова виртуальных функций разрешаются во время выполнения.Потому что в C ++ указатель на производный класс совместим по типу с указателем на его базовый класс.Таким образом, для вызова виртуальной функции должен быть известен фактический тип созданного объекта (или фактический нижележащий объект), на который указывает указатель базового класса, который может быть разрешен только во время выполнения.

struct foo
{
     virtual void virtualMethod()
     {
          cout<< " \n virtualMethod of foo \n";
     }

     void normalMethod()
     {
          cout<< " \n normalMethod of foo \n";
     }
     virtual ~foo() {}
};

struct bar: public foo
{
     void virtualMethod()
     {
         cout<< " \n virtualMethod of bar \n";
     }
     void normalMethod()
     {
          cout<< " \n normalMethod of bar \n";
     }
     ~bar() {}
};

foo* obj = new bar ;
obj->virtualMethod() ;

Теперь, то, какой virtualMethod() должен быть вызван, зависит от типа времени выполнения (или фактического нижележащего объекта), на который указывает obj, потому что obj может указывать на объект, сконструированный либо new foo, либо new bar.Во время выполнения мы знаем, что obj создается из возражаемого, чей возвращаемый тип равен bar*, соответствующая виртуальная функция производного класса вызывается, если существует.В противном случае вызывается виртуальная функция базового класса.

obj->normalMethod();

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

Results: ideOne link link

Answer 2

Если вы имеете в виду вызовы с использованием полиморфизма

время компиляции: перегрузка операторов и функций.и во время выполнения: виртуальные функции.

Answer 3

Виртуальные функции будут разрешены во время выполнения. Термины динамическая привязка или поздняя привязка используются для изображения этих функций.

Оба термина подразумевают, что разрешение происходит во время выполнения, в зависимости от того, как был создан объект.

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

int Add(int nX, int nY)
{
    return nX + nY;
}
int Subtract(int nX, int nY)
{
    return nX - nY;
}

int main()
{
    // Create a function pointer and make it point to the Add function
    int (*pFcn)(int, int) = Add;
    cout << pFcn(5, 3) << endl; // add 5 + 3
    pFcn = Subtract;
    cout<< pFcn(5,3)<<endl // pefrom 5-3
    return 0;
}

Answer 4

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

Например:

class A
{
    public:
        virtual ~A(){}
        virtual void DoStuff() { cout << "A"; }   
};

class B : public A
{
    public:
        virtual void DoStuff() { cout << "B"; }
};

void Magic(A &x)
{
    x.DoStuff();
}

Теперь в методе Magic() нет способа, которым компилятор может определить, какой экземпляр будет передан методу.Это может быть экземпляр A и это может быть экземпляр B.Метод, который должен быть вызван, отличается в каждом случае.Следовательно, вызов не полностью разрешен, но проходит через некоторый посреднический механизм, который выбирает подходящий метод.

Answer 5

При использовании функции привязки во время выполнения вызовы функций не разрешаются во время компиляции.Обычно это полиморфизм с использованием виртуальных функций.В таких случаях среда выполнения сохраняет записи всех подробностей виртуальной функции в таблице VMT (таблица виртуальных методов), а затем во время выполнения динамически выбирает правильную версию функции, которая будет использоваться.Функции, которые не являются виртуальными, разрешаются во время компиляции, которая называется статической привязкой.