C++Talk.NET

Glen Low · Guest

I have a template in my library macstl 0.2 that looks like this:

template <typename T, size_t n> class vec
{
...
};

For each value of n, I want to define a constructor that has exactly n
arguments e.g.

vec <int, 4> v (4, 5, 6, 7); // is a valid call, since n = 4, # of
args = 4
vec <int, 4> v (6, 4); // is an invalid call, since n = 4, # of args =
2

The allowable values of n are fairly small and bounded (n = 2, 4, 8,
16) so it's acceptable to make a solution that has a finite number of
variations.

These are the solutions I came up with so far, any comments and/or
better ones?

1. Define the guts in vec_base, then partially specialize vec on
various n to have those constructors. vec inherits from vec_base.

PROS: only the legal constructors are visible.
CONS: tedious to set up -- also need some twisty Barton-Nackman or
CRTP if operators need to be declared on vec.

2. Declare all the constructors in vec, but only define the ones that
are legal.

PROS: only one class.
CONS: turns compiler errors into linker errors. Metaprogramming that
relies on only those constructors being declared would fail for
example.

3. Turn the constructor into a templated constructor, then use our
trusty flavor-of-the-month (year?) enable_if to selectively enable the
right ones e.g.

template <typename T1, typename T2, typename T3, typename T4>
vec (T1 t1, T2 t2, T3 t3, T4 t4,
enable_if <n == 4 && is_convertible

Carl Barron · Guest

In article <9215d7ac.0408251818.62eca043 (AT) posting (DOT) google.com>, Glen Low
<glenlow (AT) pixelglow (DOT) com> wrote:

Andreas Harnack · Guest

I'm afraid there's no way to do this directly, simply because C++ doesn't
allow you to specify a variable length argument list; unless of course you
count the ellipse, but this gives you no control over the types, note even
the
number of arguments passed.

You can, however, construct an object by induction from a single element and
a 'lower order' object, i.e. something like:

vec<int, 4> v(x4, vec<int,3>(x3, vec<int,2>(x2, ... )));

That works fine but is not really convenient. Some people use macros as
a shortcut, but that's not perfect either. I prefer to go the other way
round
by providing an operator that constructs a 'higher order' object from a
given
one:

template < class T, int n > struct vec {
...
vec < T, n+1 >
operator()(T const& x) { return vec < T, n+1 > (x,*this); }
};

template < class T > struct vec<0> {
...
vec() {}
};

This way you could say (using the copy structor):

vec<int,4> v( vec<int,0>()(x1)(x2)(x3)(x4) );

The initial object doesn't carry any information, so this could be made a
global constant object:

vec<int,0> v0;
vec<int,4> v( v0(x1)(x2)(x3)(x4) );

Both versions use to work fine for me.
Even more tempting, however, is the comma operator:

template < class T, int n >
vec < T, n > operator,(vec < T, n-1 > const& v, T const& x) {
return vec<T,n>(x, v); }
template < class T >
vec < T, 2 > operator, (T const& x1, T const& x2) {
return vec<T,2>(x2, vec<T,1>(x1, vec<T,0>())); }

This way you could write

vec<int,4> v( (x1, x2, x3, x4) );

which probably comes closest to what you want. I tried this once and
the general idea seems to work; however, I had some problems to get
the compiler pick the right overloaded operator.
(Maybe I used overloading to heavily :-)

Andreas

"Glen Low" <glenlow (AT) pixelglow (DOT) com> wrote

Glen Low · Guest

Francis Glassborow · Guest

In article <SeLXc.8949$ZS5.432 (AT) news (DOT) cpqcorp.net>, Andreas Harnack
<andreas_harnack (AT) web (DOT) de> writes

Andreas Harnack · Guest

Yes, I've been thinking along that line too. What about:

int a[] = { 0, 1, 2, 3 };

namespace array
{
template < class T > T* begin(T a[]) { return a; }
template < class T, int n > T* end(T (&a)[n]) { return a+n; }
};

vector<int> v(array::begin(a), array::end(a));

Alternatively (or in addition) we might try to wrap an aggregate into a
fully featured container
of a constant size (haven't tried that yet):

namespace array
{
template < class T > class vect
{
T* v; int n;
public:
vect(T* a, int s): v(a), n(s) {}
T* begin() { return v; }
T* end() { return v+n; }
int size() { return n; }
// ... etc.
};

template < class T, int n > vect<T> vector(T (&a)[n]) { return
vect<T>(a, n); }
};

vector<int> v(array::vector(a));

We need to have a function template to create an appropriate object since as
far
as I understand only a function object can deduce the array size n.

Andreas

"Francis Glassborow" <francis (AT) robinton (DOT) demon.co.uk> wrote

Glen Low · Guest

Andreas Harnack · Guest

Hi Glen,

I think if you do it that way you can't check for the number of elements in
the array since T[n] is transformed into T*; To get round that you'll have
to
deduce the template argument from the parameter and that - as far as I
know -
works only for function templates (see my previous posting).

However, are you (or is anybody else Smile

aware of attempts to standardize
such a class to wrap an initialized aggregate into a container? 'Cause I use
to sketch down such classes/templates rather ad hoc and that's not really
convenient

Andreas

"Glen Low" <glenlow (AT) pixelglow (DOT) com> wrote

Glen Low · Guest

Andreas Harnack · Guest

Yes, that works for me too, even for initialized aggregates;
it seems the ampersand really does the trick. (I found it
the standard 14.8.2.4-13 by the way.)

template <int n> struct vec
{
vec (int (¶m) [n]) {}
};

int main ()
{
int x [] = { 0, 1, 2, 3 };

// vec <3> z1 (x); // error!
vec <4> z2 (x); // OK
// vec <5> z3 (x); // error!
}

I tried gcc version 2.95.4 and 3.0.4 on Debian 3.0
and gcc 3.2 on Suse 8.1.

But still, is there any work going on regarding a template
vector class with size as template argument? Or should
that be ask in its own thread?

Andreas

"Glen Low" <glenlow (AT) pixelglow (DOT) com> wrote

Glen Low · Guest