Problème avec l'article sur la meta-programmation

Bonsoir,
je suis actuellement en train de m'interesser au sujet de la "Métaprogrammation" (la lecture de l'article sur le Yes Engine m'a fait découvrir ce sujet :p) et j'essai donc d'implémenter les différents exemples qui sont présentés.

Le problème c'est que voilà, le code suivant (que je vais c/c) ne compilais pas:

Code:

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
#include <iostream>
 
class Vector {
    typedef double* iterator;
    typedef const double* const_iterator;
 
    public:
        Vector(double x, double y, double z) {
            element[0] = x;
            element[1] = y;
            element[2] = z;
        }
 
        iterator begin() { return element; }
        iterator end() { return element + 3; }
 
        double getX() { return element[0]; }
        double getY() { return element[1]; }
        double getZ() { return element[2]; }
 
        void setX(double x) { element[0] = x; }
        void setY(double y) { element[1] = y; }
        void setZ(double z) { element[2] = z; }
 
    private:
        double element[3];
};
 
enum Ops {
    Add,
    Minus,
    Const
};
 
template <typename T, int Op> struct UnaryOp {};
 
template <typename T> struct UnaryOpBase {
    UnaryOpBase(T t) : It(t) {};
    inline void operator ++() { ++It; }
 
    T It;
};
 
template <typename T> struct UnaryOp<T, Minus> : public UnaryOpBase<T> {
    UnaryOp(T t) : UnaryOpBase<T>(t) {};
    inline double operator *() { return -(*It); }
};
 
template <typename T> struct UnaryOp<T, Const> : public UnaryOpBase<T> {
    UnaryOp(T t) : UnaryOpBase<T>(t) {};
    inline void operator ++() {};
    inline double operator *() { return It; }
};
 
//! ---
 
template <typename T, typename U, int Op> struct BinaryOp {};
 
template <typename T, typename U> struct BinaryOpBase {
    BinaryOpBase(T t, U u) : It1(t), It2(u) {};
    inline void operator ++() { ++It1; ++It2; }
 
    T It1;
    U It2;
};
 
template <typename T, typename U> struct BinaryOp<T, U, Add> : public BinaryOpBase<T, U> {
    BinaryOp(T t, U u) : BinaryOpBase<T, U>(t, u) {};
    inline double operator *() { *It1 + *It2; }
};
 
int main() {
    Vector v(1, 1, 1);
    return 0;
}

Le problème est le suivant:

Code:

1
2
3
4
5
6
7
8
9
Metaprogrammation-01\main.cpp||In member function `double UnaryOp<T, 1>::operator*()':|
Metaprogrammation-01\main.cpp|46|error: `It' was not declared in this scope|
Metaprogrammation-01\main.cpp||In member function `double UnaryOp<T, 2>::operator*()':|
Metaprogrammation-01\main.cpp|52|error: `It' was not declared in this scope|
Metaprogrammation-01\main.cpp||In member function `double BinaryOp<T, U, 0>::operator*()':|
Metaprogrammation-01\main.cpp|69|error: `It1' was not declared in this scope|
Metaprogrammation-01\main.cpp|69|error: `It2' was not declared in this scope|
Metaprogrammation-01\main.cpp|69|warning: no return statement in function returning non-void|
||=== Build finished: 4 errors, 1 warnings ===|

Pour régler ce problème, à la ligne46 par exemples, j'ai du mettre:
inline double operator *() { return -(*UnaryOpBase<T>::It); }
au lieu de:
inline double operator *() { return -(*It); }

Or, dans l'exemple donné dans l'article ce n'est pas le cas. Quelqu'un peut-il m'expliquer pourquoi j'ai du expliciter la provenance de It ? Et sinon, quelqu'un a t-il une autre façon de procéder ?

Merci d'avance pour vos réponses, et bonnée soirée. :)