SDK Multiplataforma en C logo

SDK Multiplataforma en C

Strings

❮ Anterior
Siguiente ❯

Cadenas de caracteres en UTF-8, reservadas dinámicamente.


Funciones

const char_t*tc (...)
String*str_c (...)
String*str_cn (...)
String*str_trim (...)
String*str_trim_n (...)
String*str_copy (...)
String*str_printf (...)
String*str_path (...)
String*str_cpath (...)
String*str_relpath (...)
String*str_repl (...)
String*str_reserve (...)
String*str_fill (...)
String*str_read (...)
voidstr_write (...)
voidstr_writef (...)
voidstr_copy_c (...)
voidstr_copy_cn (...)
voidstr_cat (...)
voidstr_cat_c (...)
voidstr_upd (...)
voidstr_destroy (...)
voidstr_destopt (...)
uint32_tstr_len (...)
uint32_tstr_len_c (...)
uint32_tstr_nchars (...)
uint32_tstr_prefix (...)
bool_tstr_is_prefix (...)
intstr_scmp (...)
intstr_cmp (...)
intstr_cmp_c (...)
intstr_cmp_cn (...)
bool_tstr_empty (...)
bool_tstr_empty_c (...)
bool_tstr_equ (...)
bool_tstr_equ_c (...)
bool_tstr_equ_cn (...)
bool_tstr_equ_nocase (...)
bool_tstr_equ_end (...)
voidstr_upper (...)
voidstr_lower (...)
voidstr_upper_c (...)
voidstr_lower_c (...)
voidstr_subs (...)
voidstr_repl_c (...)
const char_t*str_str (...)
bool_tstr_split (...)
bool_tstr_split_trim (...)
voidstr_split_pathname (...)
voidstr_split_pathext (...)
const char_t*str_filename (...)
const char_t*str_filext (...)
uint32_tstr_find (...)
int8_tstr_to_i8 (...)
int16_tstr_to_i16 (...)
int32_tstr_to_i32 (...)
int64_tstr_to_i64 (...)
uint8_tstr_to_u8 (...)
uint16_tstr_to_u16 (...)
uint32_tstr_to_u32 (...)
uint64_tstr_to_u64 (...)
real32_tstr_to_r32 (...)
real64_tstr_to_r64 (...)

Los objetos String contienen cadenas de caracteres UTF-8 reservadas dinámicamente. A pesar que es posible insertar cadenas de texto directamente en el código fuente o acceder a ellas a través de los paquetes de recursos (respack_text), es habitual componer textos en tiempo de ejecución o almacenar datos volátites recibidos a través de algún canal de entrada (teclado, archivos, red, etc). El módulo strings.h ofrece soporte para trabajar con este tipo de objetos, así como funciones genéricas para la manipulación de textos.

Hay diferentes formas de componer cadenas UTF8, pero los dos constructores más utilizados son str_c para crear una copia de una cadena C y str_printf para componer una cadena a partir de varios campos, con el conocido formato de la función printf().

1
2
3
4
String *str1 = str_c("This a static char array.");
String *str2 = str_printf("Code: %s, Price %8.2f.", tc(product->code), product->price);
str1 = "This a static char array."
str2 = "Code: 456-34GH-JKL, Price   439.67."

En el caso que sea necesario crear textos más extensos a partir de bucles u otros condicionales, la forma más eficiente es crear un Stream y, posteriormente, obtener el String.

1
2
3
4
5
6
7
8
String *str;
Stream *stm = stm_memory(2048);
stm_printf(stm, "List of %d products\n", arrpt_size(products, Product));
arrpt_foreach(product, products, Product);
    stm_printf(stm, "Code: %s, Price %8.2f.\n", tc(product->code), product->price);
arrpt_end();
str = stm_str(stm);
stm_close(&stm);

tc ()

Devuelve la cadena C interna en formato UTF-8 contenida en el String.

const char_t*
tc(const String *str);
str

El objeto string.

Retorna

Puntero a la cadena C.


str_c ()

Crea un String a partir de una cadena C codificada en UTF-8.

String*
str_c(const char_t *str);
str

Cadena C UTF8 terminada en carácter nulo '\0'.

