Quote:Original post by iMalc
Problem solved![grin]

Quote:Original post by l0calh05t
Okay, does anyone see how I can do this without the macro?

template < typename Self , typename T , size_t N >struct arith_array_base {	Self& operator+=( const Self & other ) {		for ( unsigned i = 0 ; i < N ; ++i ) data += other.data;		return static_cast< Self& >( *this );	}	Self& operator-=( const Self & other ) {		for ( unsigned i = 0 ; i < N ; ++i ) data -= other.data;		return static_cast< Self& >( *this );	}	      T& operator[]( size_t i )       { assert( i < N ); return data; }	const T& operator[]( size_t i ) const { assert( i < N ); return data; }	      T* ptr()       { return data; }	const T* ptr() const { return data; }	friend Self operator+( const Self & lhs , const Self & rhs ) { Self copy(lhs); copy += rhs; return copy; }	friend Self operator-( const Self & lhs , const Self & rhs ) { Self copy(lhs); copy -= rhs; return copy; }protected:	T data[N];};struct vertex : arith_array_base< vertex , float , 3 > {};int main() {	vertex v1,v2,v3;	v1 = v2 + v3;}

arith_array_base( const arith_array_base & other_ ) {    const Self& other = static_cast< const Self& >( other_ );    ...}

struct vertex2d : arith_array_base< vertex2d , float , 2 > {};struct texcoord : arith_array_base< texcoord , float , 2 > {};int main() {	vertex2d v;	texcoord t;	v = t;}

Quote:Original post by iMalc
You know the scary thing is, I've actually used that method before (Just didn't know what it was called). However I later decided that it was better to switch to using a typedef instead, as the downside that I found of the above, is that you have to cast the 'this' pointer everywhere when returning it.

Quote:Original post by Julian90
0) place spaces after the '\'s in the macro to stop it showing up as one line

Quote:1) use std::copy instead of memcpy to ensure that something like tuple<fixed_point, 3> calls fixed_point's copy constructor and assignment operator correctly.

Quote:2) Consider adding a begin() and end() member function to be more SC++L compatible

Quote:
3) operator- and operator+ should be free functions.

Quote:
Okay now im done being picky my suggestion is: typedef tuple<float, 3> vec;

Quote:
Or if thats not flexible enough then:
*** Source Snippet Removed ***

I really dont see the problem with using a macro though just make it a local macro (i.e. #undef it when your done) and the most prominant issue with macros disapears (i.e. that they dont respect scoping rules) beacause it will never interact with client code.

Quote:Original post by MaulingMonkey

Quote:Original post by iMalc
Problem solved![grin]

Except for the return types at any rate in this case ;-)

Quote:A pattern commonly known as CRTP, or the Curiously Reoccuring Template Pattern. Obtuse, I know. Basically, a class passes itself as a template parameter to a base class. See vertex's definition.

*** Source Snippet Removed ***

template<class T, int N, class Self = tuple> struct tuple{	/* bla */}

color4f col;vector4f vec = tuple_type_cast<vector4f>(col); // T and N remain constant

Quote:
Notes:

1) I always place the Self parameter first, to help make it clear when CRTP is being used.
2) "> 0" invariant mantained with signedness (allowing us to generate compile time warnings) rather than run time checks.

Quote:3) Verbose name I know, but it's closer to boost::array than boost::tuple, so I couldn't help changing it.

Quote:4) Crazy whitespacing I know, I'm just obsessed with lining up duplicated code so it's easily spotted, and pattern variations (accidental or intentional) made obvious.
5) Your current operator+= didn't work (there is no "result" local variable to be returned, and even if there were, since it returns a reference, that would've been horribly broken anyways.

Quote:6) It's easier to implement + in terms of +=, so I do so.
7) All functions listed inline to the class definition are implicitly of inline linkage, so I didn't bother explicitly repeating that.

Quote:8) Generally fiddled around into conforming to my own standards :P.

Quote:9) Although it was not involved here, copy-construction and assignment are special cases in that the arguments involved cannot simply be Self, as they will not override the autogenerated versions. Instead, if the members of Self were required, you would end up with something like:

arith_array_base( const arith_array_base & other_ ) {    const Self& other = static_cast< const Self& >( other_ );    ...}

Quote:10) I could've safely used arith_array_base as the argument types as well, since I don't use any members specific to Self in the base class, since each class that uses arith_array_base gets their own version (thanks to the Self parameter being unique to the class), no worries about a situation like this:

struct vertex2d : arith_array_base< vertex2d , float , 2 > {};struct texcoord : arith_array_base< texcoord , float , 2 > {};int main() {	vertex2d v;	texcoord t;	v = t;}

error C2679: binary '=' : no operator found which takes a right-hand operand of type 'texcoord' (or there is no acceptable conversion)

Quote:Original post by l0calh05t
But will this work?

*** Source Snippet Removed ***

Because sometimes a tuple is just a plain and simple tuple.

template<class T, int N, class Self = tuple>struct tuple{	/* ... */};

template<class T, int N, class Self = tuple<T,N> >struct tuple{	/* ... */};

template<class T, int N, class Self = tuple<T,N> >struct tuple{	/* ... */};template<class T, int N>struct tuple<T,N,tuple<T,N> >{	/* ... */};