fabricio.olivetti@gmail.com wrote:

> I am designing a class to read a data file and provide access to
> another class, but as this dataset may contain either double or int
> values, and some of them may be very large I'd like to create a class
> that can decide upon allocating a vector of "char" (for the integral
> values may be enough) or a vector of double.
> But I can't see how can I do that...using templates I still have to
> determine, prior the class declaration, which type this class will
> hold.
>
> Of course I could declare something like this:
>
> class foo{
>
> private:
> vector< char > cData;
> vector< double > dData;
> bool type;
> public:
> double getData(unsigned i);
> };
>
> and always return a double (casting the char when required) and using
> just the required data type using a flag to determine which type is
> used by the class.
> How would be the most elegant and optimized way of doing that?

The most elegant and probably also most efficient way is to not solve the
problem. Just store doubles as doubles instead of converting back and forth
on the fly.

As for how you _could_ go about the problem of representing different data
transparently, you might have a look at this:


#include <vector>
#include <cassert>
#include <iostream>
#include <memory>

class foo {
public:

typedef std::size_t size_type;

private:

struct base {

virtual
void push_back ( double ) = 0;

virtual
double get ( size_type ) const = 0;

virtual
base * clone ( void ) const = 0;

virtual
~base ( void ) {}

};

template < typename T >
struct node : public base {

std::vector< T > the_data;

void push_back ( double d ) {
the_data.push_back( d );
}

double get ( size_type n ) const {
assert( n < the_data.size() );
return ( the_data[n] );
}

base * clone ( void ) const {
return new node ( *this );
}

};

base * node_ptr;

public:

foo ( bool use_double = true )
: node_ptr ()
{
std::auto_ptr< base > dummy
( use_double ? new node<double> () : new node<char> () );
// put your filling routine here:
for ( unsigned i = 0; i < 20; ++i ) {
dummy->push_back( 100 );
}
node_ptr = dummy.release();
}

double getData ( size_type n ) const {
return ( node_ptr->get( n ) );
}

foo ( foo const & other )
: node_ptr ( other.node_ptr->clone() )
{}

~foo ( void ) {
delete ( node_ptr );
}

};

int main ( void ) {
foo f;
std::cout << f.getData( 5 ) << '\n';
}


Best

Kai-Uwe Bux