Операторы для C структуры

[m_ax]

Специализируйте эту функцию для Color, и в ней меняйте тип на нужный, а после вычисления переводите результат в Color.

Да, именно)

Во всех функциях нужно использовать rgbF, а результат переводить по обстоятельству)

Я бы написал свой color_cast со всеми возможными специализациями (туда и обратно):

Код

C++ (Qt)
template <class R, class T>
R color_cast(T);
 
template <>
Color color_cast<Color, rgbF>(rgbF clr)
{
    return  /* перегоняем rgbF в Color */;
}
 
template <>
rgbF color_cast<rgbF, Color>(Color clr)
{
    return /* перегоняем Color в rgbF */;
}
 
template <>
Color color_cast<Color, Color>(Color clr)
{
    return  clr;
}
 
template <>
rgbF color_cast<rgbF, rgbF>(rgbF clr)
{
    return  clr;
}
 

 

Ну и дальше во всех шаблонных функциях:

Код

C++ (Qt)
template <class R, class T>
R some_color_function(T clr1, T clr2)
{
    rgbF c1 = color_cast<rgbF>(clr1);
    rgbF c2 = color_cast<rgbF>(clr2);
    ...
    return color_cast<R>(....); 
}
 

Как то так)

[m_ax]

Но боюсь, что сейчас выяснятся внезапные проблемы перегона из rgbF в Color и обратно 

[Old]

Но боюсь, что сейчас выяснятся внезапные проблемы перегона из rgbF в Color и обратно 

Вы мелко думаете, скорее всего, это все не годится.

[m_ax]

Вы мелко думаете, скорее всего, это все не годится. 

Эх.. Боюсь сегодня мы этого уже не узнаем(

[Igors]

Во всех функциях нужно использовать rgbF, а результат переводить по обстоятельству)

Я бы написал свой color_cast со всеми возможными специализациями (туда и обратно):

А как этот color_cast я вставлю в темплейт код? Есть выражение

Код

C++ (Qt)
return c1 * (1 - w) + c2 * w;

Что делать если с1 и с2 имеют тип Color? Очевидно нужно соскочить на вычисления в флотах. Поэтому пришлось создать свой класс rgbF и определить операторы

Код

C++ (Qt)
rgbF operator + ( const rgbF & c, const rgbF & c );
rgbF operator * ( const Color & c, float t );

Так все хорошо, но + возвращает rgbF, а в темплейт коде нужно вернуть Color (тип аргументов c1 и с2). Поэтому еще

Код

C++ (Qt)
rgbF::operator Color( void );

Вопросы

1) Правильно ли я сделал или есть др, более элегантный способ?

2) Что делать если уже имеется библиотечный класс RgbLibF у которого rgb во флотах и операторы все есть - но вот про Color он ничего не знает. Как тогда? Оператор * можно сделать так же, но как заставить вернуть Color? (трогать хедер RgbLibF нельзя)

Спасибо

Edit: можно было просто

Код

C++ (Qt)
Color operator + ( const rgbF & c, const rgbF & c );

(только сейчас заметил). Но этот случай не общий

[Old]

Код

C++ (Qt)
template <class R, class T>
R some_color_function(T clr1, T clr2, float w)
{
    rgbLibF c1 = color_cast<rgbLibF>(clr1);
    rgbLibF c2 = color_cast<rgbLibF>(clr2);
    rgbLibF result = c1 * (1 - w) + c2 * w;         // Все вычисления выполняются с rgbLibF
    return color_cast<R>( result );                   // Кастуем в нужный тип, например это будет Color.
}
 

И описать функции каста из Color в rgbLibF и обратно.

[m_ax]

А как этот color_cast я вставлю в темплейт код? Есть выражение

Легко.. Как, показано выше (пост #20).

Что делать если с1 и с2 имеют тип Color? Очевидно нужно соскочить на вычисления в флотах. Поэтому пришлось создать свой класс rgbF и определить операторы

Не нужно никаких своих операторов. Все операции внутри ваших шаблонных функциях производятся с rgbLibF.. А дальше кастуется в зависимости от параметра шаблона (R)..

1) Правильно ли я сделал или есть др, более элегантный способ?

 
С color_cast решение более элегантное, т.к. не нужно переписывать кучу непонятных операторов..

2) Что делать если уже имеется библиотечный класс RgbLibF у которого rgb во флотах и операторы все есть - но вот про Color он ничего не знает. Как тогда? Оператор * можно сделать так же, но как заставить вернуть Color? (трогать хедер RgbLibF нельзя)

Опять же, color_cast решает это)

[Igors]

Опять же, color_cast решает это)

Есть выражение

Код

C++ (Qt)
return c1 * (1 - w) + c2 * w;

Где здесь color_cast? Может Вы предлагаете заменить его с использованием color_cast? Каким образом и что тогда будет если c1 и c2 инстанциированы др типами (напр float)?

[Old]

Хотелось бы еще раз напомнить про специализацию шаблонов.

[m_ax]

Где здесь color_cast? Может Вы предлагаете заменить его с использованием color_cast? Каким образом и что тогда будет если c1 и c2 инстанциированы др типами (напр float)?

