ich habe folgenden Problem:

vector<int>v = {0,1,6,8} = {v0,v1,v2,v3}

ich messe immer folgende abstand:
vector<int>abstand1 = {[v1-v0],[v2-v1],[v3-v2]}
vector<int>abstand2 = {[v2-v0],[v3-v1]}
vector<int>abstand3 = {[v3-v0]}

das Problem habe ich gelöst aber mit eine sehr lange FKT.
über 300 Zeile hier einem abschnitt (bei v.size()=4)

int laenge = hilfs_vector.size();
switch(laenge)
{
case 1:
abstand1.push_back(v[0]);
break;
case 2:
for(unsigned int i=0 ; i<v.size()-1 ;++i)
{
 abstand1.push_back(v[i+1]-v[i]);
}
break;
case 3:
for(unsigned int i=0 ; i<v.size()-1 ;++i)
{
  abstand1.push_back(v[i+1]-v[i]);
}
for(unsigned int i=0 ; i<v.size()-2 ;++i)
{
  abstand2.push_back(v[i+2]-v[i]);
}
break;
case 4:
for(unsigned int i=0 ; i<v.size()-1 ;++i)
{
  abstand1.push_back(v[i+1]-v[i]);
}
for(unsigned int i=0 ; i<v.size()-2 ;++i)
{
  abstand2.push_back(v[i+2]-v[i]);
}
for(unsigned int i=0 ; i<v.size()-3 ;++i)
{
 abstand3.push_back(v[i+3]-v[i]);
}
break;

ganz banal gesagt ich bin immer zu fuss gegangen ja nach wie lange der vector ist und das ist gar nicht gut.

Man kann bestimmt mit 2 For schleife das ganze lösen aber ich komme nicht darauf

}

ich bin einen Anfänger

vector<int>v = {0,1,6,8} = {v0,v1,v2,v3}

ich messe immer folgende abstand:
vector<int>abstand1 = {[v1-v0],[v2-v1],[v3-v2]}
vector<int>abstand2 = {[v2-v0],[v3-v1]}
vector<int>abstand3 = {[v3-v0]}

und deinem Code:

void foo( std::vector< int > const & v )
{
    for( std::vector< int >::size_type i = 0; i < v.size() - 1; ++i ) {

        for( std::vector< int >::size_type k = 0; k < v.size() - 1 - i; ++k ) {

            std::cout << "v[ " << i + k + 1 << " ] - v[ " << k << " ];\n";
        }
        std::cout.put( '\n' );
    }
}

wie kann ich die Vektoren fühlen ?
abstand1, abstand2, abstand3... und wie sieht es aus wenn der Vektor v.size()= n;

Danke in voraus

ich habe das test Prog bei mir ausprobiert
Ich bekomme folgende Fehlermeldung:
error C2143: syntax error : missing ',' before ':'
error C3531: 'k': a symbol whose type contains 'auto' must have an initializer

und das ist genau in diesen Zeile:

for( auto k : result[ i ])

ich habe Visual Studio 2010

Ich habe mehrere Vektoren v1,v2,v3,v4.....v26
ich möchte alle vektoren v1-v26 in einem einzigen Vektor reinpacken?
Wie mache ich das am besten dynamisch ?

Sind alle vectors in einem Container, oder sind sie alle Einzelgänger?

PS:
Das Visual Studio 2010 kann noch kein C++11, daher kann dein Compiler die for-Schleife nicht übersetzen.

PS:
Das Visual Studio 2010 kann noch kein C++11, daher kann dein Compiler die for-Schleife nicht übersetzen.

Doch, ein bisschen: Und die for_each Schleife kann er. Jedoch mit anderer Syntax (so wie in C# glaube ich)

ich kriege das irgendwie nicht hin so ein Schande....

@out Sind alle vectors in einem Container, oder sind sie alle Einzelgänger?

-->Sie sind Einzelgänger.

das heisst jedes Mal muss ermittelt werden wie viel Vektoren habe ich und wie lange jeden Vektor

Das verstehe ich nicht. Wenn alle vectors Einzelgänger sind, dann sind es doch immer gleich viele vectors. Das musst du ja hartcodiert haben. Wieso musst du das dann jedes Mal ermitteln? Wenn es hartcodiert ist, sind es doch jedes mal gleich viele?

#include <numeric>
#include <vector>
using namespace std;

int main()
{
	vector<int> v1(10);
	iota( begin(v1), end(v1), 10);
	vector<int> v2(10);
	iota( begin(v2), end(v2), 20);
	vector<int> v3(10);
	iota( begin(v3), end(v3), 30);
	vector<int> v4(10);
	iota( begin(v4), end(v4), 40);
	vector<int> v5(10);
	iota( begin(v5), end(v5), 50);

    // Hier gehts für dich los:
	unsigned size = v1.size() + v2.size() + v3.size() + v4.size() + v5.size();
	vector<int> all;
	all.reserve( size );
	all.insert( end(all), begin(v1), end(v1) );
	all.insert( end(all), begin(v2), end(v2) );
	all.insert( end(all), begin(v3), end(v3) );
	all.insert( end(all), begin(v4), end(v4) );
	all.insert( end(all), begin(v5), end(v5) );
}

Meine Vorhaben ist:
Wenn ich bei Mess1 bin wollte ich alle Vektoren in einen einzigen vektor haben, damit ich noch eine andere Filter einsetzen kann.

template< typename T >
vector< vector< T > > foo(vector< T > const & input )
{
    typedef vector< T >::size_type size_type;

    size_type const size = input.size() - 1;
    vector< vector< T > > result( size );
    vector< T > current( size );

    for( size_type i = 0; i < size; result[ i ] = current, current.resize( size - ++i ) )
        for( size_type k = 0; k < size - i; ++k )
            current[ k ] = input[ i + k + 1 ] - input[ k ];

    return result;
}

dann rufe ich diese Methode in main() Fkt:

std::vector< std::vector< int > > result = foo( hilfs_vector );
for( std::vector< std::vector< int > >::size_type i= 0; i < result.size(); ++i ){

        std::cout << "Delta " << i << ": ";
		ausgabe(result[i]);
        std::cout.put( '\n' );
    }

--> Der Anzahl der Vektoren ist gleich der Anzahl von i bzw Delta.
Meine ausgabe() sieht so aus:

void ausgabe(vector<int>&v)
{
	vector<int>::iterator iNext = v.begin();
	vector<int>::iterator iEnd = v.end();
	while(iNext < iEnd)
	{
		cout << " " <<*iNext++ << " ";
	}
	cout << endl;
}

Also du willst das hier?

vector<int> concatenate_vectors( const vector<vector<int>>& v )
{
	unsigned size = 0;
	for( auto it=begin(v); it!=end(v); ++it, size+=it->size() );

	vector<int> concatenate;
	concatenate.reserve( size );
	for( auto it=begin(v); it!=end(v); ++it, concatenate.insert(end(concatenate),begin(*it),end(*it)) );
	return concatenate;
}

int main()
{
	// ...
	vector<int> concatenate = concatenate_vectors( result );
}

for( auto it=begin(v); it!=end(v); size+=it->size(), ++it );