gibt es in der STL einen Container dessen Iteratoren einfach Pointer sind?

Also sowas wie

container<double> c;
double* iter = c.begin();

Bei Vektoren geht so etwas nicht und bei den anderen Standardcontainern selbstverständlich auch nicht, nur bei tr1::arrays<T,N> sind die Iteratoren so definiert.

Vielleicht gibt es auch eine Möglichkeit wie man die iteratoren auf pointer abbilden kann, natürlich nur wenn der Container seine Elemente linear speichert...

Danke

Aber da das Iterator-Konzept ein "abstrahierter Pointer" ist, wieso willst Du überhaupt den umgekehrten Weg gehen?

Bei std::vector und std:tr1::array kannst Du Dir jedoch einen Pointer auf den zusammenhängenden Bereich holen, mittels &container[0].

double* iter = &(*(c.begin()));

template<class ContainerType>
class ode_step_euler
{                                                                                  
     ContainerType dxdt;                                                            

 public:

     template<class CallMethod, class Iterator>
     void do_step( CallMethod deriv , double dt , Iterator start , Iterater end )
     {
         ContainerType::iterator dxdtiter = dxdt.begin();
         deriv( start , dxdtiter );
         while( start != end )
             *start++ += dt * (*dxdtiter++);
     }
};

Um diese Klasse zu benutzen, braucht man eine Funktion oder Klasse deriv. Viele Leute sind es gewohnt diese Funktion in der Form

void deriv( double *x , double *dxdt )
{
    x[0] = ...;
    x[1] = ...;
}

zu schreiben, so funktioniert es in den Numerical Recipies, in der gsl... Dann kann die Klasse ode_step_euler zum Beispiel so benutzt werden:

ode_step_euler<Container> euler;
Container state;
for( size_t i=0 ; i<1000 ; ++i )
{
    euler.do_step( deriv, 0.01 , state.begin() , state.end() );
    // do something with state
}

Deshalb wäre es gut ein Beispiel zu haben, dass dieser Funktionsaufruf von deriv mit double* immer klappt, d.h. es muss sichergestellt ist, daß die Iteratoren von Containertype in diesem Beispiel pointer sind. Es geht nur um ein Beispiel, um zu zeigen wie man die Klasse ode_step_euler benutzt mit pointern benutzt.

template <typename T>
T* ptr_begin(std::vector<T>& vec)
{
	return &vec[0];
}

template <typename T>
const T* ptr_begin(const std::vector<T>& vec)
{
	return &vec[0];
}

template <typename T>
T* ptr_end(std::vector<T>& vec)
{
	return &vec[0] + vec.size();
}

template <typename T>
const T* ptr_end(const std::vector<T>& vec)
{
	return &vec[0] + vec.size();
}

Die Anwendung ist dann superleicht:

euler.do_step(deriv, 0.01, ptr_begin(state), ptr_end(state));