Retorna

El objeto string.


str_cn ()

Crea un String copiando los primeros n bytes de una cadena C.

String*
str_cn(const char_t *str,
       const uint32_t n);
str

Cadena C UTF8.

n

El número de bytes a copiar.

Retorna

El objeto string.

Observaciones

En cadenas UTF-8, el número de bytes no corresponde con el número de caracteres.


str_trim ()

Crea un String a partir de una cadena C recortando los espacios en blanco, tanto al principio como al final.

String*
str_trim(const char_t *str);
str

Cadena C UTF8 terminada en carácter nulo '\0'.

Retorna

El objeto string.


str_trim_n ()

Crea un String a partir a partir de los primeros n bytes de una cadena C recortando los espacios en blanco, tanto al principio como al final.

String*
str_trim_n(const char_t *str,
           const uint32_t n);
str

Cadena C UTF8.

n

El número de bytes a considerar de la cadena original. La copia puede contener 'n' o menos bytes, según la cantidad de blancos.

Retorna

El objeto string.


str_copy ()

Crea un copia exacta del String.

String*
str_copy(const String *str);
str

El objeto string original.

Retorna

El objeto string copiado.

Observaciones

Los Strings son un tipo especial de objeto mutable. Copiar implica crear un nuevo objeto y no incrementar un contador de referencias.


str_printf ()

Compone un String desde varios campos, utilizando el formato del printf.

String*
str_printf(const char_t *format,
           ...);
format

Cadena con el formato tipo-printf con un número variable de parámetros.

...

Argumentos o variables del printf.

Retorna

El objeto string.

Observaciones

El uso de esta función previene vulnerabilidades del tipo buffer overflow, asociadas a las clásicas funciones C como strcpy.


str_path ()

Igual que str_printf, pero considera que la cadena es un pathname y, por tanto, utiliza el separador conveniente según platform.

String*
str_path(const platform_t platform,
         const char_t *format,
         ...);
1
2
String *path = str_path(ekWINDOWS, "/%s/img/%s.png", tc(product->category), tc(product->name));
path = "\\camera\\img\\sony_a5000.png"
platform

Plataforma para la que se crea el pathname.

format

Cadena con el formato tipo-printf con un número variable de parámetros.

...

Argumentos o variables del printf.

Retorna

El objeto string.


str_cpath ()

Igual que str_path, pero considerando la plataforma donde está corriendo el programa.

String*
str_cpath(const char_t *format,
          ...);
1
2
3
String *path = str_cpath("/%s/img/%s.png", tc(product->category), tc(product->name));
path = "\\camera\\img\\sony_a5000.png"  // In Windows
path = "/camera/img/sony_a5000.png"     // In Unix-like
format

Cadena con el formato tipo-printf con un número variable de parámetros.

...

Argumentos o variables del printf.

Retorna

El objeto string.


str_relpath ()

Calcula la ruta relativa a path1 para llegar a path2.

String*
str_relpath(const char_t *path1,
            const char_t *path2);
path1

La ruta de origen.

path2

La ruta de destino.

Retorna

El objeto string que contiene la ruta relativa.


str_repl ()

Crea un String reemplazando un número indeterminado de sub-cadenas. El primer parámetro es la cadena original. Los siguiente pares indican la sub-cadena a buscar y la sub-cadena que debe sustituirla. El último parámetro debe ser 0.

String*
str_repl(const char_t *str,
         ...);
1
2
String *str = str_repl("const Product **pr;", "const", "", "*", "", " ", "", 0);
str = "Productpr;"
str

Cadena original C UTF8 terminada en carácter nulo '\0'.

...

Número de parámetros variable, por pares. El primer elemento del par indica la sub-cadena a buscar en str. El segundo elemento la sustituta.

Retorna

El objeto string.


str_reserve ()

Crea un String con n+1 bytes, pero sin asignarle ningún contenido.

String*
str_reserve(const uint32_t n);
n

Número de bytes. Reserva espacio para uno más (el '\n').

Retorna

El objeto string. Su contenido será indeterminado (basura). Debe escribirse posteriormente.


str_fill ()

Crea un String repitiendo n veces un mismo carácter.

