Шаблоны: определить класс в функции и вызвать его метод

@QVO · Регистрация: 26.10.2010

Author24 — интернет-сервис помощи студентам

Здравствуйте форумчане.

Есть два класса:

C++

class WSelectionBox
{
public:
    WSelectionBox() = default;
    std::set<int> selectedIndexes();
};

C++

class WLineEdit
{
public:
    WLineEdit() = default;
    std::string valueText();
};

Как определить какой именно класс был передан в шаблон и вызвать его метод

C++

template<typename C>
void save()
{
    Widget* component_ = new C();
    // if WSelectionBox
    if(typeid(C) == typeid(WSelectionBox))
        std::set<int> selection = component_->selectedIndexes();
    // if WLineEdit
    if(typeid(C) == typeid(WLineEdit))
        std::string = component_->valueText();
}

Дабы не возникало такой ошибки?

Код

'class Wt::WLineEdit' has no member named 'selectedIndexes'
                 std::set<int> selection = component_->selectedIndexes();

С уважением QVO.

@rikimaru2013 · 03.08.2015, 23:58

Интерфейсы в С++

Croessmah · 04.08.2015, 00:07

Если C потомок Widget (естественно с виртуальными плюшками), то можете с помощью dynamic_cast привести component_ к нужному типу (WSelectionBox или WLineEdit), но че-т как-то не смотрится...

@QVO · 04.08.2015, 10:41 **[ТС]**

Камрады, есть еще какие-то подходы?

@egor2116 · 04.08.2015, 10:54

Наверное как то так

C++

#include <iostream>
#include <typeinfo>>
 
namespace cf{
    class Widget{
        public:
            virtual void make() = 0;
    };
    
    class WLineEdit : public Widget{
        public:
            virtual void make(){
                std::cout << "LineEdit do same" << std::endl;
            }
    };
    
    class WSelectedBox : public Widget{
        public:
            virtual void make(){
                std::cout << "SelectedBox do same" << std::endl;
            }
    };
    
    template<typename C>
    void save()
    {
        Widget * component = new C();
        // if WSelectionBox
        if(typeid(C) == typeid(WSelectedBox))
           component->make();
        // if WLineEdit
        if(typeid(C) == typeid(WLineEdit))
            component->make();
    }   
}
 
int main()
{   
    cf::save<cf::WLineEdit>();
    cf::save<cf::WSelectedBox>();
    
    
    return 0;
}

@rikimaru2013 · 04.08.2015, 11:15

C++

 if(typeid(C) == typeid(WSelectedBox))
           component->make();
        // if WLineEdit
        if(typeid(C) == typeid(WLineEdit))
            component->make();

улыбнуло

@ct0r · 04.08.2015, 11:46

QVO, про задачу ничего и не рассказал. Что ты хочешь сделать? Можно ли менять исходные классы? Почему именно выбрал шаблоны, а не виртуальные функции? Одно знаю точно - сохранение в том стиле, в котором хочешь сделать ты (с явными проверками на тип), делать не надо.

DiffEreD · 04.08.2015, 12:21

Как вариант:

C++

#include <iostream>
#include <set>
#include <type_traits>
#include <memory>
 
class WSelectionBox
{
public:
    WSelectionBox() = default;
    std::set<int> selectedIndexes() const {return {1,2,3};}
};
 
class WLineEdit
{
public:
    WLineEdit() = default;
    std::string valueText() const {return "Hello";}
};
 
template <typename T>
void foo_impl(T t, std::true_type) // for  WSelectionBox
{
    for (const auto &i : t->selectedIndexes()) std::cout << i << " ";
    std::cout << std::endl;
}
 
template <typename T>
void foo_impl(T t, std::false_type) // for  WLineEdit
{
    std::cout << t->valueText() << std::endl;
}
 
template <typename T>
void foo()
{
    foo_impl(std::make_shared<T>(), std::is_same<T, WSelectionBox>());
}
 
int main()
{
    foo<WSelectionBox>();
    foo<WLineEdit>();
}

@QVO · 04.08.2015, 13:13 **[ТС]**

ct0r, в общих чертах есть модели сущностей в БД MySQL. Хочу сделать GUI редактор БД.
Интерфейсы не подходят, т.к. придется переписывать код.

Пример модели:

C++

class Game
{
public:
Game();
std::string name; // название
std::vector<std::string name> tags; // теги
};

Передаю модель игры на редактирование в объект редактора:

C++

