Límites y subspans
Corte spans de forma segura
Límites y subspans es una lección gratuita de C++ Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C++ Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C++ Academy incluye 4 lecciones en total.
Dividir con subspan
s.subspan(offset, count) devuelve un span sobre una parte del original; no realiza ninguna copia, solo crea un nuevo puntero y una nueva longitud.
#include <iostream>
#include <span>
int main() {
int buf[] = {0, 1, 2, 3, 4};
std::span<int> s(buf, 5);
auto mid = s.subspan(1, 3);
for (int x : mid) std::cout << x << " ";
std::cout << "\n"; // 1 2 3
}first y last
first(n) y last(n) proporcionan spans sobre los n elementos iniciales o finales.
#include <iostream>
#include <span>
int main() {
int buf[] = {10, 20, 30, 40};
std::span<int> s(buf, 4);
auto f = s.first(2);
auto l = s.last(2);
std::cout << f[0] << " " << l[1] << "\n"; // 10 40
}Los subspans comparten la memoria
Modificar un subspan cambia los datos originales, porque ambos apuntan al mismo búfer.
#include <iostream>
#include <span>
int main() {
int buf[] = {1, 1, 1, 1};
std::span<int> s(buf, 4);
auto tail = s.last(2);
tail[0] = 99;
std::cout << buf[2] << "\n"; // 99
}size_bytes
size_bytes() devuelve el tamaño total en bytes de los elementos del span, lo que resulta útil para operaciones de E/S de bajo nivel.
#include <iostream>
#include <span>
int main() {
int buf[] = {1, 2, 3};
std::span<int> s(buf, 3);
std::cout << s.size_bytes() << "\n"; // 3 * sizeof(int)
}Los límites son su responsabilidad
operator[] en un span no comprueba los límites. Leer s[s.size()] produce un comportamiento indefinido.
Compruebe antes de dividir
Llamar a subspan con un desplazamiento o una cantidad mayor que el span produce un comportamiento indefinido; valide primero los valores respecto a size().
#include <iostream>
#include <span>
int main() {
int buf[] = {1, 2, 3};
std::span<int> s(buf, 3);
size_t off = 1, cnt = 2;
if (off + cnt <= s.size()) {
auto sub = s.subspan(off, cnt);
std::cout << sub.size() << "\n";
}
}Vacío después de dividir
Una división puede producir un span vacío (por ejemplo, first(0)); gestiónelo como cualquier rango vacío.
#include <iostream>
#include <span>
int main() {
int buf[] = {1, 2};
std::span<int> s(buf, 2);
auto e = s.first(0);
std::cout << e.empty() << "\n"; // 1
}Encadenar divisiones
Los subspans se pueden dividir aún más, ya que cada uno es simplemente otra vista del búfer original.
#include <iostream>
#include <span>
int main() {
int buf[] = {0, 1, 2, 3, 4, 5};
std::span<int> s(buf, 6);
auto inner = s.subspan(1, 4).first(2);
std::cout << inner[0] << " " << inner[1] << "\n"; // 1 2
}Procesar por bloques
Un uso habitual de subspan es recorrer un búfer grande en ventanas de tamaño fijo para transmitir o procesar por lotes.
#include <iostream>
#include <span>
int main() {
int buf[] = {1, 2, 3, 4, 5, 6};
std::span<int> s(buf, 6);
for (size_t i = 0; i < s.size(); i += 2) {
auto chunk = s.subspan(i, 2);
std::cout << "[" << chunk[0] << "," << chunk[1] << "] ";
}
std::cout << "\n";
}Comprobaciones de extensiones estáticas
Con un span de extensión estática, el compilador puede verificar algunos tamaños de división en tiempo de compilación y detectar los errores antes.
El tiempo de vida sigue siendo importante
Cada subspan comparte el tiempo de vida del búfer original. Si el origen se destruye o se reasigna, todos los spans derivados dejan de ser válidos.
Comprobación rápida
Compruebe su comprensión de los subspans y los límites.
Resumen
Ha aprendido sobre límites y subspans:
subspan,firstylastcrean divisiones sin asignación.- Los subspans comparten la memoria; las modificaciones afectan al original.
operator[]y las divisiones no comprueban los límites; valide primero.- Todos los subspans comparten el tiempo de vida del origen.
Preguntas frecuentes
¿La lección «Límites y subspans» es gratis?
Sí — el texto completo de «Límites y subspans» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C++ Academy, actualiza a CoddyKit PRO. El curso de C++ Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Límites y subspans»?
Corte spans de forma segura Practicas C++ Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar C++ Academy?
No se requiere experiencia previa. C++ Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.
¿Cuánto tiempo toma la lección «Límites y subspans»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de C++ Academy?
Sí. Cada lección de C++ Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.