c++ - ssize_t - size_t c

size_t vs int en C++ y/o C

Question

¿Por qué es que en los contenedores C ++, devuelve un tipo de size_type lugar de un int ? Si estamos creando nuestras propias estructuras, ¿también deberíamos ser alentados a usar size_type ?

Answer 1

Algunas de las respuestas son más complicadas de lo necesario. Un size_t es un tipo entero sin signo que se garantiza que sea lo suficientemente grande como para almacenar el tamaño en bytes de cualquier objeto en la memoria. En la práctica, siempre es del mismo tamaño que el tipo de puntero. En sistemas de 32 bits es de 32 bits. En sistemas de 64 bits es de 64 bits.

Answer 2

Algunas razones pueden ser:

• El tipo (size_t) se puede definir como el entero sin signo más grande en esa plataforma. Por ejemplo, podría definirse como un entero de 32 bits o un entero de 64 bits o cualquier otra cosa que sea capaz de almacenar valores sin signo de gran longitud
• Para dejar claro al leer un programa que el valor es un tamaño y no solo un int "regular"

Si está escribiendo una aplicación que es solo para usted y / o desechable, probablemente está bien usar un int básico. Si está escribiendo una biblioteca o algo importante, size_t es probablemente una mejor manera de hacerlo.

Answer 3

C ++ es un lenguaje que podría implementarse en diferentes arquitecturas y plataformas de hardware. A medida que pasó el tiempo, admitió una arquitectura de 16, 32 y 64 bits, y probablemente otras en el futuro. size_type y otros alias de tipo son formas en que las bibliotecas aíslan a los programadores / código de los detalles de la implementación.

Suponiendo que size_type usa 32 bits en máquinas de 32 bits y 64 bits en máquinas de 64 bits, el mismo código fuente probablemente funcionaría mejor si ha usado size_type donde sea necesario. En la mayoría de los casos, podría asumir que sería lo mismo que unsigned int , pero no está garantizado.

size_type se usa para expresar capacidades de contenedores STL como std::vector mientras que size_t se usa para expresar el tamaño de bytes de un objeto en C / C ++.

Answer 4

En general, size_t debe usarse siempre que mida el tamaño de algo. Es realmente extraño que size_t solo sea requerido para representar entre 0 y SIZE_MAX bytes y que SIZE_MAX solo sea requerido para ser 65,535 ...

Las otras restricciones interesantes de los Estándares C ++ y C son:

• el tipo de retorno de sizeof() es size_t y es un entero sin signo
• operator new() toma el número de bytes para asignar como un parámetro size_t
• size_t se define en <cstddef>
• SIZE_MAX se define en <limits.h> en C99 pero no se menciona en C ++ 98 ?!
• size_t no está incluido en la lista de tipos de enteros fundamentales, por lo que siempre he asumido que size_t es un alias de tipo para uno de los tipos fundamentales: char , short int , int y long int .

Si está contando bytes, entonces definitivamente debería usar size_t . Si está contando la cantidad de elementos, entonces probablemente debería usar size_t ya que parece ser lo que C ++ ha estado usando. En cualquier caso, no desea utilizar int , por lo menos use unsigned long o unsigned long long si está usando TR1. O ... aún mejor ... typedef lo que sea que termine usando para size_type o simplemente incluya <cstddef> y use std::size_t .

Answer 5

No se garantiza que los ints tengan 4 bytes en la especificación, por lo que no son confiables. Sí, size_type sería preferido sobre ints

Answer 6

Supongo que quiere decir "size_t": esta es una forma de indicar un entero sin signo (un entero que solo puede ser positivo, nunca negativo): tiene sentido para los tamaños de los contenedores, ya que no puede tener una matriz con un tamaño de -7. No diría que tiene que usar size_t pero indica a otros que usan su código "Este número siempre es positivo". También le da una mayor variedad de números positivos, pero es probable que no sea importante a menos que tenga algunos contenedores muy grandes.

Answer 7

Todos los contenedores en el stl tienen varias typedefs. Por ejemplo, value_type es el tipo de elemento y size_type es el número de tipo almacenado. De esta manera los contenedores son completamente genéricos basados ​​en plataforma e implementación.

Si está creando sus propios contenedores, también debe usar size_type . Típicamente esto se hace

typedef std::size_t size_type;

Si quieres un tamaño de contenedor, deberías escribir

typedef vector<int> ints;
ints v;
v.push_back(4);
ints::size_type s = v.size();

Lo bueno es que si luego quieres usar una lista, simplemente cambia el typedef a

typedef list<int> ints;

¡Y todavía funcionará!

Answer 8

size_t no tiene firma, por lo que incluso si ambos son de 32 bits no significa exactamente lo mismo que un int no calificado. No estoy seguro de por qué agregaron el tipo, pero en muchas plataformas de hoy sizeof (size_t) == sizeof (int) == sizeof (long) , así que el tipo que elija depende de usted. Tenga en cuenta que esas relaciones no están garantizadas por el estándar y se están desactualizando rápidamente a medida que se mueven las plataformas de 64 bits.

Para su propio código, si necesita representar algo que es un "tamaño" conceptualmente y nunca puede ser negativo, size_t sería una buena opción.

Answer 9

void f1(size_t n) {
    if (n <= myVector.size()) { assert(false); }
    size_t n1 = n - myVector.size(); // bug! myVector.size() can be > n       
    do_stuff_n_times(n1);
}

void f2(int n) {
    int n1 = n - static_cast<int>(myVector.size());
    assert(n1 >= 0);
    do_stuff_n_times(n1);
}

f1 () y f2 () tienen el mismo error, pero detectar el problema en f2 () es más fácil. Para códigos más complejos, los errores aritméticos de enteros sin signo no son tan fáciles de identificar.

Personalmente uso int firmado para todos mis tamaños, a menos que se deba usar int sin firmar. Nunca me he encontrado con una situación en la que mi tamaño no se ajuste a un entero con signo de 32 bits. Probablemente usaré enteros con signo de 64 bits antes de usar enteros sin signo de 32 bits.

El problema con el uso de enteros con signo para el tamaño es una gran cantidad de static_cast desde size_t a int en su código.