1 2	editor->make_field<Game, std::string, WLineEdit>(ptr, &Game::name, std::string("Имя")); //const Dbo::ptr<Game>& ptr

Создается GUI поле

C++

template<typename T, typename R, typename C>
void make_field(Dbo::ptr<T> ptr, R T::* member, const WString& title)
{
    FieldInterface* field = new Field<T, R, C>(ptr, member, title);
    fields_.push_back(field);
//std::vector<FieldInterface*> fields_;
}

Плюс в том, что я могу создать виджет с тем количеством полей, которое мне нужно.
Допустим кликнул по названию игры, вызвалось окошко содержащее только 1 эдит под название.
Нажал на кнопку и создал виджет со всеми полями для редактирования модели. (ячейку для ввода названия игры и список для выбора уже существующих тегов)

И при нажатие кнопки сохранить после редактирование данных исполняется такой код:

C++

1 2	for(auto field : fields_) field->save();

С примерно таким содержимым:
Если я передаю поле модели с типом std::string (&Game::name) то в методе возникают ошибки, т.к. std::string не владеет методами clear и insert.

C++

        void save()
        {
            if(typeid(member_) == typeid(std::vector< std::string >))
            {
                ptr_.modify()->*member_.clear(); // тут ошибка, т.к. std::string не имеет метода clear
                WSelectionBox* component = dynamic_cast<WSelectionBox*>(component_);
                std::set<int> selection = component->selectedIndexes();
 
                for (std::set<int>::iterator it = selection.begin(); it != selection.end(); ++it)
                {
                    // тут некие манипуляции с созданием моделей для тегов
                    ptr_.modify()->*member_.insert(ptr2); // тут ошибка, т.к. std::string не имеет метода Insert
                }
            } else
            {
                ptr_.modify()->*member_ = component_->valueText();
            }
        }

@QVO · 05.08.2015, 23:17 **[ТС]**

DiffEreD, есть подход, который даст возможность вызвать более двух имплементируемых методов?
К примеру параметры:

C++

std::string
int
std::shared_ptr<int>
std::vector< std::shared_ptr<int> >

Для каждого из них свой исполняемый метод.

С уважением QVO.

DiffEreD · 05.08.2015, 23:31

Делать через std::enable_if

Добавлено через 7 минут
Примерно так:

C++

#include <iostream>
#include <set>
#include <type_traits>
#include <memory>
 
class WSelectionBox
{
public:
    WSelectionBox() = default;
    std::set<int> selectedIndexes() const {return {1,2,3};}
};
 
class WLineEdit
{
public:
    WLineEdit() = default;
    std::string valueText() const {return "Hello";}
};
 
template <typename T>
void foo_impl(std::shared_ptr<T> t, std::enable_if_t<std::is_same<T, WSelectionBox>::value>* = nullptr) // for  WSelectionBox
{
    for (const auto &i : t->selectedIndexes()) std::cout << i << " ";
    std::cout << std::endl;
}
 
template <typename T>
void foo_impl(std::shared_ptr<T> t, std::enable_if_t<std::is_same<T,WLineEdit>::value>* = nullptr) // for  WLineEdit
{
    std::cout << t->valueText() << std::endl;
}
 
template <typename T>
void foo_impl(std::shared_ptr<T> t, std::enable_if_t<std::is_same<T,int>::value>* = nullptr) // for  int
{
    std::cout << "int" << std::endl;
}
 
template <typename T>
void foo()
{
    foo_impl(std::make_shared<T>());
}
 
int main()
{
    foo<WSelectionBox>();
    foo<WLineEdit>();
    foo<int>();
}

@QVO · 05.08.2015, 23:55 **[ТС]**

DiffEreD, у меня вот так вышло:

C++

        template< typename T1, typename R1 >
        struct is_collection_point : std::integral_constant< bool,
                std::is_same< Wt::Dbo::collection< Dbo::ptr<R1> >, typename std::remove_cv<T1>::type>::value > {};
 
        template< typename T1, typename R1 >
        struct is_ptr_point : std::integral_constant< bool,
                std::is_same< Wt::Dbo::ptr<R1>, typename std::remove_cv<T1>::type>::value > {};
 
        template< typename T1 >
        struct is_wstring_point : std::integral_constant< bool,
                std::is_same< Wt::WString, typename std::remove_cv<T1>::type>::value > {};
