c++ sizeof( string )

Uitvoer:

grootte van string = 4

Betekent dit dat, aangezien sizeof(char) = 1 Byte (0 to 255), string slechts 4tekens kan bevatten?

Antwoord 1, autoriteit 100%

Het is uit je voorbeeld niet duidelijk wat ‘string’ is. Als je het volgende hebt:

#include <string>
using namespace std;

dan is stringstd::string, en sizeof(std::string)geeft je de grootte van de klasse-instantie en zijn gegevensleden, niet de lengte van de tekenreeks. Gebruik hiervoor:

string s;
cout << s.size();

Antwoord 2, autoriteit 47%

Als stringis gedefinieerd als:

char *string;

sizeof(string)vertelt je de grootte van de aanwijzer. 4 bytes (U werkt op een 32-bits machine.) U heeft nog geen geheugen toegewezen voor tekst. Wil je een tekenreeks van 10 tekens? string = malloc(10); String wijst nu naar een buffer van 10 bytes waarin je tekens kunt plaatsen.

sizeof(*string)wordt 1. De grootte van de string waarnaar wordt verwezen, een char.

Als je dat wel deed

char string[10];

sizeof(string)zou 10 zijn. Het is een array van 10 tekens.
sizeof(*string)zou nog steeds 1 zijn.

Het is de moeite waard om de __countof macro op te zoeken en te begrijpen.

Update: oh, ja, voeg NU de headers toe 🙂 ‘string’ is een klasse waarvan de instanties 4 bytes in beslag nemen, meer niet. Die 4 bytes kunnen verwijzen naar iets veel nuttigers, zoals een geheugengebied met meer dan 4 tekens.

Je kunt dingen doen als:

string s = "12345";
cout << "length of String " << s.length();

Antwoord 3, autoriteit 27%

sizeof(char)is altijd 1 byte. Een bytewaarvan we denken dat het 8-bits need not be the case. Er zijn architecturen waarbij een BYTE 32-bits, 24-bits enzovoort is. De sizeoftoegepast op elk ander type is in veelvouden van sizeof(char)wat by definition 1is.

Het volgende belangrijke om op te merken is dat C++ drie karaktertypes heeft: plain char, signed char and unsigned char. Een plain charis ofwel signedof unsigned. Het is dus verkeerd om aan te nemen dat char alleen waarden van 0 tot 255 kan hebben. Dit is alleen waar als een char 8-bits is en plain charunsignedis.

Dat gezegd hebbende, aangenomen dat ‘string’ 'std::namespace'is, sizeof(string) == 4betekent dat de grootte van de 'std::string'klasse is 4 bytes. Het neemt 4 keer het aantal bytes in beslag dat een 'char'op die machine nodig heeft. Note that signed T, unsigned T always have the same size. Het betekent niet dat de feitelijke buffer van karakters (die in het gewone spraakgebruik string wordt genoemd) slechts 4 bytes is. Binnen de klasse 'std::string'bevindt zich een niet-statische lidaanwijzer die dynamisch wordt toegewezen om de invoerbuffer vast te houden. Dit kan zoveel elementen bevatten als het systeem toestaat (C++ legt geen beperking op deze lengte). Maar aangezien de klasse 'std::string'alleen de aanwijzer naar deze potentieel oneindige lengtebuffer bevat, blijft de sizeof(std::string) altijd hetzelfde als de sizeof-aanwijzer op de gegeven architectuur die op uw systeem is 4.

Antwoord 4, autoriteit 17%

Ik weet dat veel mensen je vraag hebben beantwoord, maar hier zijn enkele punten:

