极简智能数组(容器)类模板

Question

我编写了一个(数组)容器类模板(让我们称之为智能数组)，以便在BREW平台中使用它(它不允许许多C++结构，如STD库、异常等。它对C++运行时的支持非常小)；在编写这篇文章时，我的朋友说类似的东西已经存在于Boost中，称为MultiArray，我尝试了它，但是ARM编译器(RVCT)发出了1000多个错误。我没有看到Boost.MultiArray的源代码，我最近才开始学习模板；模板元编程让我很感兴趣，尽管我不确定这是否严格地可以这样分类。

因此，我希望我所有的C++爱好者都回顾它~指出缺陷、潜在的错误、建议、优化等等；比如“您没有编写自己的http://en.wikipedia.org/wiki/Rule_of_three_%28C%2B%2B_programming%29，这可能会导致.”。任何批评都可能帮助我提高这门课，从而提高我的C++技能。

编辑：我已经使用了std::vector，因为它很容易理解，以后它将被定制的向量类模板所取代，这个模板是为了在BREW平台中工作而制作的。另外，与C++0x相关的语法(如static_assert )也将在最终代码中删除。

smart_array.h

#include <vector>
#include <cassert>
#include <cstdarg>
using std::vector;

template <typename T, size_t N>
class smart_array
{
    vector < smart_array<T, N - 1> > vec;

public:
    explicit smart_array(vector <size_t> &dimensions)
    {
        assert(N == dimensions.size());

        vector <size_t>::iterator it = ++dimensions.begin();
        vector <size_t> dimensions_remaining(it, dimensions.end());

        smart_array <T, N - 1> temp_smart_array(dimensions_remaining);
        vec.assign(dimensions[0], temp_smart_array);
    }

    explicit smart_array(size_t dimension_1 = 1, ...)
    {
        static_assert(N > 0, "Error: smart_array expects 1 or more dimension(s)");
        assert(dimension_1 > 1);

        va_list dim_list;
        vector <size_t> dimensions_remaining(N - 1);

        va_start(dim_list, dimension_1);
            for(size_t i = 0; i < N - 1; ++i)
            {
                size_t dimension_n = va_arg(dim_list, size_t);
                assert(dimension_n > 0);
                dimensions_remaining[i] = dimension_n;
            }
        va_end(dim_list);

        smart_array <T, N - 1> temp_smart_array(dimensions_remaining);
        vec.assign(dimension_1, temp_smart_array);
    }

    smart_array<T, N - 1>& operator[](size_t index)
    {
        assert(index < vec.size() && index >= 0);
        return vec[index];
    }

    size_t length() const
    {
        return vec.size();
    }
};

template<typename T>
class smart_array<T, 1>
{
    vector <T> vec;

public:
    explicit smart_array(vector <size_t> &dimension) : vec(dimension[0])
    {
        assert(dimension[0] > 0);
    }

    explicit smart_array(size_t dimension_1 = 1) : vec(dimension_1)
    {
        assert(dimension_1 > 0);
    }

    T& operator[](size_t index)
    {
        assert(index < vec.size() && index >= 0);
        return vec[index];
    }

    size_t length()
    {
        return vec.size();
    }
};

示例用法：

#include "smart_array.h"
#include <iostream>
using std::cout;
using std::endl;

int main()
{
    // testing 1 dimension
    smart_array <int, 1> x(3);
    x[0] = 0, x[1] = 1, x[2] = 2;
    cout << "x.length(): " << x.length() << endl;

    // testing 2 dimensions
    smart_array <float, 2> y(2, 3);
    y[0][0] = y[0][1] = y[0][2] = 0;
    y[1][0] = y[1][1] = y[1][2] = 1;
    cout << "y.length(): " << y.length() << endl;
    cout << "y[0].length(): " << y[0].length() << endl;

    // testing 3 dimensions
    smart_array <char, 3> z(2, 4, 5);
    cout << "z.length(): " << z.length() << endl;
    cout << "z[0].length(): " << z[0].length() << endl;
    cout << "z[0][0].length(): " << z[0][0].length() << endl;
    z[0][0][4] = 'c'; cout << z[0][0][4] << endl;

    // testing 4 dimensions
    smart_array <bool, 4> r(2, 3, 4, 5);
    cout << "r.length(): " << r.length() << endl;
    cout << "r[0].length(): " << r[0].length() << endl;
    cout << "r[0][0].length(): " << r[0][0].length() << endl;
    cout << "r[0][0][0].length(): " << r[0][0][0].length() << endl;

    // testing copy constructor
    smart_array <float, 2> copy_y(y);
    cout << "copy_y.length(): " << copy_y.length() << endl;
    cout << "copy_x[0].length(): " << copy_y[0].length() << endl;

    cout << copy_y[0][0] << "\t" << copy_y[1][0] << "\t" << copy_y[0][1] << "\t" << 
        copy_y[1][1] << "\t" << copy_y[0][2] << "\t" << copy_y[1][2] << endl;

    return 0;
}

Answer 1

如果我理解你想从这种类型中得到什么：

简言之，最好使用以下形式：

template < typename T_, unsigned N_ >

struct t_array {

 `/* ... */`

 `static const size_t Size = N_;     typedef T_ T;`

 `T objects_[Size];`

};

由于许多原因，如果您只想要一个固定大小和固定类型的数组。编译器可以做出许多安全的假设--在某些情况下，这使我的对象大小减少到20% (与使用std：：向量相比)。它也更快更安全。如果在任何地方都使用它们，那么最终可能会创建更大的二进制文件(与使用std：：vector相比)。

有一个类<boost/array.hpp>你应该读。

很抱歉，如果你不觉得这有帮助-我认为至少阅读一种常见的产品质量实现(在尝试新技术之前)会有帮助。