Похоже Вы ни меня, ни Old а не слушаете..(

Специализируете функцию color_cast:

Код

C++ (Qt)
template <class R, class T>
R color_cast(T);
 
template <>
Color color_cast<Color, Color>(Color clr) // Принимает и возвращает Color
{
    return  clr;
}
 
template <>
rgbF color_cast<rgbF, rgbF>(rgbF clr) // Принимает и возвращает rgbF
{
    return  clr;
}
 
template <>
rgbF color_cast<rgbF, float>(float clr) // кастуем float в rgbF
{
    return /*  */;
}
 
template <>
Color color_cast<Color, float>(float clr) // кастуем float в Color
{
    return /*  */;
}
 
template <>
Color color_cast<Color, rgbF>(rgbF clr) // Кастует rgbF в Color
{
    return  /* перегоняем rgbF в Color */;
}
 
template <>
rgbF color_cast<rgbF, Color>(Color clr)
{
    return /* перегоняем Color в rgbF */;
}
 

Всё. Теперь во всех функциях работаем с rgbF..

Код

C++ (Qt)
template <class R, class T>
R some_color_function(T clr1, T clr2, float w)
{
    rgbLibF c1 = color_cast<rgbLibF>(clr1);
    rgbLibF c2 = color_cast<rgbLibF>(clr2);
    rgbLibF result = c1 * (1 - w) + c2 * w;         // Все вычисления выполняются с rgbLibF
    return color_cast<R>( result );                   // Кастуем в нужный тип, например это будет Color.
}
 

Что тут непонятного то?

[Igors]

Код

C++ (Qt)
template <class R, class T>
R some_color_function(T clr1, T clr2, float w)
{
    rgbLibF c1 = color_cast<rgbLibF>(clr1);
    rgbLibF c2 = color_cast<rgbLibF>(clr2);
    rgbLibF result = c1 * (1 - w) + c2 * w;         // Все вычисления выполняются с rgbLibF
    return color_cast<R>( result );                   // Кастуем в нужный тип, например это будет Color.
}
 

Что тут непонятного то?

Т.е. Вы предлагаете заменить исходную строку

Код

C++ (Qt)
return c1 * (1 - w) + c2 * w;

На

Код

C++ (Qt)
return some_color_function(c1, c2, w);

Верно? Тогда не проще ли так

Код

C++ (Qt)
template <class T>
T DoCalc( const T & c1, const T & c2, float w )
{
 return c1 * (1 - w) + c2 * w;
}  
 
template <>
Color DoCalc( const Color & c1, const Color & c2, float w )
{
   rgbLibF c1 = Color2rgbLibF(clr1);
   rgbLibF c2 = Color2rgbLibF((clr2);
   rgbLibF result = c1 * (1 - w) + c2 * w;         // Все вычисления выполняются с rgbLibF
   return rgbLibF2Color(result);   
}

Но в любом случае меня смущает привязка к конкретному (и одному) выражению. Как-то негибко, а вдруг завтра придется интерполировать напр так

Код

C++ (Qt)
return (c1 * w1 + c2 * w2) / (w1 + w2); 

И опять придется "оборачивать" Поэтому мне кажется с операторами правильнее

Edit: "проще" я имел ввиду не надо никакого интенсивного каста - просто 2 ф-ции для перегонки из Color в rgbLibF и обратно - их по-любому писать

[Old]

Тогда не проще ли так

Бинго.
И всего-то понадобилось два напоминания.

А еще лучше, наверное, определить один класс для работы с цветом float, с которым и производить все вычисления и добавить возможность простого преобразования из него в разные структуры типа Color (через операторы приведения типа и конструкторы).

[m_ax]

Верно? Тогда не проще ли так

Не совсем..

Ещё раз. Мы пишем один раз все специализации color_cast. Написали: теперь мы можем делать, например, так:

Код

C++ (Qt)
Color clr = color_cast<Color>(123.f);
Color clr2 = color_cast<Color>(rgbF());
rgbF clr3 = color_cast<rgbF>(Color());
 
и т.д.
 

Теперь пишем шаблонные функции для работы с цветом, например:

Код

C++ (Qt)
template <class R, class T>
R combine_color(T c1, T c2, float w)
{
    rgbLibF c1 = color_cast<rgbLibF>(clr1);
    rgbLibF c2 = color_cast<rgbLibF>(clr2);
    return color_cast<R>( c1 * (1 - w) + c2 * w );   
}
 
template <class R, class T>
R other_combine_color(T c1, T c 2, float w1, float w2)
{
    rgbLibF c1 = color_cast<rgbLibF>(clr1);
    rgbLibF c2 = color_cast<rgbLibF>(clr2);
    return color_cast<R>( (c1 * w1 + c2 * w2) / (w1 + w2) );   
}
 
и т.д..
 

Во всех пользовательских функциях мы работаем с rgbLibF, поскольку для него все эти операции уже заточены..
Для пользовательских шаблонных функций таким образом не нужно писать перегрузки или специализации.
Всё это на себя берёт специализации color_cast, который уже знает что и как во что кастить.

[Old]

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

[m_ax]

Но, мне кажется один полноценный класс цвета с поддержкой всех операторов и правильных вычислений решит эти проблемы.

А разве rgbLibF - это не тот самый класс, который всё правильно делает?)