//-------------------------------
        template< typename T1, typename R1 >
        typename std::enable_if<is_collection_point<T1, R1>::value, T1>::type foo1()
        {
            std::cout << "foo1: collection\n";
        }
 
        template< typename T1, typename R1 >
        typename std::enable_if<is_ptr_point<T1, R1>::value, T1>::type foo1()
        {
            std::cout << "foo1: ptr\n";
        }
 
        template< typename T1, typename R1 >
        typename std::enable_if<is_wstring_point<T1>::value, T1>::type foo1()
        {
            std::cout << "foo1: wstring\n";
        }
//-------------------------------

Добавлено через 3 минуты
DiffEreD, может подскажешь еще как в метапрограммирование можно задать поле, которое может быть пустым.
Сейчас на примере покажу:

C++

1 2	template< typename T, typename R, typename A > void foo() {}

Как указать, что при вызове функции foo<T, R, A>() параметр A можно не передавать?

DiffEreD · 06.08.2015, 00:13

Задать параметр шаблона по умолчанию:

C++

template <typename T, typename R, typename A = void>
void foo() {}
 
int main()
{
    foo<int, double>();
}

Добавлено через 44 секунды
Или тут что то другое имелось ввиду?

@QVO · 06.08.2015, 00:22 **[ТС]**

DiffEreD, подправил твои функции:

C++

        template <typename T1, typename R1 >
        void foo_impl(std::enable_if<std::is_same< T1, Wt::Dbo::ptr<R1> >::value>* = nullptr)
        {
            std::cout << "Wt::Dbo::ptr<R1>" << std::endl;
        }
 
        template <typename T1, typename R1 >
        void foo_impl(std::enable_if<std::is_same< T1, Wt::WString >::value>* = nullptr)
        {
            std::cout << "Wt::WString" << std::endl;
        }

C++

1	foo_impl<WString, WString>();

C++

1	foo_impl<Wt::Dbo::ptr<Game>, Game>();

Выдает ошибку компиляции:

Код

call of overloaded 'foo_impl()' is ambiguous
             foo_impl<R, ptrType>();

Где я допустил ошибку?

@hoggy · 06.08.2015, 00:23

Сообщение от QVO

Как определить какой именно класс был передан в шаблон и вызвать его метод

ответ на ваш вопрос:

1.
Специализация шаблона

C++

#include <iostream>
 
#include<string>
#include<set>
 
class WSelectionBox
{
public:
    WSelectionBox() = default;
    std::set<int> selectedIndexes(){ return std::set<int>();  }
};
 
class WLineEdit
{
public:
    WLineEdit() = default;
    std::string valueText() { return ""; }
};
 
 
template<typename C>
void save();
 
template<>
void save<WSelectionBox>()
{
    auto* component_ = new WSelectionBox();
    std::set<int> selection = component_->selectedIndexes();
}
 
 
template<>
void save<WLineEdit>()
{
    auto* component_ = new WLineEdit();
    std::string s = component_->valueText();
}
 
 
 
int main()
{
    std::cout << "Hello, world!\n";
    
    save<WLineEdit>();
}

2.
SFINAE - перегрузка.

C++

#include <iostream>
 
#include<string>
#include<set>
 
class WSelectionBox
{
public:
    WSelectionBox() = default;
    std::set<int> selectedIndexes(){ return std::set<int>();  }
};
 
class WLineEdit
{
public:
    WLineEdit() = default;
    std::string valueText() { return ""; }
};
 
 
template<typename C, 
typename std::enable_if< std::is_same<C, WSelectionBox>::value >::type* = nullptr
>
void save()
{
    auto* component_ = new C();
    std::set<int> selection = component_->selectedIndexes();
}
 
template<typename C, 
typename std::enable_if< std::is_same<C, WLineEdit>::value >::type* = nullptr
>
void save()
{
    auto* component_ = new C();
    std::string s = component_->valueText();
}
 
 
 
int main()
{
    std::cout << "Hello, world!\n";
    
    save<WLineEdit>();
}

можно в статике изнутри функции пропасти тип данных,
и делегировать в "зависимости от" каким то другим функциям.

рантайм-конструкции вида :

C++

1	if(typeid(C) == typeid(WSelectionBox))

точно не нужны.

DiffEreD · 06.08.2015, 00:26

QVO, а если typename добавить:

C++

1	void foo_impl(typename std::enable_if<std::is_same< T1, Wt::Dbo::ptr<R1> >::value>::type* = nullptr)

@QVO · 06.08.2015, 00:47 **[ТС]**

DiffEreD,

