Na das ist natürlich doof...

Bischen Koht vielleicht?

Mfg.
way'n interessierts

vector<int> priory;
...
priory.push_back(2);
priory.push_back(4);
...
int A[anzahl];
A=priory.toArray();

Ich hab den Vector erstellt, da ich nicht genau weiß, wie viele Elemente eingefügt werden sollen, da die mit ner Schleife hinzugefügt werden.
Um aber jetzt wieterarbeiten zu können, brauch ich ein Array, da ich die Elemente im vector nicht so sortieren kann, wie ich es will (also nicht jedes Element, sondern nur jedes 2.).

Du kannst ueber nen Vector auch Array Like iterieren ....

vector<int> priory; 

/// vector befuellen ... 

int * mArrayView = &priory[0];
for(int i = 0; i < priory.size(); ++i) 
{
    int Element = mArrayView[i];
}

Wenn du wirklich ne copie auf Array ebene brauchst, (die frage bleibt immer noch warum ? nen vector als kopie tuts definitiv auch) geht das doch auch ...

int * newArray = new int [priory.size()];
memcpy(newArray,&priory[0],priory.size() * sizeof(int)); 
/// newArray ned vergessen zu loeschen ....

Du hasst eher nen problem den unterschied zwischen statischen und dynamischen Array zu sehen.
Punkt 1: Richtig ist, wenn die groesse ned weisst, machst nen Array entweder so gross, das nie an die grenzen kommst, oder du machst das Array dynamisch. Die groesse wissen musst zur compilezeit, also bevor das Array erstellst.

Punkt 2: Aus nem dynamischen Array nen statisches zu machen ? wie, die groesse des dynamischen arrays kennst ja per definition ned zur compilezeit. wie solltest es dann nach dem befuellen kennen ? Also siehe punkt 1 !
vector == dynamisches Array ! ein 100%er ersatz fuer c++. Man braucht unter c++ keine rohen dynamischen arrays mehr, es sei denn man hat ne umgebung wo keine stl oder andere bibs gehen ...

Ciao ...

oder

int a[SIZE];
std::copy(priory.begin(), priory.end(), a);

Ciao ...

z.B. das 1. mit dem 3. oder das 2. mit dem 4. Element.

der erste Naive Ansatz !

int buffer; 
buffer = priory[0];
priory[0] = priory[2];
priory[2] = buffer;

buffer = priory[1];
priory[1] = priory[3];
priory[3] = buffer;

Besser, swap algo nehmen:

stl::swap(priory[0],priory[2]);
stl::swap(priory[1],priory[3]);

Ciao ...

Und Shade hat recht, wenn die elemente keine pods sondern klassen mit structuren sind, geht das memcpy ned mehr (construktor / destructor thematik).
Besser den copy allgo nehmen !

richtig toll wäre natürlich wenn std::copy auch immer und überall für memcpy fälle spezialisiert wäre aber das ist leider nicht der fall

PS: für swap am besten die funktion swap() verwenden

PPS: nevermind...