Ich habe bisher:

for (int i=0; i<384; i++)
    CarrayObject.Add(DatenArray[i]);

Es würde doch sicherlich schneller gehen, wenn ich doch gleich komplett das Array kopieren könnte, oder nicht? Doch wie mache ich das?
CArray<unsigned short int> DatenArray; habe ich jetzt. Wie muss ich das ändern?
Bei CArray<unsigned short int*> würde ich doch nur immer wieder dieselbe Adresse von DatenArray speichern oder sehe ich das falsch?
(Irgendwie habe ich das Gefühl, soetwas Grundlegendes sollte ich eigentlich wissen...)

MfG,
Paul.

vector<unsigned short> Daten(384);
copy(Array,Array+384,Daten.begin());

MfG,
Paul.

Wusste nicht dass man beim Vektor direkt die Größe mit angeben kann.

Ja, bei einem Vektor kann man einiges (warte mal noch einen Monat, dann kommt hoffentlich mein Artikel über die STL)

Paul.

Muß es unbedingt ein CArray sein? Wenn es dir nur auf ein "dynamisches Array" ankommt, würde ich eher die STL bemühen (aber das ist meine persönliche Meinung ;)):

vector<unsigned short> Daten(384);
copy(Array,Array+384,Daten.begin());

Muss das eigentlich nicht

copy(Array,Array+384*sizeof(unsigned short),Daten.begin());

heißen?

--- Vergeßt es! ----

#include <vector>

machen und dann halt einfach ne Membervariable in der Klasse anlegen.
Die Anzahl kannst du dann dem Konstrukor in der Initialisierungsliste mit übergeben.
Ach ja die Headerdatei wirst du auch mit in der HEaderdatei deiner Klasse einbinden müssen, weil Template. Aber den namespace würde ich erst in der cpp aushebeln, falls das erwünscht ist

vector<unsigned short> Daten(384);  // Vorschlag von CSToll -> Problem mit Konstante (384)

==

vector<unsigned short> Daten;    // in Header-Datei
Daten.reserve(384);    // in cpp-Datei

ist?

MfG,
Paul.

P.S.: Bin aber auch bald soweit, dass ich es auch einfach testen kann.
P.S.S: Lese gerade nochmal deinen Post: Du meinst also, ich könnte im Konstruktor einfach

Constructor(.......)
, Daten(384)
{
}

schreiben?

Und was meinst du genau mit aushebeln?

P.S.S.S: Ich glaube, ich benötige dringend Koffeinkonsum!

Constructor(.......)
, Daten(384)

Das habe ich gemeint.
Wenn du an den Konstruktor von vector ne Anzahl übergibst, werden so viele Objkete schon im Container angelegt mit einem Aufruf des Standardkonstruktors des jeweiligen Typs(bei dir ja int, also eh egal).

Daten.reserve(384);

Das ist was anderes! Hier wird physischer Speicherplatz reserviert. Also intern legt der in deinem Fall ein Feld an, was min 384 ints aufnehmen kann. Die logische Länge des vectors ändert sich dagegen nicht!!!
Im Gegensatz zu der Konstruktorvariangte, hier werde wirklich 384 logische Elemente angelegt.

Wenn du als das resereve benutzt, kannst du den copy-Befehl so nicht benutzen, sondern musst die Objkete mit push_back an den vector anfügen.

Zum Grundproblem: CArray hat bestimmt garantiert auch so einen reserve-Befehl auch wenn er vieleicht anders heißt. Von daher denke ich nicht, dass CArray jetzt so viel langsamer als vector sein soll^^

Ok, nun habe ich dann Daten(384) stehen, also 384 vector Objekte.
Wie würde ich die einzeln ansprechen? Daten[1], Daten[2]? (nicht, dass ich das unbedingt müsste, nur aus Neugier)
Entweder stehe ich voll auf dem Schlauch, oder ich ralle es noch nicht ganz?!?

Ja, CArray hat einen ähnlichen Befehl, aber darum ging es mir nicht. Es ging mir nur darum, wie ich am schnellsten den Speicher kopiere und da hat mir CSToll so geholfen.