C++

        template <typename T1, typename R1 >
        void foo_impl(typename std::enable_if<std::is_same< T1, Wt::Dbo::ptr<R1> >::value>* = nullptr)
        {
            std::cout << "Wt::Dbo::ptr<R1>" << std::endl;
        }
 
        template <typename T1, typename R1 >
        void foo_impl(typename std::enable_if<std::is_same< T1, Wt::WString >::value>* = nullptr)
        {
            std::cout << "Wt::WString" << std::endl;
        }

Эта же ошибка:

C#

1 2	call of overloaded 'foo_impl()' is ambiguous foo_impl<R, ptrType>();

Добавлено через 20 минут
hoggy, можно сделать так?

C++

        template <typename C1,
                  typename C2,
                  typename std::enable_if< std::is_same<C1, Wt::Dbo::collection< Dbo::ptr<C2> > >::value >::type* = nullptr >
        void foo_impl()
        {
            std::cout << "Wt::Dbo::collection< Dbo::ptr<C2> >" << std::endl;
        }
 
        template < typename C1,
                   typename C2,
                   typename std::enable_if< std::is_same<C1, Dbo::ptr<C2> >::value >::type* = nullptr >
        void foo_impl()
        {
            std::cout << "Wt::Dbo::ptr<R1>" << std::endl;
        }
 
        template < typename C1,
                   typename C2 >
        void foo_impl()
        {
            std::cout << "Other type" << std::endl;
        }

Этот код не компилируется из-за последней функции.
Ошибка при компиляции:

Код

call of overloaded 'foo_impl()' is ambiguous
             foo_impl<R, ptrType>();

@hoggy · 06.08.2015, 02:52

Сообщение от QVO

можно сделать так?

Сообщение от QVO

Этот код не компилируется из-за последней функции.

очевидно жеж, что нельзя.

итак, справочка:

как работает SFINAE ?

итак, предположим, у нас есть функция foo, которая принимает некое T.
если T - дробное число (float/double), мы хотим обработать его одним способом.
если T - интегральное число - другим способом.
во всех остальных случаях, мы хотим ошибку компиляции.

как это сделать?
можно было бы написать 100500 перегрузок под все возможные интегральные типы и плавающие.
но это - много много копипасты.
а хочется написать парочку шаблонов под два сценария.

напишем пробный шаблон:

C++

template<typename T> 
void foo(T&& value)
{
    std::cout<<"value = "<< value <<'\n';
}

данный шаблон способен принять любой тип,
если только он умеет выводиться в std::cout.

но он не умеет различать интегральные,дробные,и прочие.

что же делать?

как различить типы по интересным нам свойствам?

можно например, применить элементы метапрограммирования:

C++

template<typename T> 
void foo(T&& value)
{
    if( std::is_integral<T>::value )
        std::cout<<"value = "<< value << "is integral type\n";
    else if( std::is_floating_point<T>::value )
        std::cout<<"value = "<< value << "is floating type\n";
    else
        std::cout<<"value = is other\n";
}

метафункция

C++

1	std::is_integral<T>::value

даст 1, если T интегральное.
метафункция

C++

1	std::is_floating_point<T>::value

даст 1, если T дробное.
ну а иначе - это что-то другое.

у этого способа есть недостатки.

1.
ветвление логики происходит в рантайме.
то есть это не эффективно. программа будет тратить время на такую выборку.

2.
мы не получаем ошибку компиляции если T ни интегральное, ни дробное.

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

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

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

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

итак, знакомьтесь, эту технику SFINAE официально узаконил стандарт:

C++

1 2	typedef typename std::enable_if<BoolValue, U>::type result;

если BoolValue - true, тогда type будет равно U,
а значит result будет равно U

если BoolValue - false, тогда type вообще не будет существовать,
и вся эта конструкция будет не валидна (не скомпилируется)

C++

// result равно int
typedef  typename std::enable_if<1, int>::type
    result;
// не скомлируется, type не существует
typedef  typename std::enable_if<0, int>::type
    result;

очень важно понимать, что по правилу SFINAE,
если теоретически может существовать такое T,
при котором шаблоно-перегруженная функция может корректно скомпилироваться,
то компилятор не будет генерировать ошибку.

он просто отбросит такую перегрузку из конкурса выбора претендентов.
и будет пытаться использовать другую перегрузку.

теперь пишем наши сценарии обработки данных в зависимости от T:

C++

#include <iostream>
 