String*
str_fill(const uint32_t n,
         const char_t c);
n

Número de caracteres.

c

Carácter patrón.

Retorna

El objeto string.


str_read ()

Crea un String leyendo su contenido de un Stream (de-serialización). El String ha debido ser escrito previamente por str_write.

String*
str_read(Stream *stream);
stream

Un stream de lectura.

Retorna

El objeto string.

Observaciones

Es una operación binaria. El tamaño del string se deserializa primero.


str_write ()

Escribe un string en un Streams (serialización).

void
str_write(Stream *stream,
          String *str);
stream

Un stream de escritura.

str

El objeto string.

Observaciones

Es una operación binaria. El tamaño del string se serializa primero. Utiliza str_writef para escribir solo el texto.


str_writef ()

Escribe en un Streams la cadena C contenida en el string.

void
str_writef(Stream *stream,
           String *str);
stream

Un stream de escritura.

str

El objeto string.

Observaciones

Escribe únicamente el texto del string, sin el carácter nulo '\0' final. Es equivalente a stm_writef(stream, tc(str)); pero más eficiente, ya que no hay que calcular el tamaño de str.


str_copy_c ()

Copia la cadena C src en el búfer apuntado por dest, incluyendo el carácter nulo '\0'.

void
str_copy_c(char_t *dest,
           const uint32_t size,
           const char_t *str);
dest

Búfer de destino.

size

Tamaño en bytes de dest.

str

Cadena C UTF8 terminada en carácter nulo '\0'.

Observaciones

Es una operación segura. No se escribirán en dest más de size bytes y nunca se truncará un carácter. dest siempre acabará con el carácter nulo '\0'.


str_copy_cn ()

Copia en dest un máximo de n bytes de la cadena C UTF8 apuntada por src, incluyendo el carácter nulo '\0'.

void
str_copy_cn(char_t *dest,
            const uint32_t size,
            const char_t *str,
            const uint32_t n);
dest

Búfer de destino.

size

Tamaño en bytes de dest.

str

Cadena C UTF8.

n

Máximo número de bytes a copiar en dest.

Observaciones

Es una operación segura. No se escribirán en dest más de n bytes y nunca se truncará un carácter. dest siempre acabará con el carácter nulo '\0'.


str_cat ()

Concatena dinámicamente el contenido de src en dest.

void
str_cat(String **dest,
        const char_t *src);
**dest

Objeto string de origen y destino.

src

Cadena C UTF8 a concatenar.

Observaciones

Esta operación implica reasignar memoria dinámica. Para componer textos largos es más eficiente utilizar Stream.


str_cat_c ()

Concatena el contenido de src en dest. El carácter nulo en dest será sobrescrito por el primer carácter de src.

void
str_cat_c(char_t *dest,
          const uint32_t size,
          const char_t *src);
dest

Cadena C UTF8 de origen y destino.

size

Tamaño en bytes de dest.

src

Cadena C UTF8 a concatenar.

Observaciones

Es una operación segura. No se escribirán en dest más de size bytes y nunca se truncará un carácter. dest siempre acabará con el carácter nulo '\0'.


str_upd ()

Cambia el contenido de un string por otro.

void
str_upd(String **str,
        const char_t *new_str);
1
2
3
4
5
6
// Equivalent code
String *str = ..original content..
String *temp = str_c(new_str);
str_destroy(&str);
str = temp;
temp = NULL;
str

Objeto string destino. El contenido original será borrado.

new_str

Cadena C UTF8 que sustituirá a la original.


str_destroy ()

Destruye un objeto string.

void
str_destroy(String **str);
str

El objeto string. Será puesto a NULL tras la destrucción.


str_destopt ()

Destruye un objeto string si su contenido no es NULL (destructor opcional).

void
str_destopt(String **str);
str

El objeto string. Será puesto a NULL tras la destrucción.


str_len ()

Retorna el tamaño en bytes de un string.

uint32_t
str_len(const String *str);
str

Objeto string.

Retorna

El número de bytes, sin incluir el carácter nulo '\0'.

Observaciones

En cadenas UTF-8 el número de bytes no es el mismo que el caracteres. str_nchars.


