Здравствуйте, samius, Вы писали:

S>Здравствуйте, Сыроежка, Вы писали:

С>>Здравствуйте, Qbit86, Вы писали:


Q>>>Я просто сделал предположение о твоём гипотетическом варианте (смотреть-то не на что). Но ты можешь его доблестно опровергнуть, таки осилив предъявить ну хоть что-нибудь.

С>>Так я еще раз повторяЮ, что ваши фантазии никому не интересны! Вы предполагать можете все, что угодно, что, например, вы — Джеймс Бонд, только мне то какое дело до ваших фантазий?

S>Вы наверное полагаете что ваши фантазии должны быть кому-то интересны после этого?

А моих фантазий нет! Я не делаю никаких предположений о каких-то гипотетических варианатх, как это делает Qbit86. Он сначала делает какие-то совершенно ничем не подкрепленные предположения, а потом предлагает эти свои фантазии другим опроверргнуть.
В мооем исходном предложении, которое я процитирую, "Почему бы вам функцию hash() не сделать виртуальный, и тогда проблема исчезнет? А статическую функцию salt() сделать закрытой для каждого класса.", был предложен путь, как можно решить проблему. Откуда Qbit86 высосал о дублировании кода?! И как он вообще мог об этом заявить, если он же сам признается, что огн моего кода не виидел?! Смешно, да и только!

Здравствуйте, Сыроежка, Вы писали:

С>Здравствуйте, samius, Вы писали:

С>>>Так я еще раз повторяЮ, что ваши фантазии никому не интересны! Вы предполагать можете все, что угодно, что, например, вы — Джеймс Бонд, только мне то какое дело до ваших фантазий?

S>>Вы наверное полагаете что ваши фантазии должны быть кому-то интересны после этого?

С>А моих фантазий нет! Я не делаю никаких предположений о каких-то гипотетических варианатх, как это делает Qbit86. Он сначала делает какие-то совершенно ничем не подкрепленные предположения, а потом предлагает эти свои фантазии другим опроверргнуть.
С>В мооем исходном предложении, которое я процитирую, "Почему бы вам функцию hash() не сделать виртуальный, и тогда проблема исчезнет? А статическую функцию salt() сделать закрытой для каждого класса.", был предложен путь, как можно решить проблему. Откуда Qbit86 высосал о дублировании кода?! И как он вообще мог об этом заявить, если он же сам признается, что огн моего кода не виидел?! Смешно, да и только!

Вы все еще полагаете что это кому-то должно быть интересно читать? Вот это ^^^ и ему подобное?

Здравствуйте, Qbit86, Вы писали:

Q>Здравствуйте, Сыроежка, Вы писали:

С>>Так я еще раз повторяЮ, что ваши фантазии никому не интересны!

Q>Тебе-то точно неинтересны, судя по объёму генерируемого тобой бессодержательного текста. Порассказывай ещё, как они тебе безразличны.

С>>Вы предполагать можете все, что угодно, что, например, вы — Джеймс Бонд, только мне то какое дело до ваших фантазий?

Q>Никакого и никакого, дело с концом. Так зачем ты продолжаешь в треде потешать почтенную публику?

С>>Так из этого следуетт, что вы на самом деле не отвтили на исходный вопрос. Вопрос касался статической функции, как статическую функцию сделать "виртуальной", то есть не отказаться от статической функции, а сделать так, чтобы доступ к ней, то есть к [b]статической функции[/b] имитировал полиморфизм.

Q>Ох, фейспалм. Ты, похоже, даже примерно не понял, в чём проблема.

С>>Но для вас что главное? Не арргументировать свои высказывания, направленные против других предложений, а продемонстрировать, что вы читали какую-то книгу!

Q>Сабж.
Я так и не уидел обоснованного объяснение голословного утверждения, где происходит дублирование кода, но зато услышал в ответ кучу пустопорожнего звона.
Единственное, что я хотел от вас добиться, это услышать обоснование вашего безапелляционного утверждения, но, как оказалось, это бесполезно. Вы не несете ответсвенность за то, что направо и налево заявляете.
Как говорил один киногерой, я люблю умных людей, но не люблю умников.
Когда вместо конкретного ответа потоком идет словоблудие, то это ничего хорошо о вас ни как оч еловеке, ни как о программисте не говорит.

Здравствуйте, samius, Вы писали:

S>Здравствуйте, Сыроежка, Вы писали:

С>>Здравствуйте, samius, Вы писали:

С>>>>Так я еще раз повторяЮ, что ваши фантазии никому не интересны! Вы предполагать можете все, что угодно, что, например, вы — Джеймс Бонд, только мне то какое дело до ваших фантазий?

S>>>Вы наверное полагаете что ваши фантазии должны быть кому-то интересны после этого?

С>>А моих фантазий нет! Я не делаю никаких предположений о каких-то гипотетических варианатх, как это делает Qbit86. Он сначала делает какие-то совершенно ничем не подкрепленные предположения, а потом предлагает эти свои фантазии другим опроверргнуть.
С>>В мооем исходном предложении, которое я процитирую, "Почему бы вам функцию hash() не сделать виртуальный, и тогда проблема исчезнет? А статическую функцию salt() сделать закрытой для каждого класса.", был предложен путь, как можно решить проблему. Откуда Qbit86 высосал о дублировании кода?! И как он вообще мог об этом заявить, если он же сам признается, что огн моего кода не виидел?! Смешно, да и только!

