Здравствуйте, dr.Chaos, Вы писали:

DC>Здравствуйте, LaPerouse, Вы писали:

LP>>Здравствуйте, dr.Chaos, Вы писали:

DC>>>Ты внимательно прочел что я тебе написал? В случае перегрузки мы имеет 2 сигнатуры функции для разных типов, но имя функции одно и получается что одна функция работает для разных типов, т.е. ведет себя полиморфно. В случае с шаблонами во время компиляции просто генерируется нужная сигнатура на этапе компиляции.

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

LP>>Ну сколько можно... То, очем ты говоришь, работает, если ТИП объекта СОВПАДАЕТ с его ЭКЗЕМПЛЯРОМ. Но и не это главное. Главное — то, что эти две функции — совершенно разные, у них сигнатура разная и говорить о том, что у тебя там полиморфизм смешно. Т к к ним применяются аргументы совершенно разных типов.

DC>Тогда ответь пожалуйста, что такое полиморфизм. Своими словами в вики не лезть .

Полиморфизм в применении к ООП — это свойство объектов реагировать по-разному на одно и то же входное воздействие. А сейчас я объясню более подробно, какую логическую ошибку совершаешь ты.

Вот кусок примера, который я приводил выше:

Interface* object1 = new A();
Interface* object2 = new B();

foo((A)object1);
foo((B)object2);

Какой тип у object1? Interface! Какой же экзепляр соответсвует object1 на этапе выполнения? A! (в смысле экземпляр класса А). Компилятор подбирает сответствующую сигнатуру по ТИПУ объекта. Твоя проблема в том, что ты не понимаешь, что foo(A* a) и foo(B* a) — совершенно разные функции, и поиск нужной сигнатуры при вызове ничем не отличается от вызова любой другой ф-ции. Тебя смущает одинаковые название ТЕЛА этих ф-ций. А между прочим, компилятору реально пофиг на тело, он отличает ф-ции только по сигнатуре. Предположим, мы назвали наши ф-ции по-разному

foo1(A* a)
foo2(B* a)

Тогда вызов foo1(new A()) ты тоже сочтешь полиморфным?

Тебе, очевидно, привденный выше пример представился в таком свете:

A* object1 = new A();
B* object2 = new B();

foo(object1);
foo(object2);

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

В случае с виртуальными ф-циями, их сигнатуры совпадают. Как же компилятор находит нужную реализацию для вызова? Очень просто, используя информацию времени выполнения о КЛАССЕ, которому принадлежит ЭКЗЕМПЛЯР объекта.