1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
|
/*
* File: fixary.h
* Summary: Fixed size 2D vector class that asserts if you do something bad.
* Written by: Jesse Jones
*/
#ifndef FIXARY_H
#define FIXARY_H
#include "fixvec.h"
// ==========================================================================
// class FixedArray
// ==========================================================================
template <class TYPE, int WIDTH, int HEIGHT> class FixedArray {
//-----------------------------------
// Types
//
public:
typedef TYPE value_type;
typedef TYPE& reference;
typedef const TYPE& const_reference;
typedef TYPE* pointer;
typedef const TYPE* const_pointer;
typedef unsigned long size_type;
typedef long difference_type;
// operator[] should return one of these to avoid breaking
// client code (if inlining is on there won't be a speed hit)
typedef FixedVector<TYPE, HEIGHT> Column;
//-----------------------------------
// API
//
public:
// ----- Size -----
bool empty() const { return WIDTH == 0 || HEIGHT == 0; }
int size() const { return WIDTH*HEIGHT; }
int width() const { return WIDTH; }
int height() const { return HEIGHT; }
// ----- Access -----
Column& operator[](unsigned long index) { return mData[index]; }
const Column& operator[](unsigned long index) const {
return mData[index];
}
template<class Indexer> TYPE& operator () (const Indexer &i) {
return mData[i.x][i.y];
}
template<class Indexer> const TYPE& operator () (const Indexer &i) const {
return mData[i.x][i.y];
}
void init(const TYPE& def) {
for ( int i = 0; i < WIDTH; ++i )
mData[i].init(def);
}
protected:
FixedVector<Column, WIDTH> mData;
};
template <typename Z>
class Matrix {
public:
Matrix(int width, int height, const Z &initial);
Matrix(int width, int height);
~Matrix();
void init(const Z &initial);
Z &operator () (int x, int y)
{
return data[x + y * width];
}
const Z &operator () (int x, int y) const
{
return data[x + y * width];
}
private:
Z *data;
int width, height, size;
};
template <typename Z>
Matrix<Z>::Matrix(int _width, int _height, const Z &initial)
: data(NULL), width(_width), height(_height), size(_width * _height)
{
data = new Z [ size ];
init(initial);
}
template <typename Z>
Matrix<Z>::Matrix(int _width, int _height)
: data(NULL), width(_width), height(_height), size(_width * _height)
{
data = new Z [ size ];
}
template <typename Z>
Matrix<Z>::~Matrix()
{
delete [] data;
}
template <typename Z>
void Matrix<Z>::init(const Z &initial)
{
for (int i = 0; i < size; ++i)
data[i] = initial;
}
#endif // FIXARY_H
|
