Uitvoer:
grootte van string = 4
Betekent dit dat, aangezien sizeof(char) = 1 Byte (0 to 255)
, string slechts 4
tekens 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 string
std::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 string
is 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 byte
waarvan we denken dat het 8-bits need not be the case
. Er zijn architecturen waarbij een BYTE 32-bits, 24-bits enzovoort is. De sizeof
toegepast op elk ander type is in veelvouden van sizeof(char)
wat by definition 1
is.
Het volgende belangrijke om op te merken is dat C++ drie karaktertypes heeft: plain char, signed char and unsigned char
. Een plain char
is ofwel signed
of 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 char
unsigned
is.
Dat gezegd hebbende, aangenomen dat ‘string’ 'std::namespace'
is, sizeof(string) == 4
betekent 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:
- Het is niet de grootte van de
string
of de capaciteit van de string, deze waarde vertegenwoordigt de structurele grootte van de klassestring
, die je kunt zien aan de implementatie ervan ( en het kan veranderen van implementatie naar implementatie) dat is een simpele aanwijzing; - 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); - Deze aanwijzer binnen de klasse
string
verwijst naar een geheugenbuffer waar de klasse de echte stringgegevens zal bewaren. /maak meer tekenreekstekst; - 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 sizeof
is, 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 sizeof
is 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