Нестатический член шаблона: возможно?

Можно ли создать нестатическое поле шаблона в классе?
Если нет, как обойти?

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

пример

у меня много B-класс, как B1,B2,B3,
(В реальном случае они имеют более значимые имена.)

Я хочу создать класс D который имеет нестатическую функцию шаблона add<BX>() что должно counter++ каждый раз, когда я это называю, для каждого человека BX, для определенного случая D.
(В реальном случае это делает что-то более сложное.)

Вот рабочая демонстрация, чтобы достигнуть этого.
К сожалению, в настоящее время я должен жестко кодировать каждый BX, по одному (B1,B2,B3) внутри D:-

class B1{};class B2{};class B3{};
class Counter{
    public: int counter=0;
};
template<class BX>class Tag{};
class D{
    Counter countB1;
    Counter countB2;
    Counter countB3;
    public: template<class BX> void add(){  
        add_(Tag<BX>());
    }
    private:
    void add_(Tag<B1>){ countB1.counter++;}
    void add_(Tag<B2>){ countB2.counter++;}
    void add_(Tag<B3>){ countB3.counter++;}
    public: template<class BX> int get(){
        return get_(Tag<BX>());
    }
    private:
    int get_(Tag<B1>){  return countB1.counter;}
    int get_(Tag<B2>){  return countB2.counter;}
    int get_(Tag<B3>){  return countB3.counter;}
};

Вот использование. Обратите внимание, что каждый экземпляр D держать свой собственный counter:-

int main() {
    D d1;
    d1.add<B2>();   d1.add<B2>();   d1.add<B3>();
    std::cout<<d1.get<B1>()<<" "<<d1.get<B2>()<<" "<<d1.get<B3>()<<"\n";
    //^ print 0 2 1  
    D d2;
    d2.add<B1>();
    std::cout<<d2.get<B1>()<<" "<<d2.get<B2>()<<" "<<d2.get<B3>()<<"\n";
    //^ print 1 0 0  (not 1 2 1)
    return 0;
}

Я мечтаю о чем-то вроде:-

class D{
    Counter<BX> countBX; //???
    public: template<class BX> void add(){  
         Counter<BX>::getNonStaticInstance(this).counter++; //???
    }
    public: template<class BX> int get(){
        return Counter<BX>::getNonStaticInstance(this).counter; //???
    }
};

Я знаю как это сделать если countBX является статическим, но для нестатического это кажется невозможным.

Источник

3 ответа

Решение

Используя std::mapstd::unordered_map (предложение от Yakk; спасибо) индексов и RTTI?

#include <map>
#include <iostream>
#include <typeindex>

class B1 {};
class B2 {};
class B3 {};

class D
 {
   private:
      std::unordered_map<std::type_index, std::size_t> bxMap;

   public:
      template <typename BX>
      void add ()
       { ++ bxMap[std::type_index(typeid(BX))]; }

      template <typename BX>
      int get ()
       { return bxMap[std::type_index(typeid(BX))]; }
 };

int main ()
 {
   D d1;
   d1.add<B2>();    d1.add<B2>();   d1.add<B3>();
   std::cout<<d1.get<B1>()<<" "<<d1.get<B2>()<<" "<<d1.get<B3>()<<"\n";
   //^ print 0 2 1
   D d2;
   d2.add<B1>();
   std::cout<<d2.get<B1>()<<" "<<d2.get<B2>()<<" "<<d2.get<B3>()<<"\n";
   //^ print 1 0 0
   return 0;
 }
Источник

Вам не нужно RTTI чтобы решить эту проблему, ни std::map, которые очень дорогие (особенно RTTI). Шаблон Variadic и наследование могут решить эту проблему для вас:

class B1 {}; class B2 {}; class B3 {};

template<typename T>
class Counter {
  public:
    int counter = 0;
};

template<class... BXs>
class D : public Counter<BXs>... {
  public:
    template<typename B>
    void add() {
      Counter<B>::counter++;
    }

    template<typename B>
    int get() {
      return Counter<B>::counter;
    }
};

Что очень близко к тому, что вы на самом деле хотели (кстати, вы были на правильном пути).

Источник

К сожалению, пока мы не получим отражение в стандарте, не будет простого способа перебора членов класса.

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

Мы можем сделать это с базовым классом, который имеет std::array счетчиков, по одному для каждого BX:

template<class... Bs>
struct Base
{
    std::array<Counter, sizeof...(Bs)> counters;
    // ... more on this later
};

Тогда наш D класс может извлечь из него и получить нужные ему счетчики:

struct D :  Base<B1, B2, B3>{ /*...*/};

Следующее, что мы сделаем, это осуществим IndexOf функция в базовом классе, которая позволит нам преобразовать тип (один из B1B2B3) в индекс.

Мы можем сделать это с помощью признаков типа и выражений сгиба:

template<class T>
static constexpr int IndexOf()
{
    // find index of T in Bs...
    int toReturn = 0;
    int index = 0;
    (..., (std::is_same_v<T, Bs> ? toReturn = index : ++index));
    return toReturn;
}

А теперь наш D класс значительно упрощен и не зависит от отправки тегов:

struct D :  Base<B1, B2, B3>{   
    template<class BX> 
    void add(){ 
        counters[IndexOf<BX>()].counter++;
    }

    template<class BX> 
    int get(){
        return counters[IndexOf<BX>()].counter;;
    }
};

Live Demo

РЕДАКТИРОВАТЬ:

C++ 14 версия IndexOf:

template<class T>
static constexpr int IndexOf()
{
    // find index of T in Bs...
    int toReturn = 0;
    int index = 0;
    using swallow = int[];
    (void) swallow {0, (std::is_same<T, Bs>() ? toReturn = index : ++index, 0)...};
    return toReturn;
}

C++ 14 Demo

Источник
Другие вопросы по тегам