1. Het is niet de grootte van de stringof de capaciteit van de string, deze waarde vertegenwoordigt de structurele grootte van de klasse string, die je kunt zien aan de implementatie ervan ( en het kan veranderen van implementatie naar implementatie) dat is een simpele aanwijzing;
2. Aangezien de sizeof(string)de grootte is van de klassenstructuur, krijg je de grootte van de enige interne pointer, die in jouw geval 4 bytes is (omdat je in een 32 -bit machine, dit kan ook van platform tot platform veranderen);
3. Deze aanwijzer binnen de klasse stringverwijst naar een geheugenbuffer waar de klasse de echte stringgegevens zal bewaren. /maak meer tekenreekstekst;
4. Als je de echte grootte van de tekenreeks wilt krijgen, moet je de methode size()uit de klasse aanroepen die de grootte van de geheugenbuffertekenreeks controleert (wat niet hetzelfde is als de geheugenbuffergrootte).

Ik denk dat uw probleem uw opvatting van sizeofis, zie hier meer informatie en hieris wat uitleg over hoe het werkt.

Antwoord 5, autoriteit 13%

Helemaal niet. Het betekent dat de structuur van de klasse zo is, dat het niet het dynamische geheugen bevat dat het kan besturen. std::string wordt dynamisch uitgebreid om aan elke gewenste grootte te voldoen.

s.max_size() // will give the true maximum size
s.capacity() // will tell you how much it can hold before resizing again
s.size() // tells you how much it currently holds

De 4 die je krijgt van sizeofis waarschijnlijk een soort verwijzing naar de grotere structuur. Hoewel sommige optimalisaties op sommige platforms het gebruiken als de daadwerkelijke tekenreeksgegevens totdat het groter wordt dan past.

Antwoord 6, autoriteit 10%

Nee, dit betekent dat de grootte van de klassenreeks 4 is.

Het betekent niet dat een string kan worden opgenomen in 4 bytes geheugen. Helemaal niet. Maar je moet onderscheid maken tussen dynamisch geheugen, waarin de size-tekens staan waaruit een string kan worden gemaakt, en het geheugen dat wordt ingenomen door het adres van de eerste van die tekens

Probeer het zo te zien:

contents  --------> |h|e|l|l|o| |w|o|r|ld|\0|

sizeof 4 verwijst naar het geheugen dat wordt ingenomen door inhoud. Wat het inhoud? Gewoon een verwijzing naar (het adres van) het eerste teken in de char-array.

Hoeveel karakters mag een string bevatten? Idealiter is er een karakter per byte beschikbaar in het geheugen.

Hoeveel karakters heeft een string eigenlijk? Welnu, er is een ledenfunctie genaamd size()die je precies dat zal vertellen

size_type size() const

Zie meer op de SGIpagina !

Antwoord 7

Een string-object bevat een pointernaar een buffer op de heap die de feitelijke stringgegevens bevat. (Het kan ook andere implementatiespecifieke meta-informatie bevatten, maar die van jou blijkbaar niet.) Je krijgt dus de grootte van die aanwijzer, niet de grootte van de array waarnaar deze verwijst.

Antwoord 8

u kunt ook strings gebruiken en de lengte ervan achterhalen met de functie string.length(). kijk naar de onderstaande code:

// Finding length of a string in C++
#include<iostream>
#include<string>
using namespace std;
int count(string);
int main()
{
string str;
cout << "Enter a string: ";
getline(cin,str);
cout << "\nString: " << str << endl;
cout << count(str) << endl;
return 0;
}
int count(string s){
if(s == "")
  return 0;
if(s.length() == 1)
  return 1;
else
    return (s.length());
}

u kunt de details krijgen van:
http://www.programmingtunes.com/finding-length- of-a-string-in-c/

Antwoord 9

size() van string geeft het aantal elementen in de string, terwijl sizeof() functie op een string drie extra bits geeft. strlen() van een karakterarray geeft het aantal elementen + 1 (vanwege het null char scheidingsteken) en houd er rekening mee dat de grootte van char 1 byte is. sizeof() op een char-array geeft de grootte die aan de array is toegewezen

string str="hello";
char arr[x]="hello";
cout<<str.size()<<endl<<sizeof(str)<<endl;
cout<<strlen(arr)<<endl<<sizeof(arr)<<endl;

uitvoer is 5 8 5 x