Disregrading the fact that the array index operator in the following
vect class might technically use undefined behaviour, nevertheless
there isnt a way it can fail (assuming a valid index) , or is there?

regards
Andy Little

#include <stdexcept>
#include <cassert>

     template <typename T>
     struct vect
     {
         T x,y,z;

         T & operator[](int n)
         {
             if((n < 0)|| (n > 2)){
                 throw std::logic_error("array subscript out of range");
             }
             if( sizeof(vect) == 3 * sizeof(T)){
                 T * p = & x;
                 return p[n];
             }
             else{
                 switch (n){
                     case 0:
                         return x;
                     case 1 :
                         return y;
                     default:
                         return z;
                 }
             }
         }
         T const & operator[](int n)const
         {
             if( (n < 0) || (n > 2)){
                 throw std::logic_error("array subscript out of range");
             }
             if( sizeof(vect) == 3 * sizeof(T)){
                 T const * p = & x;
                 return p[n];
             }
             else{
                 switch (n){
                     case 0:
                         return x;
                     case 1 :
                         return y;
                     default:
                         return z;
                 }
             }
         }
         vect(): x(0),y(0),z(0){}
         /*
             Other operations omitted for clarity

             ...

         */
     };

int main()
{
     vect<double> v;
     v[0] = 2;
     double n = v.x;
     assert(v[0] == n);

In this type of expression, losing one execution cycle is worth
spending some time on. The class is a template and therefore T could be
anything form a bool to a long double and beyond in size. I am making 3
assumptions:

1) The code is (in practise) correct for various T's, compilers and
OSes.

2)  it is trivial for the compiler to deduce that the condition  of the
if statement is a compile time constant, so for an optimising compiler
the code is equivalent to:

#if ( VECT_SIZE == THREE_SIZEOF_T)
                 T * p = & x;
                   return p[n];
#else
                   switch (n){
                       case 0:
                          return x;
                       case 1 :
                           return y;
                       default:
                           return z;
                }
#endif

3) That the array access version of the expression is always at least
as fast as and maybe faster than the switch statement.

Assuming those 3 assumptions hold I may gain something , but I appear
to lose nothing though after looking at Carl Barrons version, I see the
scheme may be compromised by the array bounds checking! Carls code
looks cleaner, however if the first ( correctness) assumption is wrong
it isnt worth considering alternative expressions to the switch AFAICS.

Thanks for all the replies.

regards
Andy Little

IIRC the same issue (allowing use of array access operations) came up
in relation to std::complex either on this list or comp.std.c++, though
I cant find the references at the moment.

As an example of the superiority of the array access approach in some
situations, imagine a function to detect whether two points are
touching  each other within a tolerance vector. Further assume that you
have two implement this for a 2Dand a 3D space. The array notation is
much more convenient. (I will leave the member version to do):

// type_trait to return the number of elements in a vect
template<typename T>
struct extent;

// Does vect a, touch vect b within the given tolerance?
// Vect may be a 2d or 3d vector
template <typename Vect>
bool touches( Vect const & a, Vect const & b, Vect const & tolerance)
{
     using boost::extent;
     for (int i = 0; i < extent<Vect>::value; ++i){
       using std::abs;
       if ( abs( a[i] - b[i]) > abs(tolerance[i]) ){
             return false;
       }
     }
     return true;

#include <stdexcept>

template <typename T>
struct vect
{
     struct { // to init by zeroes automatically (saves you from writing
of initialization list for default constructor)
         union {
             T data_[3];
             struct {
                 T x,y,z; // saves you from vec.x() syntax
             };
         };
     };

     T& operator[](int n)
     {
         if((n < 0)|| (n > 2)){
             throw std::logic_error("array subscript out of range");
         }
         return data_[n];
     }
     // NOTE: return by value for simple built-in types is better
     T operator[](int n)const
     {
         if( (n < 0) || (n > 2)){
             throw std::logic_error("array subscript out of range");
         }
         return data_[n];
     }
     vect() {}
     /*
         Other operations omitted for clarity

         ...

     */

int main()
{
      vect<double> v;
      assert(v.x == 0);
      assert(v.y == 0);
      assert(v.z == 0);
      v[0] = 2;
      v.y = 3;
      double n = v.x;
      assert(v[0] == n);

          std::cout << "Test passed\n";
      std::cin.get();