Skip to content

vittoric/Libft

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Repository files navigation

Libft - Primer proyecto como estudiante de 42Madrid 🚀

Contenido


¿Que es libft?

Programar en C puede ser aburrido cuando uno no tiene acceso a las funciones comunes más utilizadas. Libft es un proyecto individual en 42 que nos hace a recrear algunas funciones de la biblioteca C estándar para futuros proyectos y tener una comprensión más profunda de las estructuras de datos y los algoritmos básicos. Este proyecto permite entender la forma en la que estas funciones operan, cómo implementarlas y aprender a utilizarlas. En 42 no se nos permite usar algunas bibliotecas estándar en nuestros proyectos, por lo que tenemos que crear una librería propia, que será muy útil ya que la utilizaremos en los siguientes proyectos de C.


¿En que consiste?

Hay 4 secciones:

  1. Funciones de Libc: Algunas de las funciones estándar de C
  2. Funciones adicionales: Funciones que serán útiles para proyectos posteriores
  3. Parte bonus: funciones que serán útiles para la manipulación de listas
  4. Funciones personales: Funciones que creo que serán útiles más adelante

¿Que es Makefile y como hacerlo?

Un archivo del tipo makefile es un archivo que hace uso de la utilidad make. Esta utilidad determina que partes de un programa deben de compilarse, y les manda comandos para hacerlo. En esencia, un makefile sirve para autocompilar un proyecto en lugar de hacerlo manualmente.

Para poder hacer uso de make, en primer lugar debe crearse un archivo del tipo makefile. Para ello basta con crear uno con nombre "makefile" o "Makefile". Ambos nombres son completamente válidos (el manual de la GNU recomienda usar el segundo, puesto que suele aparecer cerca del inicio en los listados de directorios, junto otros arhcivos importantes como README).

En estos apuntes voy a explicar, en particular, el Makefile que he hecho para el proyecto libft.

Aqui os dejo un link a stackoverflow del tutorial de las mejores prácticas y trucos para hacer un buen makefile


Lista de funcciones


Funciones de Libc Funciones adicionales Parte bonus Funciones personales
ft_isalpha ft_substr ft_lstnew ft_islower
ft_isdigit ft_strjoin ft_lstadd_front ft_isupper
ft_isalnum ft_strtrim ft_lstsize ft_isspace
ft_isascii ft_split ft_lstlast
ft_isprint ft_itoa ft_lstadd_back
ft_strlen ft_strmapi ft_lstdelone
ft_memset ft_putchar_fd ft_lstclear
ft_bzero ft_putstr_fd ft_lstiter
ft_memcpy ft_putendl_fd ft_lstmap
ft_memmove ft_putnbr_fd
ft_strlcpy ft_striteri
ft_strlcat
ft_tolower
ft_toupper
ft_strchr
ft_strrchr
ft_strncmp
ft_memchr
ft_memcmp
ft_strnstr
ft_atoi

int ft_isalpha(int c)

Descripción Param. #1 Return Value
Busca un carácter alfabético, es equivalente a(ft_isupper(c) o ft_islower(c)) El caracter a buscar 0 si el carácter resulta falso y 1 si el carácter resulta verdadero

int ft_isdigit(int c)

Descripción Param. #1 Return Value
Busca un dígito (de 0 a 9) El caracter a buscar 0 si el carácter resulta falso y 1 si el carácter resulta verdadero

int ft_isalnum(int c)

Descripción Param. #1 Return Value
Compruebe si hay un carácter alfanumérico, es equivalente a(ft_isalpha oft_isdigit) El caracter a buscar 0 si el carácter resulta falso y 1 si el carácter resulta verdadero

int ft_isascii(int c)

Descripción Param. #1 Return Value
Comprueba un carácter ASCII, que es cualquier carácter entre 0 y 127 inclusive El caracter a buscar 0 si el carácter resulta falso y 1 si el carácter resulta verdadero

int ft_isprint(int c)

