Kiedy używać std :: size_t?

Zastanawiam się, czy powinienem używać std::size_tpętli i innych rzeczy zamiast int? Na przykład:

#include <cstdint>

int main()
{
    for (std::size_t i = 0; i < 10; ++i) {
        // std::size_t OK here? Or should I use, say, unsigned int instead?
    }
}

Ogólnie, jaka jest najlepsza praktyka dotycząca tego, kiedy stosować std::size_t?

Dobrą zasadą jest, aby wszystko, co trzeba porównać w pętli z czymś, co jest naturalnie std::size_tsamym sobą.

std::size_tjest rodzajem dowolnego sizeofwyrażenia i gwarantuje, że będzie w stanie wyrazić maksymalny rozmiar dowolnego obiektu (w tym dowolnej tablicy) w C ++. Przez rozszerzenie jest również zagwarantowane, że jest wystarczająco duży dla dowolnego indeksu tablicy, więc jest to naturalny typ dla pętli po indeksie nad tablicą.

Jeśli liczysz tylko liczbę, może być bardziej naturalne użycie typu zmiennej, która przechowuje tę liczbę, intlub unsigned int( lub wystarczająco duży), ponieważ powinny one mieć naturalny rozmiar dla maszyny.

size_tjest typem wyniku sizeofoperatora.

Użyj size_tdla zmiennych, które modelują rozmiar lub indeks w tablicy. size_tprzekazuje semantykę: od razu wiesz, że reprezentuje rozmiar w bajtach lub indeksie, a nie tylko inną liczbę całkowitą.

Ponadto użycie size_tdo reprezentowania rozmiaru w bajtach pomaga uczynić kod przenośnym.

size_tTypu służy do określenia rozmiaru czegoś więc to naturalne, aby go użyć, na przykład, coraz długość łańcucha, a następnie przetwarza każdy znak:

for (size_t i = 0, max = strlen (str); i < max; i++)
    doSomethingWith (str[i]);

Ci nie muszą zwracać uwagę na warunki brzegowe oczywiście, ponieważ jest to typ unsigned. Granica na końcu górnej zwykle nie jest to ważne, ponieważ maksymalna to zazwyczaj duże (choć jest możliwe, aby się tam dostać). Większość ludzi po prostu używa inttego typu rzeczy, ponieważ rzadko mają struktury lub tablice, które stają się wystarczająco duże, aby przekroczyć ich możliwości int.

Ale uważaj na takie rzeczy jak:

for (size_t i = strlen (str) - 1; i >= 0; i--)

co spowoduje nieskończoną pętlę z powodu zawijania się niepodpisanych wartości (chociaż widziałem, że kompilatory ostrzegają przed tym). Można to również złagodzić poprzez (nieco trudniejsze do zrozumienia, ale przynajmniej odporne na problemy z owijaniem):

for (size_t i = strlen (str); i-- > 0; )

Przesunięcie dekrementacji na efekt uboczny warunku kontynuacji po sprawdzeniu powoduje sprawdzenie kontynuacji wartości przed dekrementacją, ale nadal korzysta ze zmniejszonej wartości w pętli (dlatego pętla działa len .. 1raczej niż len-1 .. 0).

Z definicji size_tjest wynikiem sizeofoperatora. size_tzostał stworzony w celu odniesienia do rozmiarów.

Liczba przypadków, w których coś robisz (w twoim przykładzie 10), nie dotyczy rozmiarów, więc po co używać size_t? intlub unsigned intpowinien być w porządku.

Oczywiście istotne jest również to, co robisz iw pętli. Jeśli przekażesz go do funkcji, która bierze unsigned intna przykład pick unsigned int.

W każdym razie zalecam unikanie konwersji typu niejawnego. Wyraźnie wszystkie konwersje typów.

size_tjest bardzo czytelnym sposobem na określenie wymiaru rozmiaru elementu - długości łańcucha, ilości bajtów, które zajmuje wskaźnik itp. Jest także przenośny na różnych platformach - przekonasz się, że 64-bitowy i 32-bitowy zachowują się ładnie dzięki funkcjom systemowym i size_t- coś, co unsigned intmoże nie zrobić (np. kiedy należy użyćunsigned long

krótka odpowiedź:

prawie nigdy

długa odpowiedź:

Ilekroć musisz mieć wektor char większy niż 2 GB w systemie 32-bitowym. W każdym innym przypadku użycie podpisanego typu jest znacznie bezpieczniejsze niż użycie niepodpisanego typu.

przykład:

std::vector<A> data;
[...]
// calculate the index that should be used;
size_t i = calc_index(param1, param2);
// doing calculations close to the underflow of an integer is already dangerous

// do some bounds checking
if( i - 1 < 0 ) {
    // always false, because 0-1 on unsigned creates an underflow
    return LEFT_BORDER;
} else if( i >= data.size() - 1 ) {
    // if i already had an underflow, this becomes true
    return RIGHT_BORDER;
}

// now you have a bug that is very hard to track, because you never 
// get an exception or anything anymore, to detect that you actually 
// return the false border case.

return calc_something(data[i-1], data[i], data[i+1]);

Podpisany odpowiednik size_tto ptrdiff_tnie int. Ale intw większości przypadków używanie jest znacznie lepsze niż size_t. ptrdiff_tjest longw systemach 32 i 64-bitowych.

Oznacza to, że zawsze musisz konwertować do iz size_t za każdym razem, gdy wchodzisz w interakcje ze std :: container, co nie jest zbyt piękne. Ale podczas trwającej konferencji natywnej autorzy c ++ wspomnieli, że zaprojektowanie std :: vector z niepodpisanym size_t było błędem.

Jeśli Twój kompilator wyświetla ostrzeżenia o niejawnych konwersjach z ptrdiff_t na size_t, możesz to wyraźnie wyrazić za pomocą składni konstruktora:

calc_something(data[size_t(i-1)], data[size_t(i)], data[size_t(i+1)]);

jeśli chcesz po prostu iterować kolekcję, bez sprawdzania granic, użyj zakresu opartego na:

for(const auto& d : data) {
    [...]
}

tutaj kilka słów od Bjarne Stroustrup (autor C ++) na temat przejścia na język ojczysty

Dla niektórych osób ten błąd projektu podpisany / niepodpisany w STL jest wystarczającym powodem, aby nie używać std :: vector, ale zamiast własnej implementacji.

Użyj std :: size_t do indeksowania / liczenia tablic typu C.

W przypadku kontenerów STL będziesz mieć (na przykład) vector<int>::size_type, które powinny być używane do indeksowania i zliczania elementów wektorowych.

W praktyce zazwyczaj są to ints bez znaku, ale nie jest to gwarantowane, szczególnie przy użyciu niestandardowych alokatorów.

Wkrótce większość komputerów będzie miała architekturę 64-bitową z 64-bitowym systemem operacyjnym: es z programami działającymi na kontenerach miliardów elementów. Następnie należy użyć size_tzamiast intjako indeksu pętli, w przeciwnym razie indeks będzie zawijał się na elemencie 2 ^ 32: th, zarówno w systemach 32-, jak i 64-bitowych.

Przygotuj się na przyszłość!

Korzystając z size_t, zwróć uwagę na następujące wyrażenie

size_t i = containner.find("mytoken");
size_t x = 99;
if (i-x>-1 && i+x < containner.size()) {
    cout << containner[i-x] << " " << containner[i+x] << endl;
}

Otrzymasz false w wyrażeniu if bez względu na to, jaką wartość masz dla x. Uświadomienie sobie tego zajęło mi kilka dni (kod jest tak prosty, że nie przeprowadziłem testu jednostkowego), chociaż ustalenie źródła problemu zajęło tylko kilka minut. Nie jestem pewien, czy lepiej jest wykonać rzut lub użyć zera.

if ((int)(i-x) > -1 or (i-x) >= 0)

Oba sposoby powinny działać. Oto mój testowy przebieg

size_t i = 5;
cerr << "i-7=" << i-7 << " (int)(i-7)=" << (int)(i-7) << endl;

Wyjście: i-7 = 18446744073709551614 (int) (i-7) = - 2

Chciałbym komentarze innych.

size_t jest zwracany przez różne biblioteki, aby wskazać, że rozmiar tego kontenera jest różny od zera. Używasz go, gdy wrócisz: 0

Jednak w powyższym przykładzie zapętlenie na size_t jest potencjalnym błędem. Rozważ następujące:

for (size_t i = thing.size(); i >= 0; --i) {
  // this will never terminate because size_t is a typedef for
  // unsigned int which can not be negative by definition
  // therefore i will always be >= 0
  printf("the never ending story. la la la la");
}

użycie liczb całkowitych bez znaku może potencjalnie powodować tego rodzaju subtelne problemy. Dlatego imho wolę używać size_t tylko wtedy, gdy wchodzę w interakcje z kontenerami / typami, które tego wymagają.

size_tjest typem bez znaku, który może przechowywać maksymalną wartość całkowitą dla twojej architektury, więc jest chroniony przed przepełnieniem liczb całkowitych z powodu znaku (podpisany int 0x7FFFFFFFzwiększony o 1 da -1) lub krótki rozmiar (niepodpisany krótki int 0xFFFF zwiększony o 1 da ci 0).

Jest używany głównie w indeksowaniu tablic / pętlach / arytmetyki adresów i tak dalej. Funkcje takie jak memset()i podobne akceptują size_ttylko, ponieważ teoretycznie możesz mieć blok pamięci wielkości 2^32-1(na platformie 32-bitowej).

Dla takich prostych pętli nie zawracaj sobie głowy i używaj tylko int.

size_t to typ całki bez znaku, który może reprezentować największą liczbę całkowitą w twoim systemie. Używaj go tylko wtedy, gdy potrzebujesz bardzo dużych tablic, macierzy itp.

Niektóre funkcje zwracają rozmiar_t, a twój kompilator ostrzega cię, jeśli spróbujesz dokonać porównań.

Unikaj tego, używając odpowiedniego podpisanego / niepodpisanego typu danych lub po prostu typecast dla szybkiego włamania.

size_t jest bez znaku int. więc kiedy tylko chcesz int bez znaku, możesz go użyć.

Używam go, gdy chcę określić rozmiar tablicy, przeciwdziałać ...

void * operator new (size_t size); is a good use of it.