Re: More concise syntax for addressing std::vector* ???
* Peter Olcott:
"Vaclav Haisman" <v.haisman@sh.cvut.cz> wrote in message
news:49C509E1.1090309@sh.cvut.cz...
Peter Olcott wrote, On 21.3.2009 14:03:
"Balog Pal" <pasa@lib.hu> wrote in message
news:gq1nc6$1nhk$1@news.ett.com.ua...
"Peter Olcott" <NoSpam@SeeScreen.com>
Is there a more concise way of saying this:
Ptr->operator[](0)
(*Ptr)[0];
That worked in this simple case. What about this more
complex case:
Number03 = Array01.Array->operator[](0).
Array->operator[](0).
Array->operator[](0).
Array->operator[](0).
Array->operator[](0).
Array->operator[](0).Number;
Such deep array structures are highly unlikely. If you do
not like
(*vecptr)[0] then use reference: std::vector<foo> & v =
*vecptr; v[0];.
It is a given (like in geometry, it can't change) design
requirement that the depth of reference specified above can
not be changed. I don't want to explain my reasoning because
that would require disclosing proprietary information.
The above syntax compiles and produce the desired
functionality. I just want to be able to specify it more
concisely if possible.
SOLUTION 1.
Define a function 'in' of 7 arguments, then write something like
Number03 = in( Array01, 0, 0, 0, 0, 0, 0 );
Or, if you want a more general solution, under assumption that you cannot change
the type definitions for that structure:
SOLUTION 2.
<code>
#include <iostream>
#include <vector>
#include <stddef.h>
#ifdef _MSC_VER
# pragma warning( disable: 4503 ) // decorated name length exceeded
#endif
//----------------------------------- Silly 6-dimensional vector:
struct NumberHolder
{
double number;
NumberHolder( double x ): number( x ) {}
};
template< typename T >
struct VecPtrHolder
{
T* array;
VecPtrHolder( T& a ): array( &a ) {}
};
typedef std::vector< NumberHolder > Vec1D;
typedef std::vector< VecPtrHolder< Vec1D > > Vec2D;
typedef std::vector< VecPtrHolder< Vec2D > > Vec3D;
typedef std::vector< VecPtrHolder< Vec3D > > Vec4D;
typedef std::vector< VecPtrHolder< Vec4D > > Vec5D;
typedef std::vector< VecPtrHolder< Vec5D > > Vec6D;
//----------------------------------- Machinery to index the beast:
template< typename T > struct ElemTypeOf;
template< typename T, typename U > struct ElemTypeOf< std::vector<T, U> >
{
typedef T Type;
};
template< typename V > struct In;
template< typename V > struct In< VecPtrHolder<V> >
{
V* myArray;
In( VecPtrHolder<V>& holder ): myArray( holder.array ) {}
In< typename ElemTypeOf<V>::Type > operator[]( size_t i )
{
return (*myArray)[i];
}
};
template<>
struct In< VecPtrHolder< std::vector< NumberHolder > > >
{
typedef std::vector<NumberHolder> Vec;
Vec* myVecPtr;
In( VecPtrHolder<Vec>& v ): myVecPtr( v.array ) {}
NumberHolder& operator[]( size_t i )
{
return (*myVecPtr)[i];
}
};
template< typename V >
In< VecPtrHolder< V > > in( VecPtrHolder<V> h ) { return h; }
//----------------------------------- Example usage:
int main()
{
using namespace std;
Vec1D v1( 1, 3.14 );
Vec2D v2( 1, v1 );
Vec3D v3( 1, v2 );
Vec4D v4( 1, v3 );
Vec5D v5( 1, v4 );
Vec6D v6( 1, v5 );
VecPtrHolder< Vec6D > array01( v6 );
cout << in( array01 )[0][0][0][0][0][0].number << endl;
}
</code>
For this latter solution it's probably a good idea to extend it to support
const-ness.
But the best of idea of all is perhaps
SOLUTION 3.
To check whether the program logic is sound. It's a common newbie mistake to end
up with huge and/or multi-dimensional arrays. Generally it reflects some failure
in understanding the problem domain.
Cheers & hth.,
- Alf
--
Due to hosting requirements I need visits to <url: http://alfps.izfree.com/>.
No ads, and there is some C++ stuff! :-) Just going there is good. Linking
to it is even better! Thanks in advance!