Descripción Param. #1 Return Value
Comprueba cualquier carácter imprimible, incluido el espacio El caracter a buscar 0 si el carácter resulta falso y 1 si el carácter resulta verdadero

size_t ft_strlen(const char *str)

Descripción Param. #1 Return Values
Calcula la longitud de la cadena apuntada por str, excluyendo el byte nulo de terminación ('\0') Es la cadena de la que vamos a encontrar la longitud La longitud de la cadena

void *ft_memset(void *ptr, int x, size_t n)

Descripción Param. #1 Param. #2 Param. #3 Return Value
Rellena con "n" bytes de "x" la memoria de "ptr" *ptr es el puntero al área de memoria que se va a llenar El valor x (convertido a unsigned char) a establecer El número de bytes que se establecerá en el valor x Un puntero al área de memoria s

void ft_bzero(void *s, size_t n)

Descripción Param. #1 Param. #2 Return Value
Borra los datos en los "n" bytes de la memoria comenzando en la ubicación señalada por "s" escribiendo ceros El puntero al área de memoria que se va a rellenar El número de bytes Nada

void *ft_memcpy(void *dst, const void *src, size_t n)

Descripción Param. #1 Param. #2 Param. #3 Return Value
Copia n bytes del área de memoria src a la memoria de dst. Las áreas de memoria no deben superponerse. Usa ft_memmove si las áreas de memoria se superponen Área de memoria dst La cadena de origen El número de bytes a copiar Un puntero a la cadena de destino

void *ft_memmove(void *dst, const void *src, size_t len)

Descripción Param. #1 Param. #2 Param. #3 Return Value
Copia len bytes de la memoria de src a dst. La memoria pueden superponerse. Primero, los bytes en src se copian en una matriz temporal y luego en dst Esta es la matriz de destino donde se copiará el contenido, convertido a un puntero La cadena de origen El número de bytes Un puntero a la cadena de destino

size_t ft_strlcpy(char *dst, const char *src, size_t dstsize)

Descripción Param. #1 Param. #2 Param. #3 Return Value
Copia la cadena a la que apunta src, incluido el byte nulo de terminación ('\0'), al búfer señalado por dst La cadena de destino La cadena que se va a copiar Número de caracteres que se copiarán de src Longitud total de la cadena a crear (longitud de src)

size_t ft_strlcat(char *dest, const char *src, size_t dstsize)

Descripción Param. #1 Param. #2 Param. #3 Return Value
Concatena la cadena src al final de dst. Se concatenará al máximo tamaño - strlen (dst) - 1 bytes, terminando en NULL el resultado La cadena de destino Cadena que se agregará a dst Número máximo de caracteres que se agregarán La longitud de la cadena que intentó crear en dest

int ft_tolower(int c)

Descripción Param. #1 Return Value
Si el carácter pasado como argumento es una mayúscula, conviértalo a minúscula El caracter a convertir Si c es una letra mayúscula, devuelve su equivalente en minúscula. De lo contrario, devuelve c

int ft_toupper(int c)

Descripción Param. #1 Return Value
Si el carácter pasado como argumento es una minúscula, conviértalo a mayúscula El caracter a convertir Si c es una letra minúscula, devuelve su equivalente en mayúscula. De lo contrario, devuelve c

char *ft_strchr(const char *s, int c)

Descripción Param. #1 Param. #2 Return Value
Localiza la primera aparición de 'c' en la cadena a la que apunta 's'. El carácter nulo final se considera parte de la cadena, por lo tanto, si 'c' es '\0', ubica el final '\0' Puntero a string Caracter a buscar Un puntero a la primera aparición del carácter c en la cadena s o NULL si no se encuentra el carácter

char *ft_strrchr(const char *s, int c)

Descripción Param. #1 Param. #2 Return Value
Localiza la última aparición de 'c' en la cadena a la que apunta 's'. El carácter nulo final se considera parte de la cadena, por lo tanto, si 'c' es '\0', ubica el final '\0' Puntero a string Caracter a buscar Un puntero a la última aparición del carácter c en la cadena s o NULL si no se encuentra el carácter