//--- вспомогательная структура 
// инкапсулирует расчеты 
// связанные с определнием свойств типа
template<typename T>struct property
{
    enum { is_integral = std::is_integral<T>::value       };
    enum { is_floating = std::is_floating_point<T>::value };
    enum { is_other = !is_integral && !is_floating        };
};
 
// --- инстанцируется только если T интегральное, иначе не существует
// а значит для T, которое не интегральное, 
// данная перегрузка просто не будет скомпилирована
template<typename T, 
    typename std::enable_if< property<T>::is_integral>::type* = nullptr  
> 
void foo(T&& value)
{
    std::cout<<"value = "<< value << " is integral type\n";
}
 
// --- инстанцируется только если T дробное, иначе не существует
// а значит для T, которое не дробное, 
// данная перегрузка просто не будет скомпилирована
template<typename T, 
    typename std::enable_if< property<T>::is_floating >::type* = nullptr  
> 
void foo(T&& value)
{
    std::cout<<"value = "<< value << " is floating type\n";
}
 
// --- инстанцируется только если T ни интегральное, и не дробное
// а значит для T, которое дробное, или интегральное
// данная перегрузка просто не будет скомпилирована
template<typename T, 
    typename std::enable_if< property<T>::is_other >::type* = nullptr  
> 
void foo(T&& value)
{
    // расскоментируйте, что бы получить ошибку компиляции
    //static_assert(!property<T>::is_other, "ERROR: T MUST BE INTERGAL OR FLOATING");
        
    std::cout<<"value is other type\n";
}
 
int main()
{
    std::cout << "Hello, world!\n";
    
    foo(10);
    foo(10.5);
    
    foo(nullptr);
}

обратите внимание на конструкцию:

C++

1
2
3

template<typename T, 
    typename std::enable_if< property<T>::is_integral>::type* = nullptr  
>

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

и если T подходящее - получится T*,
а если не подходящее - шаблон просто отбрасывается.

в итоге, в зависимости от Т только одна из перегрузок будет инстанцированна.
все остальные будут забракованы.

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

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

http://rextester.com/BLBO36917

C++

//Title of this code
//g++  4.9.1
 
#include <iostream>
 
//--- вспомогательная структура 
// инкапсулирует расчеты 
// связанные с определнием свойств типа
template<typename T>struct property
{
    enum { is_integral = std::is_integral<T>::value       };
    enum { is_floating = std::is_floating_point<T>::value };
    enum { is_other = !is_integral && !is_floating        };
};
 
//--- макросы служат для наглядности
#define dFOR_INTEGRAL\
    typename std::enable_if< property<T>::is_integral>::type* = nullptr  
#define dFOR_FLOATING\
    typename std::enable_if< property<T>::is_floating>::type* = nullptr  
#define dFOR_OTHER\
    typename std::enable_if< property<T>::is_other>::type* = nullptr  
 
//--- не нужно вникать в то, что скрывается под макросами
// просто имейте ввиду, что данная функция только для интегральных
template<typename T, dFOR_INTEGRAL > 
void foo(T&& value)
    { std::cout<<"value = "<< value << " is integral type\n"; }
 
// а эта - для дробных
template<typename T, dFOR_FLOATING> 
void foo(T&& value)
    { std::cout<<"value = "<< value << " is floating type\n"; }
 
// а эта - для всех остальных
template<typename T, dFOR_OTHER> 
void foo(T&& value)
{
    // расскоментируйте, что бы получить ошибку компиляции
    //static_assert(!property<T>::is_other, "ERROR: T MUST BE INTERGAL OR FLOATING");
        
    std::cout<<"value is other type\n";
}
 
// а не забудем удалить дефайны, они нам больше не нужны
#undef dFOR_INTEGRAL
#undef dFOR_FLOATING
#undef dFOR_OTHER
 
int main()
{
    std::cout << "Hello, world!\n";
    
    foo(10);
    foo(10.5);
    
    foo(nullptr);
}

----------------------------------------------------

Теперь возвращаемся к вашему примеру:

C++

template <typename C1,
                  typename C2,
                  typename std::enable_if< std::is_same<C1, Wt::Dbo::collection< Dbo::ptr<C2> > >::value >::type* = nullptr >
        void foo_impl()
        {
            std::cout << "Wt::Dbo::collection< Dbo::ptr<C2> >" << std::endl;
        }
 
        template < typename C1,
                   typename C2,
                   typename std::enable_if< std::is_same<C1, Dbo::ptr<C2> >::value >::type* = nullptr >
        void foo_impl()
        {
            std::cout << "Wt::Dbo::ptr<R1>" << std::endl;
        }
 
 
      //-------------------------------------------------------------------
        template < typename C1,  //<--- смотрим сюда
                   typename C2 >
        void foo_impl()
        {
            std::cout << "Other type" << std::endl;
        }

