может ли шаблон функции-члена класса c++ быть виртуальным?

<p>я слышал, что шаблоны функций-членов класса c++ не могут быть виртуальными. это правда? </p><p>если они могут быть виртуальными, то каков пример сценария, в котором можно использовать такую функцию?</p>

<p>шаблоны - все о генерации кода компилятором в <strong>compile-time</strong>. виртуальные функции - это система времени выполнения, которая определяет, какую функцию вызывать в <strong>run-time</strong>. </p><p>как только система во время выполнения выяснит, что ей нужно будет вызывать виртуальную функцию с шаблоном, компиляция завершена, и компилятор больше не может генерировать соответствующий экземпляр. поэтому у вас не может быть шаблонов виртуальных функций-членов. </p><p>тем не менее, есть несколько мощных и интересных методов, вытекающих из сочетания полиморфизма и шаблонов, в частности, так называемого <em> <a href="http://www.artima.com/cppsource/type\_erasure.html">стирание типа</a> </em>. </p>

<p>из шаблонов c++ полное руководство:</p><blockquote> <p>шаблоны функций-членов не могут быть объявлены виртуальными. это ограничение навязывается потому, что обычная реализация виртуальной функции механизм вызова использует таблицу фиксированного размера с одной записью на виртуальную функция. тем не менее, число экземпляров функции-члена шаблон не фиксируется, пока вся программа не будет переведена . следовательно, поддержка шаблонов виртуальных функций-членов потребует поддержка совершенно нового механизма в компиляторах c++ и линкеры. напротив, обычные члены шаблонов классов могут быть виртуальный, потому что их число фиксируется при создании экземпляра класса</p> </blockquote>

<p>c++ не поддерживает функции-члены виртуального шаблона прямо сейчас. наиболее вероятной причиной является сложность его реализации. раджендра приводит веские причины, почему это нельзя сделать прямо сейчас, но это возможно при разумных изменениях стандарта. особенно трудно определить, сколько экземпляров шаблонной функции действительно существует, и создание виртуальной таблицы кажется трудным, если учесть место вызова виртуальной функции. у людей, занимающихся стандартами, сейчас есть много других дел, и c++ 1x - это тоже большая работа для авторов компиляторов.</p><p>когда вам понадобится шаблонная функция-член? однажды я столкнулся с такой ситуацией, когда я пытался реорганизовать иерархию с чисто виртуальным базовым классом. это был плохой стиль для реализации различных стратегий. я хотел изменить аргумент одной из виртуальных функций на числовой тип и вместо перегрузки функции-члена и переопределить каждую перегрузку во всех подклассах, я пытался использовать функции виртуального шаблона (и должен был выяснить, их не существует) .) </p>