int ft_strncmp(const char *s1, const char *s2, size_t n)

Descripción Param. #1 Param. #2 Param. #3 Return Value
Compara los primeros n caracteres de las cadenas s1 y s2 La primera cadena que se va a comparar La cadena para comparar El número máximo de caracteres para comparar La diferencia entre los dos primeros caracteres que difieren en el cadenas que se comparan

void *ft_memchr(const void *s, int c, size_t n)

Descripción Param. #1 Param. #2 Param. #3 Return Value
Localiza la primera ocurrencia de c (convertida a unsigned char) en la cadena s La cadena a buscar Caracter a buscar El número de bytes a buscar Un puntero al byte localizado, o NULL si tal byte no existe dentro de n bytes

int ft_memcmp(const void *s1, const void *s2, size_t n)

Descripción Param. #1 Param. #2 Param. #3 Return Value
Compara los primeros n bytes del área de memoria s1 a los primeros n bytes del área de memoria s2 La primera cadena a comparar La cadena a comparar El número de bytes a comparar < 0 si s1 es menor que s2; > 0 si s1 es mayor que s2; = 0 si s1 es igual a s2

char *ft_strnstr(const char *haystack, const char *needle, size_t len)

Description Param. #1 Param. #2 Param. #3 Return Value
Ubiqua la subcadena, donde no se buscan más de los caracteres 'len'. Busca la primera aparición de la subcadena 'needle' en la cadena 'haystack'. Los bytes nulos finales ('\0') no se comparan. La cadena a buscar La cadena que se buscará en la cadena 'haystack' La cantidad máxima de caracteres a buscar Un puntero a la primera aparición de subcadena 'needle' en el 'haystack'. NULL si no se encuentra la subcadena. Si 'needle' es una cadena vacía, se devuelve 'haystack'

int ft_atoi(const char *str)

Description Param. #1
Esta es una función de C que convierte una representación de cadena de un número entero en un valor entero. La función toma un solo argumento, un puntero a una cadena terminada en nulo (const char *str). La función procesa la cadena de izquierda a derecha y devuelve el valor entero representado por la cadena. La función primero inicializa el resultado (res) en 0 y el signo (signo) en 1. Luego omite cualquier carácter de espacio en blanco inicial (espacios, tabuladores, líneas nuevas, etc.) en la cadena mediante un ciclo while que continúa mientras el carácter actual (señalado por str) es un espacio o un carácter no imprimible (valores ASCII de 9 a 13). A continuación, la función comprueba el primer carácter que no sea un espacio en blanco. Si es un signo menos ('-'), el signo se establece en -1. Si es un signo más ('+'), el signo se deja como 1. Si no es ni un signo más ni un signo menos, el signo permanece 1. Finalmente, la función ingresa a un ciclo que procesa los caracteres restantes en la cadena hasta que encuentra un carácter que no es un dígito (0 a 9). Para cada dígito, la función multiplica el resultado actual por 10 y suma el valor del dígito. Cuando finaliza el bucle, la función devuelve el resultado multiplicado por el signo. Por ejemplo, si se llama a la función con la cadena "-12345", omitirá los caracteres de espacio en blanco iniciales, establecerá el signo en -1 y procesará los dígitos 1, 2, 3, 4 y 5, lo que dará como resultado un resultado final. valor de retorno de -12345. Esta es la cadena que estamos convirtiendo en un número entero.

char *ft_substr(char const *s, unsigned int start, size_t len)