str_len_c ()

Retorna el tamaño en bytes de una cadena C UTF8.

uint32_t
str_len_c(const char_t *str);
str

Cadena C UTF8 terminada en carácter nulo '\0'.

Retorna

El número de bytes, sin incluir el carácter nulo '\0'.

Observaciones

En cadenas UTF-8 el número de bytes no es el mismo que el caracteres. unicode_nchars.


str_nchars ()

Retorna el número de caracteres de un objeto string.

uint32_t
str_nchars(const String *str);
str

Objeto string.

Retorna

El número de caracteres, sin incluir el carácter nulo '\0'.

Observaciones

En cadenas UTF-8 el número de bytes no es el mismo que el caracteres.


str_prefix ()

Localiza el inicio común de dos cadenas.

uint32_t
str_prefix(const char_t *str1,
           const char_t *str2);
str1

Primera cadena C UTF8 terminada en carácter nulo '\0'.

str2

Segunda cadena C UTF8 terminada en carácter nulo '\0'.

Retorna

El número de bytes que son idénticos al comienzo de ambas cadenas.


str_is_prefix ()

Comprueba si una cadena es prefijo de otra.

bool_t
str_is_prefix(const char_t *str,
              const char_t *prefix);
str

Cadena C UTF8 terminada en carácter nulo '\0'.

prefix

Prefijo de str terminado en carácter nulo '\0'.

Retorna

TRUE si preffix es prefijo de str.


str_scmp ()

Compara alfabéticamente dos strings.

int
str_scmp(const String *str1,
         const String *str2);
str1

Primer string.

str2

Segundo string.

Retorna

Resultado de la comparación.


str_cmp ()

Compara alfabéticamente un string con una cadena C UTF8.

int
str_cmp(const String *str1,
        const char_t *str2);
str1

Objeto string.

str2

Cadena C UTF8 terminada en carácter nulo '\0'.

Retorna

Resultado de la comparación.


str_cmp_c ()

Compara alfabéticamente dos cadenas C UTF8 terminadas en carácter nulo '\0'.

int
str_cmp_c(const char_t *str1,
          const char_t *str2);
str1

Primera cadena C UTF8.

str2

Segunda cadena C UTF8.

Retorna

Resultado de la comparación.


str_cmp_cn ()

Compara alfabéticamente los primeros n bytes de dos cadenas C UTF8 terminadas en carácter nulo '\0'.

int
str_cmp_cn(const char_t *str1,
           const char_t *str2,
           const uint32_t n);
str1

Primera cadena C UTF8.

str2

Segunda cadena C UTF8.

n

Máximo número de bytes a comparar.

Retorna

Resultado de la comparación.

Observaciones

Es una operación segura. Si alguna de las dos cadenas llega al final antes de llegar a n bytes, la comparación termina.


str_empty ()

Comprueba si un string está vacío (str->data[0] == '\0').

bool_t
str_empty(const String *str);
str

Objeto string.

Retorna

TRUE si está vacío o es NULL.


str_empty_c ()

Comprueba si una cadena C UTF8 está vacía (str[0] == '\0').

bool_t
str_empty_c(const char_t *str);
str

Cadena C UTF8.

Retorna

TRUE si está vacía o es NULL.


str_equ ()

Comprueba si el contenido de un string es igual a una cadena C.

bool_t
str_equ(const String *str1,
        const char_t *str2);
str1

Objeto string.

str2

Cadena C UTF8 terminada en carácter nulo '\0'.

Retorna

TRUE si son iguales.


str_equ_c ()

Comprueba si dos cadenas C UTF8 son iguales.

bool_t
str_equ_c(const char_t *str1,
          const char_t *str2);
str1

Primera cadena C UTF8 acabada en carácter nulo '\0'.

str2

Segunda cadena C UTF8 acabada en carácter nulo '\0'.

Retorna

TRUE si son iguales.


str_equ_cn ()

Comprueba si los primeros bytes de dos cadenas C UTF8 son iguales.

bool_t
str_equ_cn(const char_t *str1,
           const char_t *str2,
           const uint32_t n);
str1

Primera cadena C UTF8 acabada en carácter nulo '\0'.

str2

