Question

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

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继承所有表，因为它的接口必须与数组交互（我试图避免使用虚函数）。

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

Answer 1

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

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

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*。

Answer 2

如果要使用模板，则需要指定模板参数：

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;

Answer 3

如果要创建Table的非模板基类并为该基类赋予int *和size_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;
}

如何将模板指针传递给内部类？

3 个答案: