First, the size of array put on stack has to be known at compile time, so
T s[];
shoud read for instance
T s[10];
Second array of T
is different type then T*
return by new
.
Solution:
class Stack
{
public:
Stack();
~Stack() { delete[] s_;} // to avoid memory leak delete the array
private:
T* s;
int N;
};
template <class T>
Stack<T>::Stack() {
s = new T[10];
}
usage:
int main() {
Stack<int> s;
return 0;
}
Even better, make the size of array a template parameter:
template <class T, size_t N>
class Stack
{
public:
Stack();
~Stack() { delete[] s_;} // to avoid memory leak delete the array
private:
T* s_;
int N_;
};
template <class T, size_t N>
Stack<T,N>::Stack() : N_( N) {
s_ = new T[N_];
}
usage:
int main() {
Stack< int,10> s;
return 0;
}
Even better
Use templates, make standard container a template parameter:
template <class T, size_t N, template<class T,
class = std::allocator<T> > class C >
class Stack
{
public:
Stack();
~Stack() {}
private:
C<T> s_;
int N_;
};
template <class T, size_t N, template<class T,
class = std::allocator<T> > class C >
Stack<T,N,C>::Stack() : N_( N) {
s_.resize( N_);
}
usage:
int main() {
Stack< int,10,std::vector > s;
return 0;
}