первые две перегрузки по правилу SFINAE пройдут отбраковку.
допустим, выживет только одна.

а вот самая последняя перегрузка :

C++

template < typename C1,  //<--- смотрим сюда
                   typename C2 >
        void foo_impl()
        {
            std::cout << "Other type" << std::endl;
        }

никогда не будет забракована.
ведь SFINAE её никак не срезает.
а значит она всегда будет среди претендентов на выбор.

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

вот так у вас и образуется "неоднозначность вызова".

@QVO · 06.08.2015, 03:17 **[ТС]**

hoggy, благодарю за развернутый ответ!
Я разбил функции по типа и они содержат разную логику:

C++

template < typename Member,
           typename Model,
           typename std::enable_if< std::is_same< Member, std::string >::value >::type* = nullptr >
void modify_impl()
{
    std::cout << "std::string" << std::endl;
}
 
template < typename Member,
           typename Model,
           typename std::enable_if<std::is_floating_point<Member>::value, Member>::type* = nullptr >
void modify_impl()
{
    std::cout << "floating" << std::endl;
}
 
template < typename Member,
           typename Model,
           typename std::enable_if< std::is_same< Member, int >::value >::type* = nullptr >
void modify_impl()
{
    std::cout << "int" << std::endl;
}

Функции (точнее методы) являются членами класса
И вызываются с метода save()

C++

template< typename DboModel, typename FieldType, typename Component, typename FieldTypeDboModel = void>
class Field : public FieldInterface
{
public:
    Field(Dbo::ptr<DboModel> ptr, FieldType DboModel::* member)
        , ptr_(ptr)
        , member_(member)
    {
        component_ = new Component();
    }
 
    void save()
    {
        modify_impl<member_, DboModel>();
    }
private:
    Dbo::ptr<DboModel> ptr_;
    FieldType DboModel::* member_;
};

Возникают такие ошибки:

Код

use of 'this' in a constant expression
             modify_impl<member_, DboModel>();
                         ^
no matching function for call to 'G::Field<G::Game, Wt::Dbo::ptr<G::Genre>, Wt::WComboBox, G::Genre>::modify_impl()'
             modify_impl<member_, DboModel>();
                        ^
no matching function for call to 'G::Field<G::Game, Wt::WString, Wt::WTextArea, void>::modify_impl()'
             modify_impl<member_, DboModel>();
                        ^

Можете подсказать где я снова ошибся?

@hoggy · 06.08.2015, 03:22

Сообщение от QVO

ожете подсказать где я снова ошибся?

смотрите сюда:

C++

void save()
{
        modify_impl<member_, DboModel>(); //<--- чем является member_ ?
}

параметрами шаблона могут быть либо типы,
либо константы времени компиляции.

Шаблоны: определить класс в функции и вызвать его метод

Решение

Решение

Решение

@rikimaru2013 2549 / 1208 / 358 Регистрация: 30.11.2013 Сообщений: 3,826
	03.08.2015, 23:58	2
	Интерфейсы в С++ 1

Croessmah Неэпический 17870 / 10635 / 2054 Регистрация: 27.09.2012 Сообщений: 26,737 Записей в блоге: 1
	04.08.2015, 00:07	3
	Если C потомок Widget (естественно с виртуальными плюшками), то можете с помощью dynamic_cast привести component_ к нужному типу (WSelectionBox или WLineEdit), но че-т как-то не смотрится... 1

@QVO 652 / 462 / 80 Регистрация: 26.10.2010 Сообщений: 1,263 Записей в блоге: 4
	04.08.2015, 10:41 [ТС]	4
	Камрады, есть еще какие-то подходы? 0

@ct0r Игогошка! 1801 / 708 / 44 Регистрация: 19.08.2012 Сообщений: 1,367
	04.08.2015, 11:46	7
	QVO, про задачу ничего и не рассказал. Что ты хочешь сделать? Можно ли менять исходные классы? Почему именно выбрал шаблоны, а не виртуальные функции? Одно знаю точно - сохранение в том стиле, в котором хочешь сделать ты (с явными проверками на тип), делать не надо. 0