Что дает template metaprogramming (по сравнению с другими яз - C/C++

В C++ имеется механизм template metaprogramming. В C#, Java нет какого механизма (нету ведь?). Вопрос в том какие преимущества по сравнению с C#, Java дает плюсам шаблонное метапрограммирование?

Есть ли какие то конкретные задачи которые невозможно или очень трудно решить на C#, Java но сравнительно легко можно решить на плюсах?

Ощущается ли в C#, Java отсутствие шаблонного метапрограммирования или там вместо него какие-то другие механизмы имеются которые компенсируют отсутствие шаблонного метапрограммирования?

Можно и другие языки для примера рассмотреть.

Вопрос НЕ про обобщенное программирование (использование параметризованных классов и алгоритмов). Вопрос про шаблонное метапрограммирование (суть в том, что вычисления на этапе компиляции являются Turing-complete).

у меня тоже вопрос
что вы сделали что бы найти ответы на свои вопросы самостоятельно ?
и работаете ли вы над собой что бы в будущем находить ответы самостоятельно ?

Здравствуйте, Максим Рогожин, Вы писали:

МР>Ощущается ли в C#, Java отсутствие шаблонного метапрограммирования или там вместо него какие-то другие механизмы имеются которые компенсируют отсутствие шаблонного метапрограммирования?

В основном обходятся обычным динамическим полиморфизмом времени выполнения.

Здравствуйте, Максим Рогожин, Вы писали:

МР>В C++ имеется механизм template metaprogramming. В C#, Java нет какого механизма (нету ведь?). Вопрос в том какие преимущества по сравнению с C#, Java дает плюсам шаблонное метапрограммирование?

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

template <size_t N, typename = double> class Vector;
template <size_t M, size_t N, typename = double> class Matrix;
template <size_t N, typename = double> class Quaternion;

Получается компактно и максимально эффективно.

Следующиющий шаг — попробовать сделать то же самое на C# или на Java, испытать разочарование после жестокого облома и реализовать сначала все возможные варианты классов, которые могут поотребоваться в средненьком игровом движке:

class Vector2Double;
class Vector2Float;
class Vector3Double;
class Vector3Float;
class Vector4Double;
class Vector4Float;

class Matrix2x2Double;
class Matrix2x2Float;
class Matrix3x3Double;
class Matrix3x3Float;
class Matrix3x4Double;
class Matrix3x4Float;
class Matrix4x4Double;
class Matrix4x4Float;

class Quaternion2Double;
class Quaternion2Float;
class Quaternion3Double;
class Quaternion3Float;

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

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

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

R>Для этого нужно попытаться решить какую-нибудь практическую задачу. Например, реализацию векторно матричных операций для игровых/графических движков. Например, в C++ достаточно реализовать пару тройку наблонных классов и операций между ними:

R>

R>template <size_t N, typename = double> class Vector;
R>template <size_t M, size_t N, typename = double> class Matrix;
R>template <size_t N, typename = double> class Quaternion;
R>

По моему вы говорите про обобщенное программирование (использование параметризованных классов и алгоритмов)? А мой вопрос про шаблонное метапрограммирование (т.е. суть в том, что вычисления на этапе компиляции являются Turing-complete).

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

R>у меня тоже вопрос
R>что вы сделали что бы найти ответы на свои вопросы самостоятельно ?
R>и работаете ли вы над собой что бы в будущем находить ответы самостоятельно ?

Какой-то хамский вопрос. Интересно же послушать вживую реальных людей.

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

R>class Vector2Double;
...
R>class Vector4Float;

R>class Matrix2x2Double;
...
R>class Matrix4x4Float;

R>class Quaternion2Double;
...
R>class Quaternion3Float;

Вспомнилось, в Дельфи-7 нет шаблонов, но можно нагеренить подобное при помощи {$INC}, я правда такое делал только для сортировки.

Но это ответ лишь на первую половину вопроса.
Вторая половина — пригождались ли шаблонные мета-извращения?

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

жду от автора очередного вброса — "А зачем нужен С++?"

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

TB>Но это ответ лишь на первую половину вопроса.
TB>Вторая половина — пригождались ли шаблонные мета-извращения?

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

template <size_t N, typename T, typename U>
ProductType<T,U> dotproduct(const Vector<N, T>& t, const Vector<N, U>& u)
{
  return std::inner_product(t.begin(), t.end(), u.begin(), ProductType<T,U>());
}

И вот практически сразу мы испытываем желание использовать "мета-извращение" ProductType, которое может быть реализовано простейшим образом:

typename <typename T, typename U>
using ProducType = decltype(std::declval<T>() * std::declval<U>());

И чем дальше в лес, тем толше партизаны: обязательно наступит момент, когда нам захочется использовать более сложные специализации, а значит и SFINAE — неизбежно, по моему опыту.

Таким образом, мое твердое ИМХО, если нам удается обосновать целесообразность применения шаблонов как таковых, вместе с этим мы автоматически обосновываем целесообразность "мета-извращений", как ты их называешь.

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

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

TB>>Но это ответ лишь на первую половину вопроса.
TB>>Вторая половина — пригождались ли шаблонные мета-извращения?

R>Ну возьмем к примеру самое элементарное — хотим мы реализовать операцию скалярного произведения двух векторов произвольного типа (хотя можно и произвольго числа векторов, но небудем усложнять прямо сразу). Разумная, на мой взгляд, реализация должна выглядеть примерно так:

R>

R>template <size_t N, typename T, typename U>
R>ProductType<T,U> dotproduct(const Vector<N, T>& t, const Vector<N, U>& u)
R>{
R>  return std::inner_product(t.begin(), t.end(), u.begin(), u.end(), ProductType<T,U>());
R>}
R>

Почему не

auto result = t[0]*u[0];
for (int i=1; i<N; ++i) result+=t[i]*u[i];
return result;

?

fix: вот жеж я лалка, я в 3 строчках опечатался,

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

TB>Почему не
TB>

TB>auto result = t[0]*u[i];
TB>for (int i=1; i<N; ++i) result+=t[i]*u[i];
TB>return result;
TB>

TB>?

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

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

R>>Ну возьмем к примеру самое элементарное — хотим мы реализовать операцию скалярного произведения двух векторов произвольного типа (хотя можно и произвольго числа векторов, но небудем усложнять прямо сразу). Разумная, на мой взгляд, реализация должна выглядеть примерно так:

R>>

R>>template <size_t N, typename T, typename U>
R>>ProductType<T,U> dotproduct(const Vector<N, T>& t, const Vector<N, U>& u)
R>>{
R>>  return std::inner_product(t.begin(), t.end(), u.begin(), u.end(), ProductType<T,U>());
R>>}
R>>

TB>Почему не
TB>

TB>auto result = t[0]*u[i];
TB>for (int i=1; i<N; ++i) result+=t[i]*u[i];
TB>return result;
TB>

TB>?

В добавок к сказанному выше — в моем варианте есть возможность указать тип возвращаемого значения явно, в твоем же случае — это только auto и самодокументируемость кода страдает.

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

R>>Ну возьмем к примеру самое элементарное — хотим мы реализовать операцию скалярного произведения двух векторов произвольного типа (хотя можно и произвольго числа векторов, но небудем усложнять прямо сразу). Разумная, на мой взгляд, реализация должна выглядеть примерно так:

R>Разумно не браться за задачу, где надо все усложнять, а упростить задачу, чтобы реализовать ее в достаточном объеме и с достаточными техническими характеристиками. Произвольное число — это усложнение. Оно реально нужно в вашей деятельности?
R>Вам руководство выделит деньги на реализацию этого безумия?

Дальше не читал

Много букв — признак путанницы в голове, имхо.

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

R>В добавок к сказанному выше — в моем варианте есть возможность указать тип возвращаемого значения явно, в твоем же случае — это только auto и самодокументируемость кода страдает.

Согласен, auto вообще лютое зло. Это невероятно модно, типа офигеть какой вывод типов, кококо, быстрее писать, но читать невозможно.
Сфинае это извращение, вызванное тем, что в 2018 до сих пор в кресты не завезли статик иф, но мне всё равно кажется, что в реальных программах это можно обойти, не особо что-то потеряв.

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

TB>Сфинае это извращение, вызванное тем, что в 2018 до сих пор в кресты не завезли статик иф, но мне всё равно кажется, что в реальных программах это можно обойти, не особо что-то потеряв.

Вот здесь не соглашусь, очень полезная штука, там, где обычные специализации не справляются. Например, очень иногда выручают специализации по доступности определенной операции для заданных входных типов. Обойти, конечно, можно, но только ценой раздувания кода, порой, весьма болезненного.

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

R>А вы почитайте. И с карандашом. Подумайте над каждой мыслью. Того гляди и от извращений метапрограммирования уйдете. Станете здоровым программистом, а может быть даже и инженером-программистом.

Спасибо, за заботу, но я уж как-нибудь обойдусь.

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

R>Следующиющий шаг — попробовать сделать то же самое на C# или на Java, испытать разочарование после жестокого облома и реализовать сначала все возможные варианты классов, которые могут поотребоваться в средненьком игровом движке:

R>

R>class Vector2Double;
R>class Vector2Float;
R>class Vector3Double;
R>class Vector3Float;
R>class Vector4Double;
R>class Vector4Float;

R>class Matrix2x2Double;
R>class Matrix2x2Float;
R>class Matrix3x3Double;
R>class Matrix3x3Float;
R>class Matrix3x4Double;
R>class Matrix3x4Float;
R>class Matrix4x4Double;
R>class Matrix4x4Float;

R>class Quaternion2Double;
R>class Quaternion2Float;
R>class Quaternion3Double;
R>class Quaternion3Float;
R>

Почему не

class Vector<T> { public Vector(int len) { ... } }

class Matrix<T> { public Matrix(int len1, int len2) { ... } }

class Quaternion<T> { public Quaternion(int len) { ... } }

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

ARK>Почему не

ARK>

ARK>class Vector<T> { public Vector(int len) { ... } }

ARK>class Matrix<T> { public Matrix(int len1, int len2) { ... } }

ARK>class Quaternion<T> { public Quaternion(int len) { ... } }
ARK>

Ну хотя бы потому, что в C#, например, тебе не будут доступны никакие арифметические операци над элементами — ни сложить, ни вычесть ни умножить — можешь попробовать, если не веришь. Как это ни печально, но дженерики C# — это совсем не то же самое, что шаблоны C++, несмотря не некоторую схожесть. При этом о быстродействии даже говорить нет смысла

	От:	Максим Рогожин
	Дата:	24.02.18 10:20
	Оценка:	+1

От:	reversecode	google
Дата:	24.02.18 10:31
Оценка:	1 (1) +2 -8

От:	Qbit86	https://twitter.com/qbit86
Дата:	24.02.18 10:43
Оценка:

	От:	rg45
	Дата:	24.02.18 10:51
	Оценка:	+1 -2

	От:	Максим Рогожин
	Дата:	24.02.18 12:30
	Оценка:	+1