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

由于只有静态方法，因此不需要该类型的Object。您应该可以这样称呼它：

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

Answer 2

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

这里提供的是模板专业化。如果要专业化，首先需要一个基本模板，然后才能进行编译。

template <typename>
struct VariantConverter;

有时，如果仅存在个专业，这将很有用，那么您只需按照上面的说明声明基数，尽管价格很普通，但是具有默认实现：

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

唯一的，上面的示例中var应该是什么？ T也一样？ VariantConverter结构的另一个模板参数？第三种选择是我展示的一种：函数模板参数：

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

现在，您可以提供适用于大多数类型的默认实现-如果存在合理的（否则，不实现默认值而只拥有专门知识可能更合适）。

好的，现在，我们可以专门处理：

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 3

抱歉，我的沟通不畅。英语是我的第一语言，尽管受过教育，但我在书面交流方面并不聪明。这是更大的背景。我正在尝试添加到现有课程。

//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() });
        }
    };

如何在新模板中使用模板化类？

3 个答案: