Dlaczego w stringu jest 8

Proszę o pomoc ponieważ dlaczego jest 8?(https://zapodaj.net/b999cee243fb7.jpg.html)

bo to wielkość wskaźnika 64 bitowego (64/8 = 8)

Zaczynam naukę c++ dlaczego 64 bitowy?

Bo masz 64 bitowy kompilator na 64 bitowy procesor więc każdy wskaźnik jest 64 bitowy. Możesz przełączyć na 32 bity jeśli chcesz. Wygląda że nie za bardzo w ogóle wiesz co robisz, więc polecam przejście najpierw jakiegoś podstawowego kursu, zwłaszcza lekcję o wskaźnikach

Ok, ostatnie pytanie czemu podzielił przez 8?

Już rozumiem, dziękuję.

@obscurity: przecież tam nie ma w ogóle żadnego wskaźnika. Nie wiem czemu u OP jest tam 8, na moim linuksie jest 32. Może to wynikać 1) z tego że OP kompiluje na 32 bity 2) z tego, że jest użyta jakaś inna reprezentacja stringa.

Rozmiar obiektu std::string jest całkowicie zależny od implementacji. Nie musi być równy rozmiarowi wskaźnika ani nie ma związku z długością przechowywanego ciągu znaków.
Ponadto, nie jest ten rozmiar nikomu potrzebny. Ot, ciekawostka.

enedil napisał(a):

@obscurity: przecież tam nie ma w ogóle żadnego wskaźnika. Nie wiem czemu u OP jest tam 8, na moim linuksie jest 32. Może to wynikać 1) z tego że OP kompiluje na 32 bity 2) z tego, że jest użyta jakaś inna reprezentacja stringa.

Azarien napisał(a):

Rozmiar obiektu std::string jest całkowicie zależny od implementacji. Nie musi być równy rozmiarowi wskaźnika ani nie ma związku z długością przechowywanego ciągu znaków.

Ponadto, nie jest ten rozmiar nikomu potrzebny. Ot, ciekawostka.

Implementacja może realizować pamiętanie małych stringów "przy obiekcie", dopiero przechodząc przy większych na alokowane

@Robek Robek: na przyszłość jeśli chcesz wklejać screenshoty, to wklejaj screenshoty, a nie dosłowne zdjęcia ekranu. Nie czytaj co pisał tu obscurity, bo tylko mąci w głowie niepoprawnymi informacjami.

sizeof zwraca wielkość elementu danego typu. Jest to wielkość stała w czasie kompilacji i niezależna od jego wartości. Np. dwa stringi, jeden zawierający Ala, a drugi całość Pana Tadeusza będą miały identyczną wielkość zmiennej. W C++ jest to dość mało przydatny operator, szczególnie dla nowicjuszy.

Jeśli chodzi o sam wynik, to jest on bardzo dziwny. Czy używasz jakiegoś przedpotopowego dev-c++ z antycznym kompilatorem? std::string powinien mieć wielkość opdowiednią co najmniej 3 wskaźnikom/size_t (dane + size + capacity), a 8 nijak się do tego nie ma - nawet kompilując w trybie 32-bitowym. Jedyne co mi przychodzi na myśl to właśnie antyczny kompilator, który wykorzystuje COW (Copy On Write) dla stringów, gdzie 8 bajtów może mieć sens.

Azarien napisał(a):

Rozmiar obiektu std::string jest całkowicie zależny od implementacji. Nie musi być równy rozmiarowi wskaźnika ani nie ma związku z długością przechowywanego ciągu znaków.

Ponadto, nie jest ten rozmiar nikomu potrzebny. Ot, ciekawostka.

Implementacja może realizować pamiętanie małych stringów "przy obiekcie", dopiero przechodząc przy większych na alokowane

Jaki mechanizm w C++ pozwoliłby na różny wynik sizeof() kontenerów tego samego typu, a różniących się tylko zawartością?

Azarien napisał(a):

Azarien napisał(a):

Rozmiar obiektu std::string jest całkowicie zależny od implementacji. Nie musi być równy rozmiarowi wskaźnika ani nie ma związku z długością przechowywanego ciągu znaków.

Ponadto, nie jest ten rozmiar nikomu potrzebny. Ot, ciekawostka.

Implementacja może realizować pamiętanie małych stringów "przy obiekcie", dopiero przechodząc przy większych na alokowane

Jaki mechanizm w C++ pozwoliłby na różny wynik sizeof() kontenerów tego samego typu, a różniących się tylko zawartością?

@Azaren, to niewłaściwe pytanie

class Foo
{
	private:
	union
	{
		char *str;
		char small[8];
	};
	bool usesmall;  
	public:
	Foo(const char *str)
	{
		size_t len=strlen(str);
		usesmall=(len<sizeof(str));
		if(usesmall) memcmp(small,str,len+1);
		else
		{
			this->str=new char[len+1];
			memcmp(this->str,str,len+1);
		}
	}
	~Foo() { if(!usesmall) delete[] str; }
};

Poza tym, czy to nie jest C++, owszem brzydkie podejście ale jednak:

struct node
{
	private:
	node() {}
	node *next;
	char text[1];
	public:
	static node *alloc(const char *text)
	{
		size_t size=strlen(text);
		node *n=(node*)malloc(sizeof(node)+size);
		memcpy(n->text,text,size+1);
		return n;
	}
	static void dispose(node *n) { free(n); }
};

Najciekawsze jest to, że sizeof wywołuje zdziwienie przy stringach...

auto short_str = std::string{"Chile"};
auto long_str = std::string{"United States of America"};
if (sizeof(str) == sizeof(long_str)) {
  std::cout << "WTF?! This language is so stupid!!!111";
}

...ale już w przypadku użycia na typie "liczbowym" zdziwienia nie ma:

auto small_val = int{2};
auto big_val = int{20'000'000};
if (sizeof(small_val) == sizeof(big_val)) {
  std::cout << "Yeah, int is int. I got it.";
}

;)

Jeśli jesteśmy przy ciekawostkach:

int main()
{
    auto a = 2'147'483'648;
    auto b = 0x80000000;
    DBG(a);
    DBG(b);
    DBG(a == b);
    DBG(sizeof(a));
    DBG(sizeof(b));
}

a                                                           2147483648
b                                                           2147483648
a == b                                                      true
sizeof(a)                                                   8
sizeof(b)                                                   4

https://wandbox.org/permlink/l20s9oxheVQ4UIYd