Segunda cadena C UTF8 acabada en carácter nulo '\0'.

n

Primeros 'n' bytes a comparar.

Retorna

TRUE si son iguales.

Observaciones

Si se alcanza '\0' en alguna de las dos cadenas, se devolverá TRUE.


str_equ_nocase ()

Comprueba si dos cadenas C UTF8 son iguales, ignorando mayúsculas o minúsculas.

bool_t
str_equ_nocase(const char_t *str1,
               const char_t *str2);
str1

Primera cadena C UTF8 acabada en carácter nulo '\0'.

str2

Segunda cadena C UTF8 acabada en carácter nulo '\0'.

Retorna

TRUE si son iguales.

Observaciones

Solo se consideran caracteres US-ASCII (0-127).


str_equ_end ()

Comprueba la terminación de una cadena.

bool_t
str_equ_end(const char_t *str,
            const char_t *end);
str

Cadena C UTF8 acabada en carácter nulo '\0'.

end

Cadena C UTF8 con la terminación.

Retorna

TRUE si str acaba en end.


str_upper ()

Cambia los letras minúsculas por mayúsculas.

void
str_upper(String *str);
str

Objeto string.

Observaciones

Solo se consideran caracteres US-ASCII (0-127). La cadena original cambiará, pero no los requisitos de memoria.


str_lower ()

Cambia los letras mayúsculas por minúsculas.

void
str_lower(String *str);
str

Objeto string.

Observaciones

Solo se consideran caracteres US-ASCII (0-127). La cadena original cambiará, pero no los requisitos de memoria.


str_upper_c ()

Convierte una cadena a mayúsculas.

void
str_upper_c(char_t *dest,
            const uint32_t size,
            const char_t *str);
dest

Búfer destino.

size

Tamaño en bytes del búfer destino.

str

Cadena C UTF8 acabada en carácter nulo '\0'.

Observaciones

Solo se consideran caracteres US-ASCII (0-127).


str_lower_c ()

Convierte una cadena a minúsculas.

void
str_lower_c(char_t *dest,
            const uint32_t size,
            const char_t *str);
dest

Búfer destino.

size

Tamaño en bytes del búfer destino.

str

Cadena C UTF8 acabada en carácter nulo '\0'.

Observaciones

Solo se consideran caracteres US-ASCII (0-127).


str_subs ()

Cambia todas las instancias de un carácter por otro.

void
str_subs(String *str,
         const char_t replace,
         const char_t with);
1
2
3
4
String *str = str_c("customer.service.company.com");
str_subs(str, '.', '_');
str_uppercase(str);
str="CUSTOMER_SERVICE_COMPANY_COM"
str

Objeto string.

replace

Carácter a reemplazar.

with

Carácter de reemplazo.

Observaciones

Solo se consideran caracteres US-ASCII (0-127). La cadena original cambiará, pero no los requisitos de memoria.


str_repl_c ()

Cambia todas las instancias de una subcadena por otra.

void
str_repl_c(String *str,
           const char_t *replace,
           const char_t *with);
str

Objeto string.

replace

Subcadena a reemplazar.

with

Subcadena de reemplazo.

Observaciones

Las subcadenas replace y with deben tener el mismo tamaño, de lo contrario se producirá un Asserts. Utiliza str_repl para el caso general.


str_str ()

Busca una subcadena dentro de otra de mayor tamaño.

const char_t*
str_str(const char_t *str,
        const char_t *substr);
str

Cadena C UTF8 acabada en carácter nulo '\0'.

substr

Subcadena a buscar acabada en carácter nulo '\0'.

Retorna

Puntero a la primera ocurrencia de substr en str o NULL si no existe ninguna.


str_split ()

Divide una cadena en dos, utilizando la primera ocurrencia de una subcadena.

bool_t
str_split(const char_t *str,
          const char_t *substr,
          String **left,
          String **right);
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
const char_t *str = "one::two";
String *str1, *str2, *str3;
bool_t ok1, ok2;
ok1 = str_split(str, "::", &str1, &str2);
ok2 = str_split(tc(str1), "::", NULL, &str3);
str1 = "one"
str2 = "two"
str3 = ""
ok1 = TRUE
ok2 = FALSE
str

