0

长话短说，我有这样的事情：

template < int TSize >
class Table
{
public:
    void someInterface();

private:

    int array[TSize];
};


template < int TSize >
class SomeBigWrap
{
    SomeBigWrap() : table(), stuff(&table) {}
    Table<Tsize> table;

    OtherStuff_1 stuff;
};

class OtherStuff_1
{

    OtherStuff_1( Table * p) : pTable(p) {}
    const Table * pTable;

    void someFnc()
    {
        pTable->someInterface();
    }
};

OtherSuff_1 类需要一个指向表的指针并访问它的接口。但我不能只做一个指向模板类的指针。

我想知道，有没有办法在 SomeBigWrap 的当前实例中将一种表“传递”给 OtherStuff，而不使 OtherStuff 成为模板或使用虚拟函数？

我不能从一个 ITable 继承所有表，因为它的接口必须与数组交互（并且我试图避免使用虚拟函数）。

还有其他方法吗？也许某种形式的鸭子打字？还是我应该完全重新思考我的设计？

4

3 回答 3

0

恐怕您无能为力，您可能应该重新设计或只使用模板或虚拟。无论如何，这里有一些细微的修改：

您可能会考虑根本不存储指针，而是将其作为每个函数的参数传递：

class OtherStuff_1
{

    template<int TSize>
    void someFnc(const Table<TSize> * pTable)
    {
        pTable->someInterface();
    }
};

嵌套类可以工作：

template < int TSize >
class SomeBigWrap
{
    class OtherStuff_1
    {

        OtherStuff_1( Table * p) : pTable(p) {}
        const Table<TSize> * pTable;

        void someFnc()
        {
            pTable->someInterface();
        }
    };  
    SomeBigWrap() : table(), stuff(&table) {}
    Table<Tsize> table;

    OtherStuff_1 stuff;
};

您也可以使用void*不推荐的。

于 2012-11-16T23:46:33.213 回答
0

当您想使用模板时，您需要指定模板参数：

OtherStuff_1( Table<SomeSize> * p) : pTable(p) {}
const Table<SomeSize> * pTable;

你可能想这样定义它

template <int TSize>
class OtherStuff_1
{
    OtherStuff_1( Table<TSize> * p) : pTable(p) {}
    const Table<TSize> * pTable;

    void someFnc()
    {
        pTable->someInterface();
    }
};

...并将其SomeBigWrap用作

OtherStuff_1<TSize> stuff;
于 2012-11-16T23:46:45.113 回答
0

如果您要创建 Table 的非模板基类并将该基类赋予 anint *和 asize_t那么模板的构造函数可以将基指针分配给数组并将数组的大小分配给 size 变量。Table<TSize>然后，您可以分发指向似乎是某种动态数组的基类的指针。

事实上，我会让基类尽可能地镜像一个向量。

示例代码：

#include <iostream>

class TableBase {
public:
    typedef int value_type;
    typedef value_type* pointer;
    typedef value_type& reference;
    typedef pointer iterator;
    typedef const pointer const_iterator;
    typedef size_t size_type;

    TableBase(pointer table, size_type size) : m_array(table), m_size(size)
    {}
    iterator begin() const
    {
        return m_array;
    }
    iterator end() const
    {
        return m_array + m_size;
    }
    size_t size() const
    {
        return m_size;
    }
private:
    pointer   m_array;
    size_type m_size;
};

template<size_t TSize>
class Table: public TableBase
{
public:
    Table() : TableBase(array, TSize)
    {
        for(size_t i=0; i<TSize; ++i)
            array[i] = i;
    }

private:
    int array[TSize];
};

int main()
{
    Table<16> t;

    TableBase *tp = &t;

    for( TableBase::iterator i = tp->begin(); i != tp->end(); ++i ) {
        std::cout << *i << ',';
    }
    std::cout << std::endl;
    return 0;
}
于 2012-11-16T23:47:28.677 回答