How to set expected template argument base type

I have an interface base class:

class BaseDicModel {
public:
  virtual ~BaseDicModel() {}
  virtual QString text() const    = 0;
  virtual int id() const          = 0;
  virtual void parseQuery(QSqlQuery *q) = 0;
  virtual QJsonObject toJson()    = 0;
};

and a template function, which is supposed to execute sql query and return dictionary depending on template class.

 template <class T>
  /**
   * @brief Loading dictionary from database
   * @param sqlQuery sql query to execute
   * @return Dictionary of type T
   * !!! T MUST BE DERIVED FROM BaseDicModel !!!
   */
  static QList<T *>
  getDictionary(QString sqlQuery) {
    QList<T *> result;
    QString conName = "regionConnection";
    {
      QSqlDatabase conn = getConnectionV2(
          conName, ConfigService::getInstance()->get_db_connection());
      //        int ret = -1;
      bool bOpen = false;
      if (!conn.isOpen()) {
        if (!conn.open()) {
          qWarning() << "Error while open db";
          return result;
        }
        bOpen = true;
      }

      QSqlQuery *query = new QSqlQuery(conn);

      query->prepare(sqlQuery);
      if (query->exec()) {
        while (query->next()) {
          T *row = new T();
          row->parseQuery(query);
          result.append(row);
        }
      } else {
        qWarning() << "Error while exec query:" << query->lastError().text();
      }
      delete query;
      if (bOpen) { conn.close(); }
    }
    QSqlDatabase::removeDatabase(conName);
    return result;
  }
};

it works fine, but i have a problem: template class can be ANY class right now,and what i'd like to get is template only for BaseDicModel derived classes.
Something like this pseudocode:

template<class T implements BaseDicModel>

Can you please give me any hints on how to make it work?
Question must be silly, but i don't seem to get it.
Thanks.

Personally I would just rely on duck typing and don't care, maybe apart from renaming T to something meaningful in you context, e.g. DicModel.

It gets a bit ugly pre-C++20, but it can be done by adding a second template argument. I prefer a non-type one, as it offers slightly better protection against outsmarting the check, but a type one should also do.

I guess is_base_of and enable_if are going to be the main workhorses, with the optional addition of is_same.

So, going top down, first the extra parameter should be added, I have chosen a pointer to void. The logic behind a non-type parameter is that if one tries to specify that argument manually, the check applies regardless of it:

1. typename std::enable_if<?????>::type* = nullptr
2. The condition inside checks if T is base of something, therefore std::is_base_of<Base, T>::value
3. Optionally, a second check could be added to verify whether T is not the base type itself && !std::is_same<T, Base>::value
4. So putting it all together: template <typename T, typename std::enable_if<std::is_base_of<Base, T>::value && !std::is_same<T, Base>::value>::type* = nullptr>

#include <type_traits>


struct Base
{
    virtual ~Base() = default;
};

struct DerivedPublic : Base{};

class DerivedPrivate : Base{};

struct DerivedFurther : DerivedPrivate{};

// derived + base
template <typename T, typename std::enable_if<std::is_base_of<Base, T>::value>::type* = nullptr>
// derived only
// template <typename T, typename std::enable_if<std::is_base_of<Base, T>::value && !std::is_same<T, Base>::value>::type* = nullptr>
struct S{};

int main(int, char*[])
{
    S<Base> sb;
    S<DerivedPublic> sdpub;
    S<DerivedPrivate> sdprv;
    S<DerivedFurther> sdf;
    // S<int> si;
}

Demo