C++Talk.NET Forum Index C++Talk.NET
C++ language newsgroups
 
Archives   FAQFAQ   SearchSearch   MemberlistMemberlist   UsergroupsUsergroups   RegisterRegister 
 ProfileProfile   Log in to check your private messagesLog in to check your private messages   Log inLog in 

Speicherbelegung
Goto page 1, 2  Next
 
Post new topic   Reply to topic    C++Talk.NET Forum Index -> C++ (German)
View previous topic :: View next topic  
Author Message
Michael Schuster
Guest





PostPosted: Sun Apr 18, 2004 6:47 pm    Post subject: Speicherbelegung Reply with quote



Hallo,
ich möchte den Speicherverbrauch meines c++ Programmes (nutze nur die
Standard-c++ lib) genauer profilen.Fehler tritt keiner auf, aber ich
möcht' wissen, welche Variablen den meisten Platz allokieren. Gibts da
ne Möglichkeit, tool, Trick etc. (unter Linux)?

Bin für jede Hilfe dankbar.

Michael

--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de
Back to top
Falk Tannhäuser
Guest





PostPosted: Mon Apr 19, 2004 8:57 am    Post subject: Re: Speicherbelegung Reply with quote



Michael Schuster wrote:
Quote:
ich möchte den Speicherverbrauch meines c++ Programmes (nutze nur die
Standard-c++ lib) genauer profilen.Fehler tritt keiner auf, aber ich
möcht' wissen, welche Variablen den meisten Platz allokieren. Gibts da
ne Möglichkeit, tool, Trick etc. (unter Linux)?
Wenn es um die Speicherbelegung von Programmkode und statischen Variablen

geht, sehe ich nur plattformspezifische Lösungen (daher hier OT):
man nm
man objdump

Um den Speicherverbrauch von dynamischen Variablen (Erzeugung mit new)
zu ermitteln, könnte man z.B. die Operatoren
void* operator new(std::size_t) throw (std::bad_alloc);
void* operator new[](std::size_t) throw (std::bad_alloc);
void operator delete(void*) throw();
void operator delete[](void*) throw();
void* operator new(std::size_t, const std::nothrow_t&) throw();
void* operator new[](std::size_t, const std::nothrow_t&) throw();
void operator delete(void*, const std::nothrow_t&) throw();
void operator delete[](void*, const std::nothrow_t&) throw();
selbst definieren, um die Anzahl der Aufrufe und die angeforderten
Speichergrößen zu protokollieren.

MfG
Falk

--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de

Back to top
Andreas Huennebeck
Guest





PostPosted: Mon Apr 19, 2004 12:50 pm    Post subject: Re: Speicherbelegung Reply with quote



Michael Schuster wrote:

Quote:
ich möchte den Speicherverbrauch meines c++ Programmes (nutze nur die
Standard-c++ lib) genauer profilen.Fehler tritt keiner auf, aber ich
möcht' wissen, welche Variablen den meisten Platz allokieren. Gibts da
ne Möglichkeit, tool, Trick etc. (unter Linux)?

valgrind koennte helfen.

Tschau
Andreas
--
Andreas Hünnebeck | email: [email]ah (AT) despammed (DOT) com[/email]
----- privat ---- | www : http://www.huennebeck-online.de
Fax/Anrufbeantworter: 0721/151-284301 o. 0180/50525-5232659 (24 Pfg/Min)
SMS: D1=72617 D2=0172/7366-042 E-Plus=0177/7934-396 Viag=0179/2029-894
GPG-Key: http://www.huennebeck-online.de/public_keys/andreas.asc

--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de

Back to top
Michael Schuster
Guest





PostPosted: Mon Apr 26, 2004 1:57 pm    Post subject: Re: Speicherbelegung - std::vector Reply with quote

Hallo,
ich bin dem Speicherhunger meines Programmes etwas auf die Schliche
gekommen, denk ich. Allerdings hat das bei mir (gcc 3.3.3) einige
Fragen aufgeworfen:
Ich hab unten stehendes kleines Programm geschrieben, dessen
Speicherbedarf ich mit top (linux) genauer beoachtet habe.
Mein Problem scheint zu sein, dass ein std::vector<int>, der ohne
explizite Größenangaben erzeugt wurde (s.u.) , erstmal einiges an
Bytes reserviert. Leider weiss ich die Größe erst zur LAufzeit. Für
die meisten Objekte ist die Größe 0, für einige 2500 und größer. Wenn
ich in meinem Demoprog unten eine Größenangabe beim Initialisieren des
std:vector mache, dann ergibt sich folgendes:
Initalisierungsgröße Speicherbedarf lauf top
0 0
ab 1 68