Description Param. #1 Param. #2 Param. #3 Return Value
La función primero verifica si la cadena de entrada es NULL. Si es así, devuelve NULL. A continuación, comprueba si el índice de inicio es mayor que la longitud de la cadena original. Si es así, establece la longitud de la subcadena en 0. Luego, verifica si la longitud de la subcadena es mayor que la longitud de la cadena original. Si es así, establece la longitud de la subcadena en la longitud de la cadena original. Luego, la función asigna memoria para la subcadena usando malloc e inicializa una variable size_t (i) a 0. Luego ingresa a un ciclo que copia los caracteres de la cadena original a la subcadena, comenzando en el índice de inicio y siguiendo un número de iteraciones igual a la longitud de la subcadena. Una vez que finaliza el ciclo, la función agrega un terminador nulo al final de la subcadena y devuelve un puntero a la subcadena. Por ejemplo, si se llama a la función con la cadena "abcdefg", el índice de inicio 2 y la longitud 3, extraerá la subcadena "cde" de la cadena original y le devolverá un puntero. Un puntero a una cadena terminada en nulo (char const *s), que es la cadena original de la que se extraerá la subcadena. el índice del primer carácter a incluir en la subcadena la longitud de la subcadena Un puntero a una nueva cadena

char *ft_strjoin(char const *s1, char const *s2)

Description Param. #1 Param. #2 Return Value
La función primero verifica si ambas cadenas de entrada no son NULL. Si alguno de ellos es NULL, devuelve NULL. A continuación, calcula las longitudes de las dos cadenas de entrada mediante la función ft_strlen. Luego asigna memoria para la cadena concatenada usando malloc y verifica si la asignación fue exitosa. Si no fuera así, la función devuelve NULL. Luego, la función inicializa una variable int (i) a -1 e ingresa a un bucle que copia los caracteres de la primera cadena de entrada a la cadena concatenada, uno por uno. Una vez que finaliza el primer ciclo, la función restablece i en -1 e ingresa a otro ciclo que copia los caracteres de la segunda cadena de entrada a la cadena concatenada, comenzando al final de la primera cadena de entrada. Finalmente, la función agrega un terminador nulo al final de la cadena concatenada y le devuelve un puntero. Por ejemplo, si se llama a la función con las cadenas "abc" y "def", creará una nueva cadena "abcdef" y le devolverá un puntero. Nota: La función llama a la función ft_strlen, que calcula la longitud de una cadena terminada en nulo. Un puntero a una cadena terminada en cero (char const *s1), que es la primera cadena que se concatena Un puntero a una cadena terminada en nulo (char const *s2), que es la segunda cadena que se concatena. Un puntero a una nueva cadena que es el resultado de la concatenación de s1 y s2

char *ft_strtrim(char const *s1, char const *set)

Description Param. #1 Param. #2 Return Value
La función primero verifica si la cadena de entrada y el conjunto de caracteres no son NULL. Si alguno de ellos es NULL, devuelve NULL. A continuación, inicializa dos variables size_t: strat, que almacenará el índice del primer carácter no extraíble de la cadena, y end, que almacenará el índice del último carácter no extraíble de la cadena. Inicialmente, strat se establece en 0 y end se establece en la longitud de la cadena. Luego, la función ingresa a un bucle que incrementa start siempre que el carácter en el índice de start actual esté en el conjunto de caracteres que se eliminará. Después de que finaliza el primer ciclo, la función ingresa a otro ciclo que decrementa end siempre que el carácter en el índice final actual esté en el conjunto de caracteres que se eliminarán y end sea mayor que strat. Luego, la función asigna memoria para la cadena resultante usando malloc y verifica si la asignación fue exitosa. Si no fuera así, la función devuelve NULL. Finalmente, la función copia la subcadena de s1 que comienza en strat y tiene una longitud de (end - strat) a la cadena resultante usando ft_strlcpy. Luego devuelve un puntero a la cadena resultante. Por ejemplo, si se llama a la función con la cadena "abc" y el conjunto de caracteres "\t\n", creará una nueva cadena "abc" y le devolverá un puntero. Un puntero a una cadena terminada en nulo (char const *s1), que es la cadena original de la que se eliminarán los caracteres. Un puntero a una cadena terminada en nulo (char const *set), que es el conjunto de caracteres que se eliminará. Un puntero a una nueva cadena

About

Primer proyecto como estudiante de 42Madrid

Topics

Resources

Stars

Watchers

Forks

Releases

No releases published

Packages

No packages published