Question

我已经编写了一个（数组）容器类模板（让我们称之为智能数组），以便在BREW平台中使用它（它不允许很多C ++结构，如STD库，异常，它有一个非常小的C ++运行时支持）;写这篇文章的时候，我的朋友说Boost中已经存在这样的东西，叫做 MultiArray ，我试过了，但ARM编译器（RVCT）却有100多个错误。我没见过Boost.MultiArray的来源，我最近才开始学习模板;模板元编程对我很感兴趣，虽然我不确定这是否是一个可以归类的严格的。

所以我希望我所有的C ++爱好者都能回顾它〜指出缺陷，潜在的错误，建议，优化等等;类似“你没有写自己的 Big Three 这可能导致......”。可能是任何批评都会帮助我提高课程水平，从而提高我的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]; };

由于多种原因 if 你只需要一个固定大小和固定类型的数组。编译器可以做出很多安全假设 - 在某些情况下，这会将对象大小减少到20％（与使用std :: vector相比）。它也更快，更安全。如果你到处使用它们，那么你最终可能会创建更多更大的二进制文件（与使用std :: vector相比）。

您应该阅读一个班级<boost/array.hpp>。

对不起，如果你觉得没有帮助 - 我认为阅读至少一个共同的生产质量实施（在投入新技术之前）会有所帮助。

一个简约的智能数组（容器）类模板

1 个答案: