0

我有一个模板类， Foo ：

template <class A, class B>
class Foo
{
public:
    Foo(A &aInstance);

private:
    Attr<Foo> _attr;
};

然后我有另一个名为 Attr 的模板类，它是我的 Foo 类的一个属性，它以 Foo 类本身作为模板参数。

template <class C>
class Attr
{
    class SomeType
    {
        SomeType();
        ~SomeType();
    };

    Attr(const SomeType* st);
    ~Attr();

private:
    Attr();
}

我想在构造函数中初始化 _attr（Attr 类型），将模板中的第一个参数转换为 SomeType。

Foo 构造函数实现：

template<class A, class B>
Foo<A, B>::Foo(A &aInstance):
    _attr(
        (Attr<Foo<A, B> >::SomeType *) aInstance)
{

}

这不会编译：

错误：“）”标记之前的预期主表达式

该错误指的是 Foo 构造函数实现中的转换线，好像 SomeType 未被识别。

我现在有一个实例，但仍然遇到同样的错误。

4

5 回答 5

2 
template<class A, class B>
Foo<A, B>::Foo():
    _attr(
        (Attr<Foo<A, B> >::SomeType *) A)
{

}

A是一种类型，您正试图将其传递给构造函数。你需要一个实例。

于 2011-07-07T13:18:19.170 回答
1

0)

(Attr<Foo<A, B> >::SomeType *) A)

那时，A是一个类型名，即一个类型的名称，因此，不是你可以转换的任何东西。

1)

此外，Foo<A,B>依赖于A，B因此Attr<Foo<A, B> >也是依赖名称。因此，您需要一个typenamethere 来告诉编译器这SomeType是一个类型：

(typename Attr<Foo<A, B> >::SomeType *) somePointer)

2)

此外，在 C++ 中，通常更喜欢 C++-casts 而不是 C-style-casts。你会发现很多错误。另请参阅本教程:)

3)

另一方面：你确定你需要按设计转换，还是应该Attr准确地指向一个Foo<A, B>？

于 2011-07-07T13:21:09.137 回答
1

首先， Attr 类（在您的代码段中）不使用 C 类型，因此您应该解释它在哪里使用，以及 C 和 SomeType 之间的关系是什么。

二、在这几行

Foo<A, B>::Foo():
    _attr(
        (Attr<Foo<A, B> >::SomeType *) A)

A 是类型而不是对象。如果 _attr 应该用 Foo 对象本身初始化，那么你应该传递指针 this。

Foo<A, B>::Foo():
    _attr(
        (Attr<Foo<A, B> >::SomeType *) this)

但是，此时 Foo 对象尚未构造，因此请注意您对 Attr 构造函数中的指针所做的操作。

于 2011-07-07T13:21:15.957 回答
0

尝试将您的构造函数更改为：

template<class A, class B>
Foo<A, B>::Foo(A &aInstance):
    _attr(
        (typename Attr<Foo<A, B> >::SomeType *) &aInstance) {}

你会，因为你想要一个指针，需要添加一个地址运算符来获取实例对象的地址......否则aInstance将不是指针类型，而是引用类型，它实际上与传递对象本身（通过引用），而不是指向对象的指针。

于 2011-07-07T13:26:34.263 回答
0

这对我有用。几个 typedef 有助于更容易理解模板代码：

template<class C>
class Attr
{
public:
    class SomeType
    {
        SomeType();
       ~SomeType();
    };

    typedef typename Attr<C>::SomeType ReachIntoSomeType;

    Attr(const SomeType* st) { }
    ~Attr() { }

private:
    Attr();
};

template <class A, class B>
class Foo
{
public:
    Foo(A &aInstance) : _attr(reinterpret_cast<AttrOfFoo::ReachIntoSomeType*>(aInstance))     
    { }

private:
    typedef Attr<Foo> AttrOfFoo;
    AttrOfFoo _attr;
};
于 2011-07-07T15:44:08.013 回答