HOWTO · Arduino
Función strcpy de Arduino
Uno puede copiar una cadena de una variable a otra usando la función strcpy() en Arduino.
En esta página
Usa strcpy(destination, source) para copiar una cadena C terminada en nulo, incluido su \0 final. El destino debe tener espacio para todos los caracteres de la cadena de origen y ese terminador. Por ejemplo, "Hello World" necesita 12 bytes. Esta función sirve para arreglos de caracteres, no para objetos String de Arduino; no la uses si el origen y el destino se solapan.
Entender strcpy() y las cadenas terminadas en nulo
Una cadena C es una secuencia de caracteres seguida de un byte nulo (\0). strcpy() recibe un puntero a un destino escribible y un puntero a una cadena de origen de ese tipo. Copia hasta incluir el terminador de la cadena de origen y devuelve el puntero al destino. El origen puede declararse como const char *; el destino debe ser escribible.
La función no recibe la capacidad del destino, así que no puede comprobar si el arreglo es suficientemente grande. Si no hay espacio para todos los caracteres y el terminador, el comportamiento del programa no está definido. Que una ejecución parezca funcionar no vuelve segura una copia en un destino demasiado pequeño. Distingue también una cadena C, como char name[], de un objeto String de Arduino, que usa una interfaz diferente.
Copiar una cadena de forma segura con strcpy()
Este sketch completo copia los 11 caracteres de "Hello World" y su \0 terminador en un arreglo de 12 bytes; después imprime la cadena copiada por Serial. El sustituto de Serial para el entorno anfitrión que aparece a continuación permite ejecutar la misma lógica de setup() como ejemplo autónomo; en una placa Arduino, el núcleo proporciona Serial y llama a setup(). La cadena de ejemplo Hello World permanece en inglés en el código y la salida.
#include <cstring>
#ifndef ARDUINO
#include <iostream>
struct SerialPort {
void begin(unsigned long) {}
void println(const char* value) { std::cout << value << '\n'; }
} Serial;
#endif
const char source[] = "Hello World";
char destination[sizeof(source)]; // 12 bytes: 11 characters plus \0
void setup() {
Serial.begin(9600);
std::strcpy(destination, source);
Serial.println(destination);
}
void loop() {
// The copy is performed once in setup().
}
#ifndef ARDUINO
int main() {
setup();
return 0;
}
#endif
Hello World
Para este origen fijo, sizeof(source) incluye el terminador, por lo que la capacidad del destino es de 12 bytes. Si se trata de un puntero a texto, sizeof(pointer) solo da el tamaño del puntero; calcula la capacidad necesaria a partir de la longitud de la cadena más uno. Mantén el origen y el destino en espacios de almacenamiento distintos y sin solapamiento. El siguiente ejemplo en C para el entorno anfitrión muestra la misma copia de una cadena conocida en el entorno de ejecución configurado.
#include <stdio.h>
#include <string.h>
int main(void) {
const char source[] = "Hello World";
char destination[sizeof(source)];
strcpy(destination, source);
puts(destination);
return 0;
}
Hello World
Comparar strncpy() y strlcpy()
strncpy(destination, source, count) copia como máximo count bytes. Si el origen termina antes de alcanzar count, rellena con bytes nulos el resto del destino. Si el origen tiene al menos count bytes, no añade un terminador. Por eso, no se debe pasar a funciones de cadenas un destino que strncpy() haya llenado hasta su capacidad antes de comprobar o establecer la terminación. Para un arreglo de destino con capacidad mayor que cero, un patrón habitual consiste en copiar como máximo capacity - 1 bytes y luego asignar destination[capacity - 1] = '\0'. Así se obtiene una cadena terminada que quizá esté truncada; esto, por sí solo, no valida el origen ni evita otros errores de memoria.
strlcpy(destination, source, size) recibe la capacidad total del destino, incluido el espacio para \0; si size es mayor que cero, termina el destino. Trunca cuando es necesario y devuelve la longitud completa del origen, que se puede comparar con size para detectar el truncamiento. No está disponible en todos los entornos: comprueba que el núcleo y la cadena de herramientas de Arduino seleccionados proporcionen strlcpy() antes de usarla. Si no la proporcionan, utiliza una rutina compatible o una estrategia de copia con el tamaño calculado cuidadosamente.
Copiar la entrada de Serial en un arreglo de caracteres
Este sketch lee como máximo 31 bytes en un arreglo de entrada de 32 bytes, escribe un terminador en la posición indicada por la cantidad de bytes devuelta, copia la cadena C resultante en otro destino de 32 bytes y la imprime. En una placa, usa la API Serial de Arduino. En la ejecución para el entorno anfitrión que aparece a continuación, un sustituto sencillo proporciona la línea de ejemplo Hello World, para que la lógica de copia pueda ejecutarse sin hardware. La cadena de ejemplo permanece en inglés en el código y la salida.
#include <cstddef>
#include <cstring>
#ifndef ARDUINO
#include <iostream>
struct SerialPort {
void begin(unsigned long) {}
void setTimeout(unsigned long) {}
void println(const char* value) { std::cout << value << '\n'; }
std::size_t readBytesUntil(char delimiter, char* buffer, std::size_t capacity) {
const char sample[] = "Hello World";
std::size_t count = 0;
while (count < capacity && sample[count] != '\0' && sample[count] != delimiter) {
buffer[count] = sample[count];
++count;
}
return count;
}
} Serial;
#endif
const std::size_t INPUT_CAPACITY = 32;
char inputBuffer[INPUT_CAPACITY];
char destination[INPUT_CAPACITY];
void setup() {
Serial.begin(9600);
Serial.setTimeout(1000);
Serial.println("Enter a line:");
std::size_t bytesRead = Serial.readBytesUntil('\n', inputBuffer, INPUT_CAPACITY - 1);
inputBuffer[bytesRead] = '\0';
std::strcpy(destination, inputBuffer);
Serial.println(destination);
}
void loop() {
// This one-shot input example runs once in setup().
}
#ifndef ARDUINO
int main() {
setup();
return 0;
}
#endif
Enter a line:
Hello World
readBytesUntil() se detiene al leer \n, cuando vence el tiempo de espera de 1000 ms o después de leer 31 bytes. El recuento size_t devuelto es como máximo 31, por lo que asignar inputBuffer[bytesRead] = '\0' no sale del arreglo de 32 bytes; el destino tiene la misma capacidad y puede contener los bytes copiados y el terminador. Si una línea alcanza el límite de 31 bytes antes del salto de línea, el resto puede quedar disponible para una lectura posterior. El tiempo de espera también puede devolver una línea parcial. Cuando se encuentra, el delimitador de salto de línea se consume, pero este código no elimina un \r anterior, que podría aparecer al final de la cadena impresa; quítalo explícitamente si la aplicación lo requiere.
Elegir una función de copia y comprobar la capacidad del búfer
Antes de copiar, identifica si el valor es un String de Arduino o un arreglo de caracteres terminado en nulo. Para las cadenas C, calcula la capacidad en bytes e incluye un byte para \0; en texto UTF-8, el número de caracteres y el de bytes pueden diferir. Usa strcpy() solo cuando sepas que la longitud completa del origen cabe en el destino. Usa strncpy() únicamente si tienes un plan explícito para la terminación y el relleno; otra opción es strlcpy() cuando el entorno de destino la proporcione, comprobando su valor de retorno para detectar truncamientos. Para los datos de Serial, limita la lectura a la capacidad del arreglo de entrada, termina la cadena en la posición indicada por el recuento devuelto y dimensiona cada destino posterior para que quepa la cadena resultante.