Re: Getting rid of repeating types in template instantiations
In article
<de7d7d24-cf1c-4a5b-8c55-492268ffed41@k2g2000hse.googlegroups.com>,
rsergeant <rsergeant@gmail.com> wrote:
Hi all,
I am currently studying data structures and algorithms and I'm
implementing them in C++ purely for fun. I've written a stack
containers that allows to set the internal container at compile time.
The stack template class looks as follows:
template <
typename T,
std::size_t C = 256,
typename TS = array <T, C>
class stack {
public:
typedef T data_type;
typedef T* ptr_data_type;
typedef T& ref_data_type;
stack ()
: container_ ()
{ }
stack (const std::size_t size)
: container_ (size)
{ }
// More methods (pop, push, size, capacity)
private:
TS container_;
};
When I however want to instantiate this class using a vector I have to
repeat the datatype twice:
#include <vector>
#include "stack.hpp"
int main (int argc, char** argv)
{
stack <int, 256> s1;
stack <int, 256, typename std::vector<int> > s2;
return 0;
}
The first definition (s1) uses the default container. In the second I
use a vector as container. My question... Can I do something so I
don't have to repeat the int type? That way I can't accidently define
the container with another type and the type stored in the stack.
I've been looking in some C++ books, but I can't find a definitive
answer (or I'm looking for the wrong thing).
write a meta function that builds the complete type from some
of the data;
// a type to hold a const so we can use it anywhere in stack_type.
template <std::size_t N>
struct size_t_
{
static const std::size_t value = N;
};
// default size
typedef size_t_<256> default_size;
// a place holder
struct nil_t {};
template <class T,std::size_t C = 256, class TS = array<T,C> >
class stack
{
// ...
};
template <class T,class S=nil_t,class R = nil_t>
struct stack_type
{
typedef stack<T,S::value,R> type;
};
template <class X> // for stl containers
struct stack_type<X,nil_t,nil_t>
{
typedef stack
<
typename X::value_type,
0, // some sentinel to use push_back/pop_back and dynamic alloc.
X
> type;
};
template <class T,class S>// array <T,S::value>
struct stack_type<T,S,nil_t>
{
typedef stack<T,S::value,typename array<T,S::value> > type;
};
template <class T>
struct stack_type<nil_t,T,nil_t>
{
typedef stack<T,defautl_size::value,typename
array<T,default_size::value> > type;
};
declarations look like [in some conditions these need to
be typenamed ]
stack_type<X>::type s1; //stl container;
stack_type<T,size_t_<N> >::type s2;// array<T,N>
stack_type<nil_t,T> s3; // array<T,256>
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]