<h1>таблицы виртуальных функций</h1><p>давайте начнем с некоторой предыстории таблиц виртуальных функций и того, как они работают ( <a href="http://www.parashift.com/c++-faq-lite/virtual-functions.html">source</a> ):</p><blockquote> <p>[20.3] в чем разница между виртуальным и не виртуальным функции-члены называются?</p> <p>не виртуальные функции-члены разрешаются статически. это функция-член выбирается статически (во время компиляции) на основе тип указателя (или ссылки) на объект.</p> <p>напротив, виртуальные функции-члены разрешаются динамически (в во время выполнения). таким образом, функция-член выбирается динамически (в во время выполнения) в зависимости от типа объекта, а не от типа указатель/ссылка на этот объект. это называется «динамическое связывание.» большинство компиляторов используют какой-либо вариант следующей техники: если объект имеет одну или несколько виртуальных функций, компилятор ставит скрытые указатель на объект, называемый «виртуальный указатель» или «v-указатель». это v-указатель указывает на глобальную таблицу, называемую «виртуальная таблица» или "v-таблицы."</p> <p>компилятор создает v-таблицу для каждого класса, который имеет хотя бы один виртуальная функция. например, если класс circle имеет виртуальные функции для draw (), move () и resize () будет ровно одна v-таблица ассоциируется с классом circle, даже если был круг gazillion объекты, и v-указатель каждого из этих объектов circle будет указывать к кругу v-стол. v-таблица сама имеет указатели на каждый из виртуальные функции в классе. например, v-таблица circle будет иметь три указателя: указатель на circle :: draw (), указатель на circle :: move () и указатель на circle :: resize ().</p> <p>во время отправки виртуальной функции система времени выполнения следует v-указатель объекта на v-таблицу класса, затем следует соответствующий слот в v-таблице для кода метода.</p> <p>накладные расходы на указанную выше технику являются номинальными: дополнительно указатель на объект (но только для объектов, которым необходимо динамическое связывание ), плюс дополнительный указатель на метод (но только для виртуальных методов). накладные расходы также довольно номинальны: по сравнению с нормальный вызов функции, для вызова виртуальной функции требуется два дополнительных выборки (одна для получения значения v-указателя, вторая для получения адреса метода). ни одно из этих действий во время выполнения не происходит с не виртуальные функции, так как компилятор разрешает не виртуальные работает исключительно во время компиляции в зависимости от типа указатель.</p> </blockquote><hr><h1>моя проблема или как я сюда попал</h1><p>сейчас я пытаюсь использовать что-то подобное для базового класса cubefile с шаблонными оптимизированными функциями загрузки, которые будут реализованы по-разному для разных типов кубов (некоторые сохраняются по пикселям, некоторые по изображениям и т.д.).</p><p>некоторый код:</p><pre><code>virtual void loadcube(utpbipcube<float> &cube,long lowerleftrow=0,long lowerleftcolumn=0, long upperrightrow=-1,long upperrightcolumn=-1,long lowerband=0,long upperband=-1) = 0; virtual void loadcube(utpbipcube<short> &cube, long lowerleftrow=0,long lowerleftcolumn=0, long upperrightrow=-1,long upperrightcolumn=-1,long lowerband=0,long upperband=-1) = 0; virtual void loadcube(utpbipcube<unsigned short> &cube, long lowerleftrow=0,long lowerleftcolumn=0, long upperrightrow=-1,long upperrightcolumn=-1,long lowerband=0,long upperband=-1) = 0; </code></pre><p>то, что я хотел бы, но это не скомпилируется из-за виртуальной шаблонной комбинации:</p><pre><code>template<class t> virtual void loadcube(utpbipcube<t> &cube,long lowerleftrow=0,long lowerleftcolumn=0, long upperrightrow=-1,long upperrightcolumn=-1,long lowerband=0,long upperband=-1) = 0; </code></pre><p><strike>я переместил объявление шаблона на уровень класса</strike>, это решение заставило бы программы знать о конкретных типах данных, которые они будут читать, прежде чем они их прочитают, что недопустимо.</p><h1>решение</h1><p><em>предупреждение, это не очень красиво, но это позволило мне удалить повторяющийся код выполнения</em></p><p>1) в базовом классе</p><pre><code>virtual void loadcube(utpbipcube<float> &cube,long lowerleftrow=0,long lowerleftcolumn=0, long upperrightrow=-1,long upperrightcolumn=-1,long lowerband=0,long upperband=-1) = 0; virtual void loadcube(utpbipcube<short> &cube, long lowerleftrow=0,long lowerleftcolumn=0, long upperrightrow=-1,long upperrightcolumn=-1,long lowerband=0,long upperband=-1) = 0; virtual void loadcube(utpbipcube<unsigned short> &cube, long lowerleftrow=0,long lowerleftcolumn=0, long upperrightrow=-1,long upperrightcolumn=-1,long lowerband=0,long upperband=-1) = 0; </code></pre><p>2) и в детских классах</p><pre><code>void loadcube(utpbipcube<float> &cube, long lowerleftrow=0,long lowerleftcolumn=0, long upperrightrow=-1,long upperrightcolumn=-1,long lowerband=0,long upperband=-1) { loadanycube(cube,lowerleftrow,lowerleftcolumn,upperrightrow,upperrightcolumn,lowerband,upperband); } void loadcube(utpbipcube<short> &cube, long lowerleftrow=0,long lowerleftcolumn=0, long upperrightrow=-1,long upperrightcolumn=-1,long lowerband=0,long upperband=-1) { loadanycube(cube,lowerleftrow,lowerleftcolumn,upperrightrow,upperrightcolumn,lowerband,upperband); } void loadcube(utpbipcube<unsigned short> &cube, long lowerleftrow=0,long lowerleftcolumn=0, long upperrightrow=-1,long upperrightcolumn=-1,long lowerband=0,long upperband=-1) { loadanycube(cube,lowerleftrow,lowerleftcolumn,upperrightrow,upperrightcolumn,lowerband,upperband); } template<class t> void loadanycube(utpbipcube<t> &cube, long lowerleftrow=0,long lowerleftcolumn=0, long upperrightrow=-1,long upperrightcolumn=-1,long lowerband=0,long upperband=-1); </code></pre><p>обратите внимание, что loadanycube не объявлен в базовом классе. </p><hr><p>вот еще один ответ о переполнении стека с обходным решением: <a href="https://stackoverflow.com/questions/2939860/need-a-virtual-template-member-workaround">нужен обходной путь виртуального члена шаблона</a> . </p>

