Sizeof Vector zu klein.



  • Hallo,
    ich möchte mir die "sizeof" eines Vektors ausgeben lassen. Der Vektor enthält 5 Elemente vom Typ int. Als Größe des Vektors wird jedoch 16 und nicht 20 ausgegeben. Wenn ich mehr Elemente in den Vektor packe bleibt die ausgegebene Größe 16.
    Warum ist das so?
    Hier mein Code:

    #include <iostream>
    #include <string>
    #include <map>
    #include <algorithm>
    #include <vector>
    #include <set>
    
    using namespace std;
    
    vector<string> getNames(map<string, int> phonebook);
    vector<int> getNumbers(map<string, int> phonebook);
    int main()
    {
    	map<string, int> phonebook = {
    		{ "Alfred", 1234 },
    		{"Christoph", 5678},
    		{"Daniel", 2468},
    		{"Isabell", 3579},
    		{"Manuel", 9876},
    		{"Wilfried", 4321}};
    
    
    	bool print1 = false;
    	if (print1)
    	{
    		cout << "ranged for-loop: \n";
    		for (auto& kv : phonebook)
    		{
    			cout << kv.first << ": " << kv.second << "\n";
    		}
    
    		cout << "for_each: \n";
    
    		auto PrintContents = [](auto kv) {
    			cout << kv.first << ": " << kv.second << "\n"; };
    		for_each(phonebook.begin(), phonebook.end(), PrintContents);
    	}
    
    	bool print2 = true;
    	if (print2)
    	{
    		vector<string> names = getNames(phonebook);
    		vector<int> numbers = getNumbers(phonebook);
    		set<int> numberSet(numbers.begin(), numbers.end());
    		int size = sizeof numbers;
    		cout << sizeof numbers << "\n";
    		for (auto val : numbers)
    		{
    			cout << val << " size: " << sizeof val << "\n";
    		}
    	}
    }
    
    vector<string> getNames(map<string, int> phonebook)
    {
    	vector<string> names;
    	for (const auto kv : phonebook)
    	{
    		names.push_back(kv.first);
    	}
    	return names;
    }
    
    vector<int> getNumbers(map<string, int> phonebook)
    {
    	vector<int> numbers;
    	for (const auto kv : phonebook)
    	{
    		numbers.push_back(kv.second);
    	}
    	return numbers;
    }
    


  • @H-P-Wurst sagte in Sizeof Vector zu klein.:

    sizeof

    ich denke, sizeof berechnet in dem Fall nur den Speicherverbrauch des Vektors selber, ohne den Speicherverbrauch des adressierten Speichers, den die Elemente verbrauchen.
    std::vector<T> wird vermutlich aus 1 Pointer ( 8 Byte ) und Angaben zu Size und Reservation bestehen ( 2 x 4 Byte? ).
    der aus drei Pointern ( wären dann 24 Byte ). Je nach Implementation des Compilerherstellers.

    Wenn du den Gesamtspeicherkonsum berechnen willst, sollte das vermutlich eher in diese Richtung gehen:

    std::vector<T> myvector;
    int memusage = sizeof ( myvector ) + myvector.size() * sizeof( T );
    

    Falls du mit "reserve" arbeitest, solltest du die "capacity()" mit berücksichtigen.

    Aber ohne Gewähr. Nur meine erste Vermutung.



  • @It0101 sagte in Sizeof Vector zu klein.:

    std::vector<T> wird vermutlich aus 1 Pointer ( 8 Byte ) und Angaben zu Size und Reservation bestehen ( 2 x 4 Byte? ).

    Typisch ist 3x Pointer-Grösse.
    Kann sein Begin-Pointer + Used/Allocated size_t.
    Kann sein Begin-Pointer + End-Pointer + Allocation_End Pointer.
    Oder irgendwas dazwischen.



  • @It0101 sagte in Sizeof Vector zu klein.:

    Falls du mit "reserve" arbeitest, solltest du die "capacity()" mit berücksichtigen.

    Nicht nur dann, sondern immer - auch push_back und andere können die Kapazität größer machen als man braucht.

    Die Größe ist auto memusage = sizeof(myvector) + myvector.capacity() * sizeof(T);

    Beispiel:

    vector<int> v;
    for (int i = 0; i < 100; ++i) { cout << i << " Elemente, size = " << sizeof(v) + v.capacity() * sizeof(int) << '\n'; v.push_back(0); }
    0 Elemente, size = 24
    1 Elemente, size = 28
    2 Elemente, size = 32
    3 Elemente, size = 40
    4 Elemente, size = 40
    5 Elemente, size = 56
    6 Elemente, size = 56
    7 Elemente, size = 56
    8 Elemente, size = 56
    9 Elemente, size = 88
    10 Elemente, size = 88
    11 Elemente, size = 88
    12 Elemente, size = 88
    13 Elemente, size = 88
    14 Elemente, size = 88
    15 Elemente, size = 88
    16 Elemente, size = 88
    17 Elemente, size = 152
    18 Elemente, size = 152
    ...
    


  • This post is deleted!


  • @wob sagte in Sizeof Vector zu klein.:

    Die Größe ist auto memusage = sizeof(myvector) + myvector.capacity() * sizeof(T);

    Naja ... kommt wohl drauf an, was man eigentlich unter Größe eines vector verstehen möchte ... wenn man es schon so genau nehmen will, was ist dann, wenn T in diesem Beispiel auch noch einen Pointer auf T1 enthält?



  • Ich finde das komisch das als "Grösse des Vektors" zu bezeichnen. Die Grösse eines std::vector<T> ist für mich entweder sizeof(std::vector<T>) oder std::vector<T>::size() - je nach Kontext.

    Das was hier diskutiert wird ist eher der "Gesamtspeicherverbrauch" oder so (memory footprint halt, k.A. ob's dafür eine gute deutsche Übersetzung gibt). Wobei den genau auszurechnen alles andere als trivial ist. z.B. kommt ja auch noch Overhead des Allokators dazu. Allerdings muss man den auch kaum jemals genau ausrechnen.



  • @hustbaer sagte in Sizeof Vector zu klein.:

    Das was hier diskutiert wird ist eher der "Gesamtspeicherverbrauch" oder so (memory footprint halt, k.A. ob's dafür eine gute deutsche Übersetzung gibt). Wobei den genau auszurechnen alles andere als trivial ist. z.B. kommt ja auch noch Overhead des Allokators dazu. Allerdings muss man den auch kaum jemals genau ausrechnen.

    Meistens ist das so, wenn man sich aber die Projekte für Microcontroller anschaut, so könnte das auf solchen Plattformen durchaus von Interesse sein.



  • @hustbaer sagte in Sizeof Vector zu klein.:

    Ich finde das komisch das als "Grösse des Vektors" zu bezeichnen. Die Grösse eines std::vector<T> ist für mich entweder sizeof(std::vector<T>) oder std::vector<T>::size() - je nach Kontext.

    Das was hier diskutiert wird ist eher der "Gesamtspeicherverbrauch" oder so (memory footprint halt, k.A. ob's dafür eine gute deutsche Übersetzung gibt). Wobei den genau auszurechnen alles andere als trivial ist. z.B. kommt ja auch noch Overhead des Allokators dazu. Allerdings muss man den auch kaum jemals genau ausrechnen.

    Habe den "memory-footprint" auch schon mal in einem projekt ermittelt. Ist aber ne Menge Aufwand. Damit habe ich Speicheroptimierungsmaßnahmen abgetestet, um zu schauen ob es auch gefruchtet hat.



  • Danke, hilft schon.



  • @It0101 sagte in Sizeof Vector zu klein.:

    Damit habe ich Speicheroptimierungsmaßnahmen abgetestet, um zu schauen ob es auch gefruchtet hat.

    Das sollte eigentlich mit _CrtMemCheckpoint oder ähnlichen Debug-Funktionen eines anderen Allocators möglich sein. Kann man aber natürlich auch selbst stricken wenn man möchte 🙂



  • Klingt wie ne Microsoft-Only-Geschichte?


Log in to reply