#include "stdafx.h"
class Base {
public:
    int static /*virtual*/ salt() {
        return 0;
    }
    int hash() {
        return 10 + salt();
    }
};

class Derived1: public Base {
public:
    int static salt() {
        return 1;
    }
};

class Derived2: public Base {
public:
    int static salt() {
        return 2;
    }
};

int _tmain(int argc, _TCHAR* argv[])
{
    int salt_Derived1= Derived1::salt();
    int salt_Derived2= Derived2::salt();

    Derived1* d1= new Derived1;
    int d1_hash= d1->hash();
    return 0;
}

class Base
{
public:
    // int static PublicNonpolymorphicHash() { return 0; } — Этот метод не нужен.
    int PublicNonvirtualPolymorphicHash() const { return 10 + PrivatePolymorphicSalt(); }
protected:
    virtual int PrivatePolymorphicSalt() const = 0; // { return Base::PublicNonpolymorphicHash(); }
};

class Derived1: public Base
{
public:
    int static PublicNonpolymorphicSalt() { return 1; }
private:
    int PrivatePolymorphicSalt() const { return Derived1::PublicNonpolymorphicSalt(); }
};

class Derived2: public Base
{
public:
    int static PublicNonpolymorphicSalt() { return 2; }
private:
    int PrivatePolymorphicSalt() const { return Derived2::PublicNonpolymorphicSalt(); }
};

int main(int argc, char const* argv[])
{
    int salt_Derived1 = Derived1::PublicNonpolymorphicSalt();
    int salt_Derived2 = Derived2::PublicNonpolymorphicSalt();

    Base* d1= new Derived1;
    int d1_hash= d1->PublicNonvirtualPolymorphicHash();
    return 0;
}

Q>class Base
Q>{
Q>public:
Q>    // int static PublicNonpolymorphicHash() { return 0; } — Этот метод не нужен.
Q>    int PublicNonvirtualPolymorphicHash() const { return 10 + PrivatePolymorphicSalt(); }
Q>protected:
Q>    virtual int PrivatePolymorphicSalt() const = 0; // { return Base::PublicNonpolymorphicHash(); }
Q>};
Q>

class Base
{
public:
    // int static PublicNonpolymorphicSalt() { return 0; } — Этот метод не нужен.
    int PublicNonvirtualPolymorphicHash() const { return 10 + PrivatePolymorphicSalt(); }
private:
    virtual int PrivatePolymorphicSalt() const = 0; // { return Base::PublicNonpolymorphicSalt(); }
};

// int static PublicNonpolymorphicHash() { return 0; } — Этот метод не нужен.

class IBase
{
public:
  virtual int hash() = 0;
//...
};

template<int saltValue>
class StdBase : public IBase
{
public:
    static const int salt = saltValue;
    virtual int hash() { return 10 + salt; }
};

class Derived1: public StdBase<1> {};
class Derived2: public StdBase<2> {};

// здесь в качестве тэга выбран указатель на тип (это обеспечивает наследование функций через приведение типа указателя)
int the_salt(Base*) { return 0; }
int the_salt(Derived1*) { return 1234; }
int the_salt(Derived2*) { return 567; }

// здесь указатель на тип играет и роль тэга, и передаёт данные
int the_hash(Base* p, int seed) { ....... }
int the_hash(Derived3* p, int seed) { ..... }

template<class T>
int hash(T* p) { return the_hash(p, the_salt((T*)0)); }

// а если наследование нежелательно, то можно использовать шаблон тэга
template<class T> struct type_tag {};

int the_salt(type_tag<Base>);
int the_salt(type_tag<Derived1>);
.....

int the_hash(type_tag<Base>, Base* p, int seed);
.....

template<class T>
int hash(T* p) { return the_hash(type_tag<T>(), p, the_salt(type_tag<T>()));

template<class Final> class Base
{
public:
  // это паттерн "Шаблонный метод": собираем функцию из полиморфных кусочков
  int hash() const { return get_hash(get_salt()); }
private:
  // примитивы Шаблонного Метода - чтобы не загромождать его код
  static int get_salt() { return Final::the_salt(); } // вызов статической функции наследника
  int get_hash(int seed) const { return static_cast<Final*>(this)->the_hash(seed); } // вызов функции-члена наследника

public:
  // дефолтные реализации (без них это был бы аналог чисто виртуальных функций)
  static int the_seed() { return 0; }
  static int the_hash(int seed) { return seed; }
};

// промежуточные наследники должны принимать форму CRTP
template<class Final> class Derived1T : public Base<Final>
{
public:
  static int the_seed() { return 123; }
  .....
};
class Derived1 : public Derived1T<Derived> {};

// запаянный наследник (от которого никто более не наследуется) может быть нешаблонным
class Derived123 : public Derived1T<Derived123>
{
  int m_x;
  double m_y;
  string m_z;
public:
  int the_hash(int seed) const
  {
    seed = Derived1T<Derived123>::the_hash(seed); // вызываем предка
    seed = hash(seed,m_x); // и досчитываем хэш своих данных
    seed = hash(seed,m_y);
    seed = hash(seed,m_z);
    return seed;
  }
};