template<class T, int size = 50>
class genClass {
     T storage[size];
     ......
     void menberFun() {
            ......
            if (someVar < size){......}
            ......
       }
}

which uses an integer wariable size as a parameter to template to a declaration of genClass, which does not include size as a parameter to template and yet allows for flexibility of the value of the size. Consider a declaration of genClass's constructor. Is there any advantage of one version over another?

As I understand the question: Is there an advantage of using size as a template variable rather than as a parameter in the constructor.

There are probabily several reasons to prefer either approach. But consider what you CAN'T do with a template parameter relative to a constructor parameter.

First:
consider that operator= has been declared for each class, then

genClass<int,50> A;
genClass<int,80> B;

// this is a compile time error [ unless explicityly allowed]
A=B;

but this is at best a runtime error (if you have checking) and not if you don't. Or maybe you allow it/want to accept this.

genClass<int> A(50);
genClass<int> B(80);
A=B;       // No compiler error

If the intension is the first code version, then you have added better compiler error detection. Which is good, since a compiler error is almost always easier and better to get than a runtime error.

Other reasons include that compile time speed. FFT's can be sped up if the size is know at compile time.