我有以下(非常简化的)“容器”类:

class container
{
    public:

        template<typename T> container(const boost::shared_ptr<T> &rhs)
            : m_content(rhs) { }

        template<typename T>
        operator T const & () const
        {
            return get<T>();
        }

        template<typename T>
        T const & get() const
        {
            return *boost::any_cast< boost::shared_ptr<T> >(m_content);
        }

    private:
        boost::any m_content;
};

它应该将对象存储在 boost::any 中共享指针形式的容器。如果我存储一些对象，比如说 boost::shared_ptr<some_type> 的对象在容器中键入，我想通过用户定义的转换简单地获取引用(const some_type&)，这将允许执行如下操作:

boost::shared_ptr<some_type> x(new some_type);
container cx = x;

...

// user-defined conversion
const some_type &y = cx;

// a template conversion using a "getter"
const some_type &y = cx.get<some_type>();

有时，我需要存储从某种抽象类型派生的对象，并对该抽象类型的引用进行相同类型的类型转换，例如，像这样:

boost::shared_ptr<some_abstract_type> x(new some_derived_type);
container cx = x;

...

// user-defined conversion
const some_abstract_type &y = cx;

// a template conversion using a "getter"
const some_abstract_type &y = cx.get<some_abstract_type>();

用户定义的转换和模板“getter”都适用于 GCC。然而，英特尔 C++ 编译器似乎在“getter”工作时遇到了(用户定义的)转换问题。

例如，以下代码适用于 GCC 但不适用于 Intel:

#include <iostream>
#include <boost/any.hpp>
#include <boost/shared_ptr.hpp>

class container
{
    public:

        template<typename T> container(const boost::shared_ptr<T> &rhs)
            : m_content(rhs) { }

        template<typename T>
        operator T const & () const
        {
            return get<T>();
        }

        template<typename T>
        T const & get() const
        {
            return *boost::any_cast< boost::shared_ptr<T> >(m_content);
        }

    private:
        boost::any m_content;
};

class base
{
    public:
        virtual ~base() { }
        virtual void f() const = 0;
};

class derived : public base
{
    public:
        virtual ~derived() { }
        virtual void f() const { std::cout << "hello\n"; }
};

void foo(const container &c)
{
    const base & a = c;
    a.f();
}

int main()
{
    boost::shared_ptr<base> a(new derived);
    container c = a;
    foo(c);
}

使用英特尔时，我收到此错误:

test.cpp(44): error: no suitable user-defined conversion from "const container" to "const base" exists
      const base & a = c;
                       ^

compilation aborted for test.cpp (code 2)

另一方面，如果我替换 base与 derived在两个main()和 foo() (或使用“getter”而不是 foo() 中的类型转换)，一切都适用于英特尔。 T 时是否可以说服 Intel 编译器使用用户定义类型转换为引用类型是抽象类吗？

提前感谢您的任何想法。

编辑:有趣的是，使用指针类型的类型转换工作正常。如果我添加

template<typename T>
operator T const * () const
{
    return &get<T>();
}

到container分类并替换 foo()与

void foo(const container &c)
{
    const base * a = c;
    a->f();
}

然后它也适用于英特尔。

最佳答案

我会在 getter 中返回一个指针:

template<typename T>
T const * get() const {
    return boost::any_cast< boost::shared_ptr<T> >(m_content);
}

这避免了转换问题，并且如果您将空指针传递给您的容器，也不会立即崩溃。

例子:

void foo(const container &c)
{
    const base* a = c.get<base>();
    a->f();
}

您还可以添加一个函数 valid() 来检查容器中是否有东西:

bool valid() const {
    return m_content != NULL;
}

编辑:您对问题的补充正是按照这个方向进行的。

关于c++ - 模板用户定义转换为抽象类引用和英特尔编译器，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/22687695/