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
| #include <algorithm>
template <size_t N, typename Value>
class vecteur {
public:
typedef Value value_type;
typedef size_t size_type;
size_type size() const {return N;}
private:
value_type *v;//pointer les composantes
public:
vecteur(): v(new value_type(N)) {if(!v) throw std::runtime_exception("bad alloc");}
~vecteur() {delete v;}
vecteur(vecteur const& other) : v(new value_type(N)) {
if(!v) throw std::runtime_exception("bad alloc");
for (size_type i = 0; i<N; ++i) {
v[i]=other.v[i];
}
}
vecteur& operator=(vecteur other) { // passed by value
copy.swap(*this); // nothrow swap
return *this; // old resources now in copy, released in its dtor
}
void swap(vecteur& other) throw() {
using std::swap; // enable ADL, defaulting to std::swap
swap(v, other.v);
}
vecteur& operator <<=(size_type shift) {
std::rotate(v, v+(shift%N), v+N);
return *this;
}
vecteur& operator >>=(size_type shift) {return operator<<=(N-shift);}
std::rotate(v.rbegin(), v.rbegin() + 1, v.rend());
double& operator[] (int rang) {return v[rang];}
double operator[] (int rang) const {return v[rang];}
vecteur& operator *= (double scalar) {
for (size_type i = 0; i<N; ++i) v[i]*=scalar;
return *this;
}
vecteur& operator /= (double scalar) {
for (size_type i = 0; i<N; ++i) v[i]/=scalar;
return *this;
}
vecteur& operator += (vecteur const& other) {
for (size_type i = 0; i<N; ++i) v[i]+=other.v[i];
return *this;
}
vecteur& operator -= (vecteur const& other){
for (size_type i = 0; i<N; ++i) v[i]-=other.v[i];
return *this;
}
vecteur operator-() const {return vecteur(*this)*=-1;}
friend inline std::ostream& operator<<(std::ostream& stream, vecteur const& v) {
for(size_type i=0; i<N; ++i) stream<<v[i]<<' ';
return stream;
}
};
template <size_t N, typename Value>
inline vecteur<N, Value> operator * (vecteur<N, Value> const& v, double scalar) {return vecteur<N, Value>(v)*=scalar;}
template <size_t N, typename Value>
inline vecteur<N, Value> operator * (double scalar, vecteur<N, Value> const& v) {return vecteur<N, Value>(v)*=scalar;}
template <size_t N, typename Value>
inline vecteur<N, Value> operator / (vecteur<N, Value> const& v, double scalar) {return vecteur<N, Value>(v)/=scalar;}
template <size_t N, typename Value>
inline vecteur<N, Value> operator + (vecteur<N, Value> const& a, vecteur<N, Value> const& b) {return vecteur<N, Value>(a)+=b;}
template <size_t N, typename Value>
inline vecteur<N, Value> operator - (vecteur<N, Value> const& a, vecteur<N, Value> const& b) {return vecteur<N, Value>(a)-=b;}
template <size_t N, typename Value>
inline vecteur<N, Value> operator <<(vecteur<N, Value> const& v, size_t n) {return vecteur<N, Value>(v)<<=n;}
template <size_t N, typename Value>
inline vecteur<N, Value> operator >>(vecteur<N, Value> const& v, size_t n) {return vecteur<N, Value>(v)>>=n;} |
Partager