MfG,
Paul.

Danke für die ausführliche Erklärung!
Ja, ich habe std::vector... schon in der Header-Datei. Wieso sollte man das eigentlich nicht da mit namespace machen? Was ist der Grund?

Stell dir mal vor, jemand anders bindet deine h-Datei ein. Dadurch wird in seinen Dateien auch automatisch der namespace ausgehebelt, ohne das er was dagegen machen kann. Wenn er das nun garnicht wollte ... ?

Paul_C. schrieb:

Ok, nun habe ich dann Daten(384) stehen, also 384 vector Objekte.
Wie würde ich die einzeln ansprechen? Daten[1], Daten[2]? (nicht, dass ich das unbedingt müsste, nur aus Neugier)
Entweder stehe ich voll auf dem Schlauch, oder ich ralle es noch nicht ganz?!?

Jo genau wie bei CArray. Mit dem []-Operator greifst du auf die Elemente zu, natürlich beginnend bei 0 . Achtung: bei [] findet kein interner Test statt, ob du über das Feld hinausgeshcossen bist. Bei vector::at dagegen werden erst die Feldindizes geprüft und bei einem Fehler ne out_of_range geschmissen.

Paul_C. schrieb:

Ja, CArray hat einen ähnlichen Befehl, aber darum ging es mir nicht. Es ging mir nur darum, wie ich am schnellsten den Speicher kopiere und da hat mir CSToll so geholfen.

Besorg dir nen Iterator für CArray, dabb kannst hier auch das copy anwenden

MfG,
Paul.

;)[/quote]

Jo genau wie bei CArray. Mit dem []-Operator greifst du auf die Elemente zu, natürlich beginnend bei 0 . Achtung: bei [] findet kein interner Test statt, ob du über das Feld hinausgeshcossen bist.

Ein wenig Programmierung kannst du mir schon zutrauen.

Danke, nochmal für die Erklärungen. Auf die Idee, dass jemand meine Headerdatei bin ich nicht gekommen, da es nicht dafür gedacht ist. Ist aber einleuchtend.

MfG,
Paul.

Ja, CArray hat einen ähnlichen Befehl, aber darum ging es mir nicht. Es ging mir nur darum, wie ich am schnellsten den Speicher kopiere und da hat mir CSToll so geholfen.

MfG,
Paul.

Ähm das Copy tut aber auch nur Elementweise kopieren!!!
Durch CStolls Vorgehen hast du doppelten Aufwand. Erst werden 384 Elemente mit 0 initialisiert, nur dass sie danach gleich wieder überschrieben werden.
Die Variante mit reserve und push_back ist also schneller, auch wenn es sich bei der geringen Anzahl(und dann auch nur ints und keine großen Objekte) nicht wirklich bemerkbar machen dürfte.

Insert und Assign kommen auch noch in Frage, da sparst du dir dann das reserve, das macht dann automatisch der Container.

std::vector<unsigned short>Daten;
Daten.reserve(384);
...
Daten.pushback(irgendwas);

schreiben?!

copy könnte wie folgt implementiert sein

while (first != last) *result++ = *first++;

Die Variablen sind die Iteratoren. Hab ich ausm STL-Buch grad abgeschrieben.
Du siehst, das ist elementweises kopieren udn es wird davon ausgegangen, dass der Ergebniscontainer entsprechend groß ist, also muss dieser schon genug Element haben, welche dann überschrieben werden.

Oder du nimmst das insert

vec.insert(vec.end(),DatenArray,DatenArray + 384);

Das wäre wohl das beste. Füge alle Elemente DatenArray bis DatenArray + 384 vor dem Ende des vectors ein.
Wohl gemerkt hier wird nichts überschrieben! Es gibt nur pro Element einen Aufruf des Copy-Kontruktors und so sparst du dir den Standardkonstruktor, der im copy nötig ist, weil du das Feld dort ja per Hand erstmal auf die entsprechende Länge setzen musst.
Also wenn im Vector Elemente sind die du nicht mehr brauchst, kannst du die vorher mit clear() rausschmeißen.