Cadena C UTF8 acabada en carácter nulo '\0'.

substr

Subcadena a buscar.

left

Subcadena izquierda. Será igual a str si substr no existe. El parámetro puede ser NULL si no es necesario.

right

Subcadena derecha. Será igual a "" si substr no existe. El parámetro puede ser NULL si no es necesario.

Retorna

TRUE si substr existe en str.


str_split_trim ()

Igual que str_split pero eliminando todos los espacios en blanco al principio y final de left y right.

bool_t
str_split_trim(const char_t *str,
               const char_t *substr,
               String **left,
               String **right);
str

Cadena C UTF8 acabada en carácter nulo '\0'.

substr

Subcadena a buscar.

left

Subcadena izquierda.

right

Subcadena derecha.

Retorna

TRUE si substr existe en str.


str_split_pathname ()

Divide un pathname en path y file Filename y pathname.

void
str_split_pathname(const char_t *pathname,
                   String **path,
                   String **file);
1
2
3
4
5
6
String *path, *name, *name2;
str_split_pathname("C:\\Users\\john\\Desktop\\image.png", &path, &name);
str_split_pathname(tc(path), NULL, name2);
path = "C:\\Users\\john\\Desktop"
name = "image.png"
name2 = "Desktop"
pathname

Pathname de entrada.

path

Ruta de directorios. El parámetro puede ser NULL si no es necesario.

file

Nombre de archivo o directorio final. El parámetro puede ser NULL si no es necesario.


str_split_pathext ()

Igual que str_split_pathname pero extrayendo también la extensión del archivo.

void
str_split_pathext(const char_t *pathname,
                  String **path,
                  String **file,
                  String **ext);
1
2
3
4
5
String *path, *name, *ext;
str_split_pathext("C:\\Users\\john\\Desktop\\image.png", &path, &name, &ext);
path = "C:\\Users\\john\\Desktop"
name = "image"
ext = "png"
pathname

Pathname de entrada.

path

Parte path de la ruta.

file

Parte file de la ruta.

ext

Extensión del archivo.


str_filename ()

Retorna la parte final de un pathname. Filename y pathname.

const char_t*
str_filename(const char_t *pathname);
1
2
const char_t *name = str_filename("C:\\Users\\john\\Desktop\\image.png");
name = "image.png"
pathname

Pathname de entrada.

Retorna

El último tramo de una ruta de directorios.


str_filext ()

Retorna la extensión del archivo, a partir de un pathname. Filename y pathname.

const char_t*
str_filext(const char_t *pathname);
1
2
const char_t *ext = str_fileext("C:\\Users\\john\\Desktop\\image.png");
ext = "png"
pathname

Pathname de entrada.

Retorna

La extensión del archivo.


str_find ()

Busca una cadena en un array.

uint32_t
str_find(const ArrPt(String) *array,
         const char_t *str);
array

El array.

str

La cadena a buscar.

Retorna

La posición de la cadena o UINT32_MAX si no existe.


str_to_i8 ()

Convierte una cadena de texto en un entero.

int8_t
str_to_i8(const char_t *str,
          const uint32_t base,
          bool_t *error);
str

Cadena de texto, terminada en carácter nulo '\0'.

base

Base numérica: 8 (octal), 10 (decimal), 16 (hexadecimal).

error

Obtiene TRUE si hay algún error en la conversión. Puede ser NULL.

Retorna

El valor numérico.

Observaciones

Si la cadena es errónea o el valor está fuera de rango, devuelve 0 con error=TRUE.


str_to_i16 ()

Convierte una cadena de texto en un entero.

int16_t
str_to_i16(const char_t *str,
           const uint32_t base,
           bool_t *error);
str

Cadena de texto, terminada en carácter nulo '\0'.

base

Base numérica: 8 (octal), 10 (decimal), 16 (hexadecimal).

error

Obtiene TRUE si hay algún error en la conversión. Puede ser NULL.

Retorna

El valor numérico.

Observaciones

Si la cadena es errónea o el valor está fuera de rango, devuelve 0 con error=TRUE.


str_to_i32 ()

Convierte una cadena de texto en un entero.

