Как использовать шаблонный класс в новом шаблоне?

Question

Не знаю почему, но код в xcode только начал работать. Я очень счастлив. Спасибо всем за ваше время.

//here is JUCE's code
//==============================================================================
/** This template-overloaded class can be used to convert between var and custom types.


    @tags{Core}
*/
    template <class Type> struct VariantConverter
    {
        static Type fromVar (const var& v)              { return static_cast<Type> (v); }
        static var toVar (const Type& t)                { return t; }
    };
//here is my addition
    template <> struct VariantConverter<Point<int>>
    {
        static Point<int> fromVar (const var& v)
        {
            return Point<int>
            (
             { v[0].operator int(), v[1].operator int() }
             );
        }
        static var toVar (const Point<int>& p)
        {
            return Array<var>({ p.getX(), p.getY() });
        }
    };

Привет, я не уверен, как мне добиться вышеуказанного кода. Класс типа typedef для замены

Point<int>

было бы здорово. Я добавляю файл JUCE.

XCode дает мне две ошибки

/Tools/JUCE/modules/juce_core/containers/juce_Variant.h:41:18: Expected unqualified-id

и

/Tools/JUCE/modules/juce_core/containers/juce_Variant.h:343:46: Expected '>'

Спасибо

Answer 1

template <>
struct VariantConverter<Point<int>>
{ /* ... */ };

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

template <typename>
struct VariantConverter;

Иногда бывает полезно, если только специализации существуют, тогда вы просто объявите базу, как указано выше, хотя обычно это имеет реализацию по умолчанию:

template <typename T>
struct VariantConverter
{
    static T fromVar(var const& v);
};

Исключительно, что будет var в вышеприведенном примере? Т как хорошо? Еще один параметр шаблона VariantConverter struct? Третий вариант - это тот, который я показываю: параметр шаблона функции:

template <typename T>
struct VariantConverter
{
    template <typename var>
    static T fromVar(var const& v);
};

Теперь вы можете предоставить реализацию по умолчанию, подходящую для большинства типов & ndash; если является разумным (в противном случае, возможно, было бы более уместным не реализовывать стандартное значение и просто иметь специализации).

ОК, сейчас мы можем специализироваться:

template <>
struct VariantConverter<Point<int>>
// Point<int> now is what previously was T; could be any arbitrary type, not
// necessarily Point<int>, but std::string, double, ...
{
    // still, you need to tell what var actually is
    // maybe you have defined a class for already? similar to std::vector?
    // assuming so this time...
    static Point<int> fromVar (var const& v)
    {
        return Point<int>
        (
           // are you sure point accepts an initializer list?
           // or do you intend to create first a point and then
           //  use move/copy constructor???
           //{ v[0].operator int(), v[1].operator int() }
           // rather normal constructor directly:
           //v[0].operator int(), v[1].operator int()
           // however, explicitly calling cast operators is ugly, rather just cast:
           static_cast<int>(v[0]), static_cast<int>(<v[1])
           // or C style casts, if you prefer
           //(int)v[0], (int)v[1]
           // I personally would rather go with the former, though, for being
           // more "C++-ish"
        );
    }
};

Теперь, может быть, вы ищете что-то совершенно другое:

template <typename T>
struct VariantConverter
{
    static Point<T> fromVar(std::vector<T> const& v)
    {
        return Point<T>(v[0], v[1]);
    }
};

Наконец, как вы явно просили:

template <>
struct VariantConverter<Point<int>>
{
    using Type = Point<int>;
    static Type fromVar(/* ... */);
};

или, для второго варианта:

template <typename T>
struct VariantConverter
{
    using Type = Point<T>;
    static Type fromVar( /* ... */);
};

Answer 2

Извините за плохое общение. Английский - мой родной язык, и, несмотря на то, что я образован, я не одарен письменным общением. Вот большой контекст. Я пытаюсь добавить в существующий класс.

//This is the end of their code
  //==============================================================================
/** This template-overloaded class can be used to convert between var and custom types.


    @tags{Core}
*/
    template <class Type> struct VariantConverter
    {
        static Type fromVar (const var& v)              { return static_cast<Type> (v); }
        static var toVar (const Type& t)                { return t; }
    };
//here is my code
    template <> struct VariantConverter<Point<int>>
    {
        static Point<int> fromVar (const var& v)
        {
            return Point<int>
            (
             { v[0].operator int(), v[1].operator int() }
             );
        }
        static var toVar (const Point<int>& p)
        {
            return Array<var>({ p.getX(), p.getY() });
        }
    };

Answer 3

Поскольку существуют только статические методы, вам не нужен объект этого типа. Вы должны быть в состоянии назвать это как:

typedef Point<int> MyPoint;

MyPoint point(1,2); // call constructor of a Point<int>
var x = VariantConverter::toVar(point); //call static methods of struct
MyPoint point2 = VariantConverter::fromVar(x);