1. He gave it a try, yes I do help, I did point out where to do things and told him why. He kept going on his own. You on the other hand saw something that makes no difference in any manner other than because it works you started this whole arguement then ignored the origonal poster. I have nothing more to say to you.

2. He kept going on his own.
Apparently.

He seemed to post the same thing over and over until someone did it for him, no matter what anyone said.

And frankly, I am a bastard, so you'll have to deal with that.

3. Since someone else has already done it, and it would be unreasonable for OP to turn in a template programming form, I'll go ahead and post this solution.

This question gave me an idea.
Code:
```template <unsigned int N>
struct Fibonacci
{
enum{value = Fibonacci<N - 1>::value + Fibonacci<N - 2>::value};
};

template <>
struct Fibonacci<1>
{
enum{value = 1};
};

template <>
struct Fibonacci<2>
{
enum{value = 1};
};```
Is there a way to avoid that second specialization, and specify that the specialization for 1 is for 1 and 2?

4. Not really. You need a base case for the recursion which is going to occur. The specializations for those values 1 and 2 are such cases.

5. Originally Posted by ~Kyo~
You do not use () around return.
I could just as easily state that you do not have a space after an open bracket (as this personally annoys me).
But we would both be in the wrong because the correct way to phrase it would be:

"You do not need to have a space after an open bracket"
or
"You should not have a space after an open bracket"

Phrasing it as you did is just rubbish in which case anyone else is right to correct you.
Code:
`return (((((0)))));`

6. Originally Posted by User Name:
Is there a way to avoid that second specialization, and specify that the specialization for 1 is for 1 and 2?
Nope. Uou could specialise for zero instead of two, but I don't think that gets you anywhere useful:
Code:
```template <>
struct Fibonacci<0>
{
enum{value = 0};
};```