template with function-style parameter

[R.Stiltskin]

I have been experimenting with a simple array class template two ways: one using only a class parameter, and the other using a function-style parameter. Everything else is the same.

The version that uses only the class parameter tests out fine. In my test driver I was able to use a variable "arraySize", prompt the user for a value for that variable, and use it to allocate arrays with no errors.

But in the version that uses a function-style parameter (using "arraySize" as the function-style template parameter), it would not compile until I changed the declaration of arraySize to a constant, for example:
const int arraySize = 5;
Of course, I can no longer prompt the user to designate the size.

Is this normal? Is this a limitation of function-style parameters for templates? Or did I do something else wrong?

[Zach L.]

The capabilities of templates are derived from the fact that they are 'interpreted' (for lack of a better term) by the compiler at compile time, based on what the parameters are. Essentially, it generates a new copy of all of your code for each unique set of parameters you feed it, and of course, the program has no way of generating this code by itself at runtime (which is what the compiler is for).

Aside from static size limits for the array class, the 'function-style' version will also cause your program to be significantly larger than necessary since a new copy of the Array class' code will exist for every size array you use.

Hope thats understandable.
Cheers.

[R.Stiltskin]

Thanks, Zach. Your comments are perfectly understandable, but give rise to another question.

Given that a function template's nontype parameters are required to be constant values that are known at compile time, why would a programmer ever use that format?

Using my code as an example, is there ever a good reason to do this:

template<class Type, int s>
Array<Type, s>::Array(){
    a = new Type[size = s];
    }
...
};

int main(){
    const int size=10;
    ...
    Array<char,size> a1;
    ...
}

rather than this

template<class Type>
Array<Type>::Array(int s=10){
    a = new Type[size = s];
    }
...
};

int main(){
    const int csize=5;
    int vsize;
    ...
    cout << "Enter array size: " << endl;
    cin >> vsize;
    Array<char> ca(csize);   // any of these can be used to make an array
    Array<string> sa;        //   "    "     "
    Array<int> ia(vsize);    //   "    "     "
    ...
}

since the latter version allows for compile-time instantiation using a constant OR a default parameter OR run-time instantiation?

By the way, I love your signature line.