<p>нет, они не могут. но:</p><pre><code>template<typename t> class foo { public: template<typename p> void f(const p& p) { ((t*)this)->f<p>(p); } }; class bar : public foo<bar> { public: template<typename p> void f(const p& p) { std::cout << p << std::endl; } }; int main() { bar bar; bar *pbar = &bar; pbar -> f(1); foo<bar> *pfoo = &bar; pfoo -> f(1); }; </code></pre><p>имеет тот же эффект, если все, что вы хотите сделать, это иметь общий интерфейс и отложить реализацию до подклассов.</p>

<p>следующий код можно скомпилировать и запустить правильно, используя mingw g ++ 3.4.5 в windows 7:</p><pre><code>#include <iostream> #include <string> using namespace std; template <typename t> class a{ public: virtual void func1(const t& p) { cout<<"a:"<<p<<endl; } }; template <typename t> class b : public a<t> { public: virtual void func1(const t& p) { cout<<"a<--b:"<<p<<endl; } }; int main(int argc, char** argv) { a<string> a; b<int> b; b<string> c; a<string>* p = &a; p->func1("a<string> a"); p = dynamic\_cast<a<string>*>(&c); p->func1("b<string> c"); b<int>* q = &b; q->func1(3); } </code></pre><p>и вывод:</p><pre><code>a:a<string> a a<--b:b<string> c a<--b:3 </code></pre><p>и позже я добавил новый класс x:</p><pre><code>class x { public: template <typename t> virtual void func2(const t& p) { cout<<"c:"<<p<<endl; } }; </code></pre><p>когда я попытался использовать класс x в main () следующим образом:</p><pre><code>x x; x.func2<string>("x x"); </code></pre><p>g ++ сообщает о следующей ошибке:</p><pre><code>vtempl.cpp:34: error: invalid use of `virtual' in template declaration of `virtu al void x::func2(const t&)' </code></pre><p>итак, очевидно, что:</p><ul> <li>виртуальная функция-член может использоваться в шаблоне класса. компилятору легко построить vtable</li> <li>невозможно определить функцию-член шаблона класса как виртуальную, как вы можете видеть, сложно определить сигнатуру функции и выделить записи vtable.</li> </ul>

<p>нет, функции-члены шаблона не могут быть виртуальными. </p>

<p>чтобы ответить на вторую часть вопроса:</p><blockquote> <p>если они могут быть виртуальными, то каков пример сценария, в котором можно использовать такую функцию?</p> </blockquote><p>это не необоснованная вещь, чтобы хотеть сделать. например, java (где каждый метод является виртуальным) не имеет проблем с универсальными методами.</p><p>одним из примеров использования в c++ шаблона виртуальной функции является функция-член, которая принимает универсальный итератор. или функция-член, которая принимает объект универсальной функции.</p><p>решением этой проблемы является использование стирания типов с boost :: any\_range и boost :: function, что позволит вам принять универсальный итератор или функтор без необходимости превращать вашу функцию в шаблон.</p>

