Summary  
This chapter explains how unsigned integer types reserve all bits for value storage to extend the range of storable non-negative numbers, at the cost of no longer representing negative values.

General domain of usage  
Storing counts or sizes where values are guaranteed non-negative (e.g., array indices, object counts).

Explore unsigned data types in C++. Learn how unsigned types differ from signed types, why they are useful for representing only non-negative numbers, and how they affect memory usage and value range. See practical examples, such as using unsigned integers to track warehouse inventory, and understand what happens if you assign a negative value to an unsigned variable. This video covers key concepts, including the role of the sign bit, the expanded range of unsigned types, and when to apply the unsigned modifier in your own programs.

Para representar un número en el sistema binario, es necesario almacenar tanto su **valor** como su **signo**. Un bit se dedica a almacenar el signo, mientras que los bits restantes se utilizan para almacenar el valor numérico. El bit de signo almacena:

- `0` si el número es no negativo;
- `1` si el número es negativo.

Si se tiene la certeza de que la variable **solo puede contener números no negativos**, se puede utilizar el modificador de tipo `unsigned`. Este modificador permite almacenar valores sin considerar el signo.

Además, debido al aumento de memoria disponible para almacenar el valor, el rango de valores posibles es más amplio; sin embargo, los números negativos no están incluidos en este rango. Por lo tanto, los rangos permitidos son los siguientes:


I2luY2x1ZGUgPGlvc3RyZWFtPgoKaW50IG1haW4oKQp7Cgl1bnNpZ25lZCBpbnQgdG90YWxfdmVoaWNsZXMgPSAxNDQ2MDAwMDAwOwoJdW5zaWduZWQgc2hvcnQgYWdlID0gMjE7CiAgCglzdGQ6OmNvdXQgPDwgdG90YWxfdmVoaWNsZXMgPDwgc3RkOjplbmRsOwoJc3RkOjpjb3V0IDw8IGFnZSA8PCBzdGQ6OmVuZGw7Cn0=

Además, existe un modificador de tipo `signed` disponible para indicar que un tipo de dato puede acomodar tanto números positivos como negativos. Sin embargo, todos los tipos de datos numéricos son `signed` por defecto, por lo que no es necesario especificarlo explícitamente.

Nota

Asegúrese de utilizar `unsigned` solo cuando la variable no pueda tomar valores negativos.  
Asignar un valor negativo a una variable unsigned no generará errores, pero el valor resultante será incorrecto.

#define CATCH_CONFIG_MAIN
#include <catch2/catch.hpp>

unsigned int addStock(unsigned int stock, unsigned int newStock, unsigned int maxCapacity);

TEST_CASE("Add 30 to 950 with max 1000 -> 980", "[addStock]") {
    unsigned int result = addStock(950, 30, 1000);
    REQUIRE(result == 980); // Expected: 980, input: stock=950, newStock=30, maxCapacity=1000
}

TEST_CASE("Add 100 to 950 with max 1000 -> 1000 (capped)", "[addStock]") {
    unsigned int result = addStock(950, 100, 1000);
    REQUIRE(result == 1000); // Expected: 1000, input: stock=950, newStock=100, maxCapacity=1000
}

TEST_CASE("Add 0 to 950 with max 1000 -> 950 (no change)", "[addStock]") {
    unsigned int result = addStock(950, 0, 1000);
    REQUIRE(result == 950); // Expected: 950, input: stock=950, newStock=0, maxCapacity=1000
}

TEST_CASE("Add 1000 to 0 with max 1000 -> 1000 (fills capacity)", "[addStock]") {
    unsigned int result = addStock(0, 1000, 1000);
    REQUIRE(result == 1000); // Expected: 1000, input: stock=0, newStock=1000, maxCapacity=1000
}

TEST_CASE("Add 500 to 400 with max 800 -> 800 (capped)", "[addStock]") {
    unsigned int result = addStock(400, 500, 800);
    REQUIRE(result == 800); // Expected: 800, input: stock=400, newStock=500, maxCapacity=800
}

TEST_CASE("Add 100 to 200 with max 500 -> 300 (normal add)", "[addStock]") {
    unsigned int result = addStock(200, 100, 500);
    REQUIRE(result == 300); // Expected: 300, input: stock=200, newStock=100, maxCapacity=500
}

TEST_CASE("Add 0 to 0 with max 100 -> 0 (empty warehouse)", "[addStock]") {
    unsigned int result = addStock(0, 0, 100);
    REQUIRE(result == 0); // Expected: 0, input: stock=0, newStock=0, maxCapacity=100
}

test.cpp

Desarrollar una comprensión integral de los tipos de datos es fundamental al aprender un lenguaje de programación. Este curso ofrece la oportunidad de profundizar en los tipos de datos en C++, obteniendo información sobre cómo se almacenan en la memoria. Además, el curso aborda el tema de la conversión de tipos.

Ofrece una visión fundamental de las operaciones aritméticas y sus posibles errores, los tipos de datos y la importancia de especificar los tipos.

short, int, long, float, double, etc. son todos tipos de datos numéricos. Aprenderá sobre cada uno de ellos, así como las posibles dificultades que pueden presentar.

Incluye el trabajo con texto en C++ utilizando `char` y `string`. Aprenderá a almacenar y manipular caracteres, utilizar métodos de cadenas, indexar y modificar cadenas, buscar texto y comprender la gestión de memoria de cadenas. Al finalizar, estará preparado para manejar texto de manera eficiente en sus programas.

Incluye valores lógicos con bool, funciones sin valores de retorno utilizando void y deducción automática de tipo con auto. También explora la conversión de tipos, tanto implícita como explícita, garantizando el manejo correcto de los tipos de datos.

Desafío: Tipos de Datos Sin Signo

Solución