3. Wie groß ist ein std::string

Wie groß ist ein std::string

  • F

    Also wieviel Speicher belegt der?

    Im grunde ist es doch ein Zeiger auf eine Zeichenkette d.H. 4 Byte + die Anzahl der Zeichen bytes + \0 (1 Byte)

    Also selbst der leere String hat 5 Byte, ansonsten 5+Anzahl Zeichen Byte?
    Ist das richtig oder liege ich da vollkommen Falsch? Sogar noch mehr? Ich weiss nicht wie std::string da wirklich implementiert ist. Ich brauch die Angabe um den groben Speicherverbrauch einer Anwendung zu kalkulieren.

    0
  • U

    zu erst: das ist nicht standardisiert, aber wird so in etwa aussehen:

    laenge (32bit / 64bit)
    pointer(32bit / 64bit)

    also bei nem 32bit system sinds 8byte und bei nem 64bit system 16byte

    dann kommt aber noch der speicher auf dem heap(bzw freispeicher oder wie auch immer er im standard betitelt wird) dazu - das ist: mind.(!) sizeof(char_type)*laenge

    du scheinst von char auszugehen und ein char hat üblicherweise(auch das hier ist nur die Regel und keine Vorschrift) 8bit. also mindestens so viel byte, wie der string lang ist - aber wie gesagt steht auch hier nirgendwo, dass es nicht mehr sein darf.

    bb

    0
  • V

    -string hat zwei zeiger plus die

    -verwalteten daten, ein char pro zeichen plus nullterminator, zwei zeiger dazu fürs freispeichermanagement, das ganze aufgerundet auf die nächste 32-byte-grenze.

    aber je nach string kanns auch anders sein. referenzzähler für copy-on-write. und natürlich small string optimisazion.

    schau doch einfach in die implemetierung rein.

    0
  • U

    edit: leider war der code ein wenig zu fehlerhaft^^

    #include <iostream> 
#include <string> 

void print_size(const std::string &x) 
{
	std::cout << "groesse von: \'" << x << "\':" << std::endl
		<< "stack: " << sizeof(x) << std::endl
		<< "heap: >=" << x.capacity() * sizeof(std::string::value_type) << std::endl;
} 

int main() 
{
	std::string a;
	std::string b("ASD");
	std::string c("def");

	print_size(a);
	print_size(a+b);
	print_size(a+b+c);
	print_size(b);
	print_size(b+c);
	print_size(c);

	system("PAUSE");
}

    MSVC9, 32bit, Debug schrieb:

    stack: 32
    heap: >=15

    überall

    MSVC9, 32bit, Release schrieb:

    stack: 28
    heap: >=15

    überall

    bin ich selbst ein wenig überrascht, aber ok : D

    bb

    0
  • S

    Man kann auch einen String mit nur einem Zeiger implementieren. Das scheint libstdc++ (GCC) so zu machen. Jedenfalls bekomme ich bei sizeof(std::string) die Ausgabe 4. Was im Heap angelegt wird, wenn man den String füllt, weiß ich natürlich nicht genau. Es ist mindestens die Kapazität, die Länge des Strings und die Zeichen selbst. Eventuell noch ein Referenzzähler vielleicht...

    Gruß,
    SP

    0

  • Moechte evtl. jemand mal die stlport messen? f'`8k

    Autocogito

    Gruß, TGGC (Was Gamestar sagt...)

    0
  • U

    Sebastian Pizer schrieb:

    Man kann auch einen String mit nur einem Zeiger implementieren. Das scheint libstdc++ (GCC) so zu machen. Jedenfalls bekomme ich bei sizeof(std::string) die Ausgabe 4. Was im Heap angelegt wird, wenn man den String füllt, weiß ich natürlich nicht genau. Es ist mindestens die Kapazität, die Länge des Strings und die Zeichen selbst. Eventuell noch ein Referenzzähler vielleicht...

    Gruß,
    SP

    hmm... dann müsste man die länge oder nen ptr auf das ende auf dem heap speichern, da size() eine konstante laufzeit haben soll - erscheint mir gerade ein wenig eigenartig - aber die, die sich das ausdenken haben sicherlich bissl mehr ahnung als ich^^
    vrmtl. wirds aber so in etwa aussehen:

    template < /* .... */ >
struct basic_string
{
private:
  std::vector *content;
public:
  /*...*/
};

    bb

    0

  • TGGC schrieb:

    Moechte evtl. jemand mal die stlport messen?

    MSVC 2005, 32bit, Release, stlport schrieb:

    stack: 24
    heap: >=15

    überall

    So, habs mal gemacht. f'`8k

    Autocogito

    Gruß, TGGC (Was Gamestar sagt...)

    0
  • V

    unskilled schrieb:

    hmm... dann müsste man die länge oder nen ptr auf das ende auf dem heap speichern, da size() eine konstante laufzeit haben soll - erscheint mir gerade ein wenig eigenartig

    Mir nicht. Für's Copy-On-Write ist es eh eine gute Idee, daß der String quasi pimplt.

    template < /* .... */ >
struct basic_string
{
private:
  basic_string_imp *imp;
public:
  bar foo() const{
    return impl->foo();
  }
  bar foo() {
    impl=getCopyAnsRealeaseIfNotAllone(impl);
    return impl->foo();
  }
  ...
};

    class basic_string_imp {
   int refcount;
   char* begin;
   char* end;
   ...
};
    0
  • B

    uhm..... ich will euch ja nicht den Spass verderben, aber die exakte Antwort ist

    sizeof(std::string);

    🙄

    0
  • U

    Blue-Tiger schrieb:

    uhm..... ich will euch ja nicht den Spass verderben, aber die exakte Antwort ist

    sizeof(std::string);

    🙄

    ich will dir ja nicht den spaß verderben, aber guck mal den 4. post an^^

    bb

    0
  • B

    unskilled schrieb:

    Blue-Tiger schrieb:

    uhm..... ich will euch ja nicht den Spass verderben, aber die exakte Antwort ist

    sizeof(std::string);

    🙄

    ich will dir ja nicht den spaß verderben, aber guck mal den 4. post an^^

    bb

    hoppla.... da war so viel Code, das sah mir nach 'ner komplizierteren Loesung aus. Schande ueber mich 🤡 *in die Ecke stell*

    0
Anmelden zum Antworten