<p>существует обходной путь для «метода виртуального шаблона», если набор типов для метода шаблона известен заранее.</p><p>чтобы показать идею, в приведенном ниже примере используются только два типа (<code>int</code> и <code>double</code>).</p><p>там «виртуальный» метод шаблона (<code>base::method</code>) вызывает соответствующий виртуальный метод (один из <code>base::vmethod</code>), который, в свою очередь, вызывает реализацию метода шаблона (<code>impl::tmethod</code>).</p><p>нужно только реализовать шаблонный метод <code>tmethod</code> в производных реализациях (<code>aimpl</code>, <code>bimpl</code>) и использовать <code>derived<*impl></code>.</p><pre><code>class base { public: virtual ~base() { } template <typename t> t method(t t) { return vmethod(t); } private: virtual int vmethod(int t) = 0; virtual double vmethod(double t) = 0; }; template <class impl> class derived : public impl { public: template <class... targs> derived(targs&&... args) : impl(std::forward<targs>(args)...) { } private: int vmethod(int t) final { return impl::tmethod(t); } double vmethod(double t) final { return impl::tmethod(t); } }; class aimpl : public base { protected: aimpl(int p) : i(p) { } template <typename t> t tmethod(t t) { return t - i; } private: int i; }; using a = derived<aimpl>; class bimpl : public base { protected: bimpl(int p) : i(p) { } template <typename t> t tmethod(t t) { return t + i; } private: int i; }; using b = derived<bimpl>; int main(int argc, const char* argv[]) { a a(1); b b(1); base* base = nullptr; base = &a; std::cout << base->method(1) << std::endl; std::cout << base->method(2.0) << std::endl; base = &b; std::cout << base->method(1) << std::endl; std::cout << base->method(2.0) << std::endl; } </code></pre><p>результат:</p><pre><code>0 1 2 3 </code></pre><p>nb: <code>base::method</code> фактически лишний для реального кода (<code>vmethod</code> может быть обнародован и использоваться напрямую) . я добавил его, чтобы он выглядел как фактический «виртуальный» шаблонный метод.</p>

<p>по крайней мере, в gcc 5.4 виртуальные функции могут быть членами шаблона, но должны быть самими шаблонами. </p><pre><code>#include <iostream> #include <string> class first { protected: virtual std::string a1() { return "a1"; } virtual std::string mixt() { return a1(); } }; class last { protected: virtual std::string a2() { return "a2"; } }; template<class t> class mix: first , t { public: virtual std::string mixt() override; }; template<class t> std::string mix<t>::mixt() { return a1()+" before "+t::a2(); } class mix2: public mix<last> { virtual std::string a1() override { return "mix"; } }; int main() { std::cout << mix2().mixt(); return 0; } </code></pre><p>результаты</p><pre><code>mix before a2 process finished with exit code 0 </code></pre>

<p>в других ответах предложенная функция шаблона представляет собой фасад и не дает никакой практической выгоды.</p><ul> <li>шаблонные функции полезны для написания кода только один раз с использованием различных типов. </li> <li>виртуальные функции полезны для того, чтобы иметь общий интерфейс для разных классов.</li> </ul><p>язык не поддерживает функции виртуальных шаблонов, но с помощью обходного пути можно использовать и то и другое, например, одна реализация шаблона для каждого класса и виртуальный общий интерфейс.</p><p>однако для каждой комбинации типов шаблонов необходимо определить фиктивную функцию виртуальной оболочки:</p><pre><code>#include <memory> #include <iostream> #include <iomanip> //--------------------------------------------- // abstract class with virtual functions class geometry { public: virtual void getarea(float &area) = 0; virtual void getarea(long double &area) = 0; }; //--------------------------------------------- // square class square : public geometry { public: float size {1}; // virtual wrapper functions call template function for square virtual void getarea(float &area) { getareat(area); } virtual void getarea(long double &area) { getareat(area); } private: // template function for squares template <typename t> void getareat(t &area) { area = static\_cast<t>(size * size); } }; //--------------------------------------------- // circle class circle : public geometry { public: float radius {1}; // virtual wrapper functions call template function for circle virtual void getarea(float &area) { getareat(area); } virtual void getarea(long double &area) { getareat(area); } private: // template function for circles template <typename t> void getareat(t &area) { area = static\_cast<t>(radius * radius * 3.1415926535897932385l); } }; //--------------------------------------------- // main int main() { // get area of square using template based function t=float std::unique\_ptr<geometry> geometry = std::make\_unique<square>(); float areasquare; geometry->getarea(areasquare); // get area of circle using template based function t=long double geometry = std::make\_unique<circle>(); long double areacircle; geometry->getarea(areacircle); std::cout << std::setprecision(20) << "square area is " << areasquare << ", circle area is " << areacircle << std::endl; return 0; } </code></pre><p>результат: </p><blockquote> <p>площадь квадрата 1, площадь круга 3.1415926535897932385</p> </blockquote><p>попробуйте это <a href="http://coliru.stacked-crooked.com/a/050f8eb9c6ad1d65">здесь</a> </p>