S>Вы все еще полагаете что это кому-то должно быть интересно читать? Вот это ^^^ и ему подобное?

А почему вы ко мне обращщаетесь, а не к Qbit86?! Я лишь хотел услышать от него, на основании чего он сделал заключение о дублировании кода.
Мне лично тоже не интересно читать ни его ^^^, ни ваше ^^^. Мне бы было интересно прочитать аргументированное объяснение высказывания Qbit86. Но этого нет, а есть лишь его ^^^, да еще ваше появившееся ^^^.

С>В мооем исходном предложении, которое я процитирую, "Почему бы вам функцию hash() не сделать виртуальный, и тогда проблема исчезнет? А статическую функцию salt() сделать закрытой для каждого класса.", был предложен путь, как можно решить проблему. Откуда Qbit86 высосал о дублировании кода?! И как он вообще мог об этом заявить, если он же сам признается, что огн моего кода не виидел?! Смешно, да и только!

Если сделать hash() виртуальной, то в каждом потомке нужно будет её определить — отсюда дублирование, так как hash() один и тот же.
Если сделать salt() закрытой, то её нельзя будет вызвать во внешнем коде (см. main() в моем примере).

Здравствуйте, Сыроежка, Вы писали:

С>Здравствуйте, samius, Вы писали:

С>А почему вы ко мне обращщаетесь, а не к Qbit86?! Я лишь хотел услышать от него, на основании чего он сделал заключение о дублировании кода.
Потому что срач тут разводите именно вы.

С>Мне лично тоже не интересно читать ни его ^^^, ни ваше ^^^. Мне бы было интересно прочитать аргументированное объяснение высказывания Qbit86. Но этого нет, а есть лишь его ^^^, да еще ваше появившееся ^^^.
То его мнение интересно, то не интересно, теперь опять интересно, причем в соседних предложениях. Экий вы ветренный.

Если вам действительно что-то интересно — учитесь прежде уважать чужое мнение. Тогда им с вами охотно поделятся.

Здравствуйте, samius, Вы писали:

S>Здравствуйте, Сыроежка, Вы писали:

С>>Здравствуйте, samius, Вы писали:

С>>А почему вы ко мне обращщаетесь, а не к Qbit86?! Я лишь хотел услышать от него, на основании чего он сделал заключение о дублировании кода.
S>Потому что срач тут разводите именно вы.

С>>Мне лично тоже не интересно читать ни его ^^^, ни ваше ^^^. Мне бы было интересно прочитать аргументированное объяснение высказывания Qbit86. Но этого нет, а есть лишь его ^^^, да еще ваше появившееся ^^^.
S>То его мнение интересно, то не интересно, теперь опять интересно, причем в соседних предложениях. Экий вы ветренный.

S>Если вам действительно что-то интересно — учитесь прежде уважать чужое мнение. Тогда им с вами охотно поделятся.

Я не понимаю, а что вы влезли-то?! Вопрос стоит не об неком абстрактном уважении чьего-то мнения, а об обосновании мнения, так как программирование — это не гадание на кофейной гуще! Он наверное ваш приятель, что вы также началли разводить флуд?!

Здравствуйте, purser, Вы писали:

С>>В мооем исходном предложении, которое я процитирую, "Почему бы вам функцию hash() не сделать виртуальный, и тогда проблема исчезнет? А статическую функцию salt() сделать закрытой для каждого класса.", был предложен путь, как можно решить проблему. Откуда Qbit86 высосал о дублировании кода?! И как он вообще мог об этом заявить, если он же сам признается, что огн моего кода не виидел?! Смешно, да и только!

P>Если сделать hash() виртуальной, то в каждом потомке нужно будет её определить — отсюда дублирование, так как hash() один и тот же.
P>Если сделать salt() закрытой, то её нельзя будет вызвать во внешнем коде (см. main() в моем примере).

Так вопрос с открытым членом или с закрытым — это не принципиально! Сделайте функцию открытой, какие проблемы?
А что касается вашего объяснения о дублировании кода, то почему же в другом варианте нет дублировании кода? Разве там не надо в каждом классе объявлять виртуальную функцию, к которой обращается не виртуальная? В чем принципиальная разница относительно дублирования кода?!

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

Здравствуйте, Сыроежка, Вы писали:

С>Здравствуйте, samius, Вы писали:

С>Я не понимаю, а что вы влезли-то?! Вопрос стоит не об неком абстрактном уважении чьего-то мнения, а об обосновании мнения, так как программирование — это не гадание на кофейной гуще! Он наверное ваш приятель, что вы также началли разводить флуд?!

Я влез потому что мне неприятны ваши манеры.
Ну а пусть бы и приятель, ничего дурного в том что бы иметь приятелей я не вижу. Иметь приятелей гораздо лучше, чем иметь дурные манеры.