Wenn push_back angewandt wird, gibt es nur manchmal
"Allokationssprünge" im Speicher: Wahrscheinlich (?) allokiert der
vector immen nen ganzen Block, und erst wenn der voll ist, gleich nen
nächst größeren. Nun die Frage, kann man den std::irgendwie
konfigurieren, dass das Allokationsverhalten anders wird, oder gibts
ne Alternative? Ich habs schon mal mit std::list probiert, aber da ist
bei größeren listen (durch die notwendigen Zeiger?) der Speicherbearf
noch viel größer.

#include <iostream>
#include <vector>
using namespace std;
#define WAIT 1000000000
#define INIT 20

int main()
{
volatile int i=0;
cout<<"nStart";
cout.flush();
i=0;
while (i // ursprünglich vector vector<int> v(INIT);
cout<<"nErzeuge v";
cout.flush();
if (INIT!=0)
{
v[INIT-1]=12;
cout< cout.flush();
}

i=0;
while (i
i=0;
while (i<50)
{

cout<<"nErhöhe v: "< v.push_back((int)i);
volatile int y=0;
while (y
i++;
}



}

--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de
Back to top
Torsten Robitzki
Guest





PostPosted: Mon Apr 26, 2004 5:30 pm    Post subject: Re: Speicherbelegung - std::vector Reply with quote

Michael Schuster wrote:
Quote:
Hallo,
ich bin dem Speicherhunger meines Programmes etwas auf die Schliche
gekommen, denk ich. Allerdings hat das bei mir (gcc 3.3.3) einige
Fragen aufgeworfen:
Ich hab unten stehendes kleines Programm geschrieben, dessen
Speicherbedarf ich mit top (linux) genauer beoachtet habe.
Mein Problem scheint zu sein, dass ein std::vector<int>, der ohne
explizite Größenangaben erzeugt wurde (s.u.) , erstmal einiges an
Bytes reserviert.

Würde mich wundern, wenn std::vector<int> v; irgend welchen Speicher
alloziiert.

Quote:
Leider weiss ich die Größe erst zur LAufzeit. Für
die meisten Objekte ist die Größe 0, für einige 2500 und größer. Wenn
ich in meinem Demoprog unten eine Größenangabe beim Initialisieren des
std:vector mache, dann ergibt sich folgendes:
Initalisierungsgröße Speicherbedarf lauf top
0 0
ab 1 68

Was auch immer das für Einheiten sind.
Quote:

Wenn push_back angewandt wird, gibt es nur manchmal
"Allokationssprünge" im Speicher: Wahrscheinlich (?) allokiert der
vector immen nen ganzen Block, und erst wenn der voll ist, gleich nen
nächst größeren.

Machen gute vectoren so, das es viel effektiver ist.

Quote:
Nun die Frage, kann man den std::irgendwie
konfigurieren, dass das Allokationsverhalten anders wird, oder gibts
ne Alternative?

Alternative, wäre einen vector selbst zu schreiben. Ich sehe Dein
Problem allerdings noch nicht so ganz. Die meisten vectoren werden wohl
den Speicher um den Faktor 1,5 bis 2 vergrößern, wenn nicht mehr genug
Speicher da ist, wenn Dir das zuviel ist, wirst Du das mit entsprechend
verschlechteter Performanze bezahlen müssen.

Quote:
Ich habs schon mal mit std::list probiert, aber da ist
bei größeren listen (durch die notwendigen Zeiger?) der Speicherbearf
noch viel größer.

#include <iostream
#include using namespace std;
#define WAIT 1000000000
#define INIT 20

int main()
{
volatile int i=0;

volatile?
Quote:
cout<<"nStart";
cout.flush();
i=0;
while (i Arg, das würde ich nicht im Sommer machen, wenn es sowieso schon immer

so warm im Büro ist.

Quote:
// ursprünglich vector vector<int> v(INIT);

Wenn Du nicht weist, wieviel Elemente in den Vector sollen, warum füllst
Du ihn den dann mit 20 Elementen?

Quote:
cout<<"nErzeuge v";
cout.flush();
if (INIT!=0)
{
v[INIT-1]=12;
cout< cout.flush();
}

Das erzeugt garnichts. Du hast Deinen vector bereits mit 20 Elementen
gefüllt, und diese mit int(), sprich 0 initialisiert.

Quote:
i=0;
while (i Schwitz....


Quote:
i=0;
while (i<50)
{

cout<<"nErhöhe v: "< v.push_back((int)i);
volatile int y=0;
while (y
i++;
}



}


so und nun hast Du 70 integer in Deinem Vector. Da Du std::cout nie
flushst könnte es sogar sein, das der mehr Speicher verbraucht als die
70 integer.

Kann es sein, das Du eine Reihe von vectoren hast, die eigentlich keine
Elemente enthalten Du diese aber immer mit irgend einer Anzahl Elemente
initialisierst?

mfg Torsten

--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de

Back to top
Stefan Reuther
Guest





PostPosted: Mon Apr 26, 2004 6:05 pm    Post subject: Re: Speicherbelegung - std::vector Reply with quote

Michael Schuster wrote:
Quote:
Mein Problem scheint zu sein, dass ein std::vector<int>, der ohne
explizite Größenangaben erzeugt wurde (s.u.) , erstmal einiges an
Bytes reserviert.

Sicher. Schließlich legt man einen Vektor üblicherweise nicht zum Spaß
an, sondern um Dinge reinzufüllen.

Quote:
Leider weiss ich die Größe erst zur LAufzeit. Für
die meisten Objekte ist die Größe 0, für einige 2500 und größer. Wenn
ich in meinem Demoprog unten eine Größenangabe beim Initialisieren des
std:vector mache, dann ergibt sich folgendes:
Initalisierungsgröße Speicherbedarf lauf top
0 0
ab 1 68

Kilobyte? Gigabyte? Wurstbrötchen?

Egal, was du da gemessen hast: es kommt immer noch Allokations-Overhead
vom Betriebssystem und von std::allocator dazu.

Quote:
Wenn push_back angewandt wird, gibt es nur manchmal
"Allokationssprünge" im Speicher: Wahrscheinlich (?) allokiert der
vector immen nen ganzen Block, und erst wenn der voll ist, gleich nen
nächst größeren.

Genau das tut er. Wenn du 'push_back' aufrufst, geht der Vektor erstmal
davon aus, das du wohl noch ein paar weitere 'push_back' aufrufen wirst,
und reserviert daher reichlich Speicher. Jede Allokationsänderung ist
mit Umkopieren verbunden. Wenn 'push_back' jedes Mal nur ein Element
anhängt, sind bei N push_back-Operationen O(N^2) Kopieroperationen
nötig. Wenn der Speicherbedarf bei jedem Überlauf verdoppelt wird, sind
es nur O(N) Kopieroperationen (und wesentlich weniger Überläufe =
Allokationsänderungen).

Quote:
Nun die Frage, kann man den std::irgendwie
konfigurieren, dass das Allokationsverhalten anders wird, oder gibts
ne Alternative?

Du kannst selbst mit 'v.reserve(größe)' die Anzahl allokierter Elemente
bestimmen. Damit hast du die volle Kontrolle. Zum Beispiel kannst du
nach dem Füllen des Vektors mit 'v.reserve(v.size())' die zusätzlich
allokierten Elemente wegwerfen.

Quote:
Ich habs schon mal mit std::list probiert, aber da ist
bei größeren listen (durch die notwendigen Zeiger?) der Speicherbearf
noch viel größer.

Vielleicht ist std::deque noch eine Alternative.

Wenn "die meisten" Vektoren eh leer sind, bietet es sich vielleicht an,
eine weitere Indirektionsebene einzuführen. Statt eines 'std::vector<T>'
eben einen Zeiger 'std::vector<T>*', wo der Vektor erst dann tatsächlich
angelegt wird, wenn du auch Elemente hast. Das lohnt sich aber nur, wenn
du wirklich *echt* *viele* leere Vektoren hast.


Stefan

--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de

Back to top
Michael Schuster
Guest





PostPosted: Mon Apr 26, 2004 6:46 pm    Post subject: Re: Speicherbelegung - std::vector Reply with quote

Torsten Robitzki wrote:

Quote:
Michael Schuster wrote:

Würde mich wundern, wenn std::vector<int> v; irgend welchen Speicher
alloziiert.
Du hast wahrscheinlich recht:Es scheint ein konstanter Offset (egal ob

1 oder 1Mio vectoren) zu sein.

Quote:
Wenn Du nicht weist, wieviel Elemente in den Vector sollen, warum füllst
Du ihn den dann mit 20 Elementen?
Das konnt ich mit dem INIT ändern, um mal zu sehen, was das für nen

Einfluss das auf den Speicherbedarf hat.

Quote:
Das erzeugt garnichts. Du hast Deinen vector bereits mit 20 Elementen
gefüllt, und diese mit int(), sprich 0 initialisiert.
Hat ich den Eindruck, das macht was aus.War wohl am cout gelegen

(s.u.)

Quote:
so und nun hast Du 70 integer in Deinem Vector. Da Du std::cout nie
flushst könnte es sogar sein, das der mehr Speicher verbraucht als die
70 integer.
Da haste leider recht. Ich hab mal eben die cout's kommentiert...


Quote:
Kann es sein, das Du eine Reihe von vectoren hast, die eigentlich keine
Elemente enthalten Du diese aber immer mit irgend einer Anzahl Elemente
initialisierst?
nee, eigentlich nicht. Aber ich schau nochmal.

Ich hab so etwa 500.000 vectoren (eigentlich Objekte mit
verschiedensten weiteren Variablen), sizeof gibt mir eine Größe, die
nicht zum Speicherbedarf passt, und da bin ich auf der Suche nach dem
toten Miststück, was den Ärger macht...Dummerweisse kenn ich die Größe
der vectoren erst zur Laufzeit, die meisten sind wie gesagt eh 0 groß,
nur eben manche nicht. Gibts nicht ne Funktion, mit der man zumindest
nachdem man weiss, dass der vector nicht mehr weiter wächst (was bei
mir der Fall wäre), den überflüssigen Speicher wieder hergibt?

Michael

--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de

Back to top
Tibor Pausz
Guest





PostPosted: Mon Apr 26, 2004 8:38 pm    Post subject: Re: Speicherbelegung - std::vector Reply with quote

Michael Schuster <michi (AT) flyflaps (DOT) de> wrote:

Quote:
Nun die Frage, kann man den std::irgendwie
konfigurieren, dass das Allokationsverhalten anders wird, oder gibts
ne Alternative?

std::vector<T> ist ein typedef für
std::vector<T, Allocator = allocator

Du kannst also einen eigenen Allocator implementieren und Dein Problem
vermutlich so lösen.

Alternativ kannst Du mit vector.reserve (size_t) Vorgaben machen,
wieviel Speicher mindest angelegt werden muß. Vielleicht reicht Dir das
auch?

--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de

Back to top
Rolf Magnus
Guest





PostPosted: Mon Apr 26, 2004 9:15 pm    Post subject: Re: Speicherbelegung - std::vector Reply with quote

Michael Schuster wrote:

Quote:
Hallo,
ich bin dem Speicherhunger meines Programmes etwas auf die Schliche
gekommen, denk ich. Allerdings hat das bei mir (gcc 3.3.3) einige
Fragen aufgeworfen:
Ich hab unten stehendes kleines Programm geschrieben, dessen
Speicherbedarf ich mit top (linux) genauer beoachtet habe.
Mein Problem scheint zu sein, dass ein std::vector<int>, der ohne
explizite Größenangaben erzeugt wurde (s.u.) , erstmal einiges an
Bytes reserviert.

Ich würde eher erwarten, daß bis zum ersten push_back kein Speicher
allokiert wird, aber das kann die Implementation machen, wie sie will.

Quote:
Leider weiss ich die Größe erst zur LAufzeit. Für
die meisten Objekte ist die Größe 0, für einige 2500 und größer. Wenn
ich in meinem Demoprog unten eine Größenangabe beim Initialisieren des
std:vector mache, dann ergibt sich folgendes:
Initalisierungsgröße Speicherbedarf lauf top
0 0
ab 1 68

Wenn push_back angewandt wird, gibt es nur manchmal
"Allokationssprünge" im Speicher: Wahrscheinlich (?) allokiert der
vector immen nen ganzen Block, und erst wenn der voll ist, gleich nen
nächst größeren.

Ja, da jedes neu-Allokieren viel Zeit und kurzzeitig auch viel Speicher
braucht und außerdem die Speicherfragmentierung erhöht. Deshalb sollte
das so selten wie möglich passieren. Das spart Ressourcen.

Quote:
Nun die Frage, kann man den std::irgendwie konfigurieren, dass das
Allokationsverhalten anders wird, oder gibts ne Alternative?

Ich wüßte keine.

--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de

Back to top
Albrecht Fritzsche
Guest





PostPosted: Tue Apr 27, 2004 6:42 am    Post subject: Re: Speicherbelegung - std::vector Reply with quote

Stefan Reuther wrote:
Quote:
Nun die Frage, kann man den std::irgendwie
konfigurieren, dass das Allokationsverhalten anders wird, oder gibts
ne Alternative?


Du kannst selbst mit 'v.reserve(größe)' die Anzahl allokierter Elemente
bestimmen. Damit hast du die volle Kontrolle. Zum Beispiel kannst du
nach dem Füllen des Vektors mit 'v.reserve(v.size())' die zusätzlich
allokierten Elemente wegwerfen.

Was heisst "wegwerfen"? vector::reserve() zumindest verringert niemals
die Kapazitaet, also die Groesse des allokierten Speichers, es
vergroessert sie ggf. Du hast auch bei vector::reserve(size) nur die
Garantie, dass da nun Platz fuer mindestens size Elemente ist.

Also, "voellige Kontrolle" wuerde ichdies nicht nennen, aber ausreichend
ist diese natuerlich.

Ali

--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de

Back to top
Albrecht Fritzsche
Guest





PostPosted: Tue Apr 27, 2004 6:46 am    Post subject: Re: Speicherbelegung - std::vector Reply with quote

Torsten Robitzki wrote:
Quote:
Mein Problem scheint zu sein, dass ein std::vector<int>, der ohne
explizite Größenangaben erzeugt wurde (s.u.) , erstmal einiges an
Bytes reserviert.


Würde mich wundern, wenn std::vector<int> v; irgend welchen Speicher
alloziiert.

Na ja, neben dem Array(Ptr) muss ja noch die Groesse des allokierten
SPeichers und die Anzahl der belegten Elemente irgendwo stehen. ALso,
drei Membervariablen darf ein vector schon belegen ;-)

Ali

--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de

Back to top
Albrecht Fritzsche
Guest





PostPosted: Tue Apr 27, 2004 6:54 am    Post subject: Re: Speicherbelegung - std::vector Reply with quote

Michael Schuster wrote:
Quote:
Wenn push_back angewandt wird, gibt es nur manchmal
"Allokationssprünge" im Speicher: Wahrscheinlich (?) allokiert der
vector immen nen ganzen Block, und erst wenn der voll ist, gleich nen

Nicht nur das - der gesamte bisherige Speicher wird in den (1.5-2mal so
grossen) neu angelegten Speicher kopiert und evtl die Destruktoren auf
dem alten Speicher aufgerufen. Das kann natuerlich dauern...

Quote:
nächst größeren. Nun die Frage, kann man den std::irgendwie
konfigurieren, dass das Allokationsverhalten anders wird

Einen eigenen Allokator verwenden oder eben, wie schon vorgeschlagen
wurde, mittels reserve() schon eine ungefaehre Obergrenze angeben.
Dann sind zb die push_back's bis an diese Grenze in (jeweils) konstanter
Zeit mgl.

Quote:
Ich habs schon mal mit std::list probiert, aber da ist
bei größeren listen (durch die notwendigen Zeiger?) der Speicherbearf
noch viel größer.

Ja, ein std::vector enthaelt kaum Overhead, genauer gesagt einen
konstanten Overhead, std::list einen Overhead, der von der Zahl der
Elemente abhaengt. Also, besser als vector bekommt man es auch selbst
kaum hin, zudem sind die zB 24 Byte nicht gerade der Rede wert.

Ali

--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de

Back to top
Tibor Pausz
Guest





PostPosted: Tue Apr 27, 2004 7:02 am    Post subject: Re: Speicherbelegung - std::vector Reply with quote

Stefan Reuther <stefan.news (AT) arcor (DOT) de> wrote:

Quote:
Du kannst selbst mit 'v.reserve(größe)' die Anzahl allokierter Elemente
bestimmen. Damit hast du die volle Kontrolle. Zum Beispiel kannst du
nach dem Füllen des Vektors mit 'v.reserve(v.size())' die zusätzlich
allokierten Elemente wegwerfen.

Das wäre mir neu. Alle Container der Standard Library sie so definiert,
daß sie bei reserve(size) mindestens für size Elemente Platz
reservieren. Aber man kann keine zusätzlichen Elemente damit
"wegwerfen", das ist ausgeschlossen.

--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de

Back to top
Michael Schuster
Guest





PostPosted: Tue Apr 27, 2004 7:29 am    Post subject: Re: Speicherbelegung - std::vector Reply with quote

Stefan Reuther <stefan.news (AT) arcor (DOT) de> wrote


Quote:
Du kannst selbst mit 'v.reserve(größe)' die Anzahl allokierter Elemente
bestimmen. Damit hast du die volle Kontrolle. Zum Beispiel kannst du
nach dem Füllen des Vektors mit 'v.reserve(v.size())' die zusätzlich
allokierten Elemente wegwerfen.
Hört sich so an wie ich es bräuchte; Allerdings meint ja Albert

Fritzsche (im Thread) dass reserve bereits reservierten Speicher nicht
wieder frei gibt.
Was passiert eigentlich, wenn ich nur N Elemente reserviere und dann
doch ein N+1 -tes dazu pushen würde?

Quote:
Wenn "die meisten" Vektoren eh leer sind, bietet es sich vielleicht an,
eine weitere Indirektionsebene einzuführen. Statt eines 'std::vector<T>'
eben einen Zeiger 'std::vector<T>*', wo der Vektor erst dann tatsächlich
angelegt wird, wenn du auch Elemente hast. Das lohnt sich aber nur, wenn
ja, daran hab ich schon gedacht, werd das wohl auch implementieren,

aber vorher wollte ich schon mal wissen, was den std::vector im
Innersten zusammenhält.
Vielen Dank schon mal für die Antworten hier.

Michael

--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de

Back to top
Rolf Magnus
Guest





PostPosted: Tue Apr 27, 2004 11:27 am    Post subject: Re: Speicherbelegung - std::vector Reply with quote

Michael Schuster wrote:

Quote:
Stefan Reuther <stefan.news (AT) arcor (DOT) de> wrote in message
news:<c6jq26.vg.1 (AT) stefan (DOT) msgid.phost.de>...

Du kannst selbst mit 'v.reserve(größe)' die Anzahl allokierter
Elemente bestimmen. Damit hast du die volle Kontrolle. Zum Beispiel
kannst du nach dem Füllen des Vektors mit 'v.reserve(v.size())' die
zusätzlich allokierten Elemente wegwerfen.
Hört sich so an wie ich es bräuchte; Allerdings meint ja Albert
Fritzsche (im Thread) dass reserve bereits reservierten Speicher nicht
wieder frei gibt.

Das kann ich bestätigen.

Quote:
Was passiert eigentlich, wenn ich nur N Elemente reserviere und dann
doch ein N+1 -tes dazu pushen würde?

Soweit ich weiß, ist der vector nicht verpflichtet, Speicher für genau N
Elemente anzulegen, sondern nur für mindestens N Elemente. Je nach dem,
was er tut, passiert also entweder nichts besonderes beim pushen von
N+1 Elementen oder er muß re-allokieren.

Etwas, das du noch ausprobieren kannst, ist das Kopieren des Vektors in
einen neuen mit nachfolgendem Swappen der Art:

std::vector<irgendwas> tmp = v;
v.swap(tmp);

Das ist auch nicht aufwendiger als das, was der vector machen müsste,
wenn er die Freigabe des Speichers selbst regeln würde.

--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de

Back to top
Display posts from previous:   
Post new topic   Reply to topic    C++Talk.NET Forum Index -> C++ (German) All times are GMT
Goto page 1, 2  Next
Page 1 of 2

 
Jump to:  
You cannot post new topics in this forum
You cannot reply to topics in this forum
You cannot edit your posts in this forum
You cannot delete your posts in this forum
You cannot vote in polls in this forum


Powered by phpBB © 2001, 2006 phpBB Group
SEO toolkit © 2004-2006 webmedic.