int32_t
str_to_i32(const char_t *str,
           const uint32_t base,
           bool_t *error);
str

Cadena de texto, terminada en carácter nulo '\0'.

base

Base numérica: 8 (octal), 10 (decimal), 16 (hexadecimal).

error

Obtiene TRUE si hay algún error en la conversión. Puede ser NULL.

Retorna

El valor numérico.

Observaciones

Si la cadena es errónea o el valor está fuera de rango, devuelve 0 con error=TRUE.


str_to_i64 ()

Convierte una cadena de texto en un entero.

int64_t
str_to_i64(const char_t *str,
           const uint32_t base,
           bool_t *error);
str

Cadena de texto, terminada en carácter nulo '\0'.

base

Base numérica: 8 (octal), 10 (decimal), 16 (hexadecimal).

error

Obtiene TRUE si hay algún error en la conversión. Puede ser NULL.

Retorna

El valor numérico.

Observaciones

Si la cadena es errónea o el valor está fuera de rango, devuelve 0 con error=TRUE.


str_to_u8 ()

Convierte una cadena de texto en un entero.

uint8_t
str_to_u8(const char_t *str,
          const uint32_t base,
          bool_t *error);
str

Cadena de texto, terminada en carácter nulo '\0'.

base

Base numérica: 8 (octal), 10 (decimal), 16 (hexadecimal).

error

Obtiene TRUE si hay algún error en la conversión. Puede ser NULL.

Retorna

El valor numérico.

Observaciones

Si la cadena es errónea o el valor está fuera de rango, devuelve 0 con error=TRUE.


str_to_u16 ()

Convierte una cadena de texto en un entero.

uint16_t
str_to_u16(const char_t *str,
           const uint32_t base,
           bool_t *error);
str

Cadena de texto, terminada en carácter nulo '\0'.

base

Base numérica: 8 (octal), 10 (decimal), 16 (hexadecimal).

error

Obtiene TRUE si hay algún error en la conversión. Puede ser NULL.

Retorna

El valor numérico.

Observaciones

Si la cadena es errónea o el valor está fuera de rango, devuelve 0 con error=TRUE.


str_to_u32 ()

Convierte una cadena de texto en un entero.

uint32_t
str_to_u32(const char_t *str,
           const uint32_t base,
           bool_t *error);
str

Cadena de texto, terminada en carácter nulo '\0'.

base

Base numérica: 8 (octal), 10 (decimal), 16 (hexadecimal).

error

Obtiene TRUE si hay algún error en la conversión. Puede ser NULL.

Retorna

El valor numérico.

Observaciones

Si la cadena es errónea o el valor está fuera de rango, devuelve 0 con error=TRUE.


str_to_u64 ()

Convierte una cadena de texto en un entero.

uint64_t
str_to_u64(const char_t *str,
           const uint32_t base,
           bool_t *error);
str

Cadena de texto, terminada en carácter nulo '\0'.

base

Base numérica: 8 (octal), 10 (decimal), 16 (hexadecimal).

error

Obtiene TRUE si hay algún error en la conversión. Puede ser NULL.

Retorna

El valor numérico.

Observaciones

Si la cadena es errónea o el valor está fuera de rango, devuelve 0 con error=TRUE.


str_to_r32 ()

Convierte una cadena de texto en un real.

real32_t
str_to_r32(const char_t *str,
           bool_t *error);
str

Cadena de texto, terminada en carácter nulo '\0'.

error

Obtiene TRUE si hay algún error en la conversión. Puede ser NULL.

Retorna

El valor numérico.

Observaciones

Si la cadena es errónea o el valor está fuera de rango, devuelve 0.0 con error=TRUE.


str_to_r64 ()

Convierte una cadena de texto en un real.

real64_t
str_to_r64(const char_t *str,
           bool_t *error);
str

Cadena de texto, terminada en carácter nulo '\0'.

error

Obtiene TRUE si hay algún error en la conversión. Puede ser NULL.

Retorna

El valor numérico.

Observaciones

Si la cadena es errónea o el valor está fuera de rango, devuelve 0.0 con error=TRUE.

❮ Anterior
Siguiente ❯