Здравствуйте, purser, Вы писали:

P>Посоветуйте, пожалуйста, как сделать метод static salt() ещё и виртуальным.
P>Знаю, что static virtual нельзя, но можно ли обойти без дублирования кода и т.д. ?
P>...

Возможно, этот тот случай, когда имеет смысл динамический полиморфизм заменить статическим:

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> {};

Здравствуйте, Сыроежка, Вы писали:

С>Здравствуйте, purser, Вы писали:

С>>>В мооем исходном предложении, которое я процитирую, "Почему бы вам функцию hash() не сделать виртуальный, и тогда проблема исчезнет? А статическую функцию salt() сделать закрытой для каждого класса.", был предложен путь, как можно решить проблему. Откуда Qbit86 высосал о дублировании кода?! И как он вообще мог об этом заявить, если он же сам признается, что огн моего кода не виидел?! Смешно, да и только!

P>>Если сделать hash() виртуальной, то в каждом потомке нужно будет её определить — отсюда дублирование, так как hash() один и тот же.
P>>Если сделать salt() закрытой, то её нельзя будет вызвать во внешнем коде (см. main() в моем примере).

С>А что касается вашего объяснения о дублировании кода, то почему же в другом варианте нет дублировании кода? Разве там не надо в каждом классе объявлять виртуальную функцию, к которой обращается не виртуальная? В чем принципиальная разница относительно дублирования кода?!

Разница в том, где дублирования меньше. В идеале мне нужна конструкция по семантике сходная со static virtual, но раз её нет,
то костыли, которые предложил Qbit86, наверное, наименьшее зло. Да, приходится создавать "лишнюю" виртуальную функцию в каждом наследнике. Дублирование функции hash() может в дальнейшем обернуться бОльшими проблемами, поскольку она больше подвержена изменениям чем простая функция-затычка из одного return.

Здравствуйте, purser, Вы писали:

P>Здравствуйте, Сыроежка, Вы писали:

С>>Здравствуйте, purser, Вы писали:

С>>>>В мооем исходном предложении, которое я процитирую, "Почему бы вам функцию hash() не сделать виртуальный, и тогда проблема исчезнет? А статическую функцию salt() сделать закрытой для каждого класса.", был предложен путь, как можно решить проблему. Откуда Qbit86 высосал о дублировании кода?! И как он вообще мог об этом заявить, если он же сам признается, что огн моего кода не виидел?! Смешно, да и только!

P>>>Если сделать hash() виртуальной, то в каждом потомке нужно будет её определить — отсюда дублирование, так как hash() один и тот же.
P>>>Если сделать salt() закрытой, то её нельзя будет вызвать во внешнем коде (см. main() в моем примере).

С>>А что касается вашего объяснения о дублировании кода, то почему же в другом варианте нет дублировании кода? Разве там не надо в каждом классе объявлять виртуальную функцию, к которой обращается не виртуальная? В чем принципиальная разница относительно дублирования кода?!

P>Разница в том, где дублирования меньше. В идеале мне нужна конструкция по семантике сходная со static virtual, но раз её нет,
P>то костыли, которые предложил Qbit86, наверное, наименьшее зло. Да, приходится создавать "лишнюю" виртуальную функцию в каждом наследнике. Дублирование функции hash() может в дальнейшем обернуться бОльшими проблемами, поскольку она больше подвержена изменениям чем простая функция-затычка из одного return.

Как раз дублирования, в варианте, который предложил Qbit86, больше, так как каждая функция должна принимать указатель на исходный обюъект класса. То есть объектный код становится гораздо больше и менее эффектиным, так как нужно передавать дополнительный агумент в функцию. А в вашем случае это совершенно не нужно, так как вы вели речь о статической функции. Сделал функцию hash виртуальной, вы избавитесь от всех своих проблем. При этом статическую функцию, если это вам так очень нужно (в чем я сильно сомневаюсь) можете оставить открытой. Но это конечно ваше личное дело, так как мы не знаем все тонокости вашей реализации.

Здравствуйте, purser, Вы писали:

P>Посоветуйте, пожалуйста, как сделать метод static salt() ещё и виртуальным.
P>Знаю, что static virtual нельзя, но можно ли обойти без дублирования кода и т.д. ?

Зависит от того, в какой момент возникает полиморфизм.
Если в рантайме (т.е. дано: Base* something, и нужно, чтобы something->salt() вернул соль для фактического типа) — то придётся использовать косвенности.
Навскидку:
— хранить соль в каждом объекте (something->m_salt)
— виртуальная функция
— указатель на функцию
— тэги и табличная функция (грубо говоря, switch(something->m_typeid) какой-нибудь)

Если же во время компиляции (т.е. Derived123* something и даже просто Derived123::salt()), то можем прибегнуть к способностям компилятора по выводу типов и поиску имён.
Самое дубовое — это просто сделать внешние функции salt и hash, зависящие от типа

// здесь в качестве тэга выбран указатель на тип (это обеспечивает наследование функций через приведение типа указателя)
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>()));

Возможно, что тебе нужен CRTP — это практически полный аналог виртуальным функциям, только во время компиляции.

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;
  }
};