This project has been created as part of the 42 curriculum by thcardos

_{Libft is a library of functions in C that recreates the standard functions of the C library, as well as including additional functions useful for future 42 projects. This project is the first project in the 42 curriculum and its aim is to familiarise students with programming in C, memory management and basic data structures.}

_{The main objective is to understand how standard C functions work internally and to develop a solid foundation of knowledge about string manipulation, memory, and linked lists.}

_{Below is a detailed description of each function and its logic:}

_{Part 1 - Libc Functions}

_{These functions recreate standard C library functions with the same behavior.}

_{Character Verification Functions}

_{ft_isalpha}

_{- Checks if a character is alphabetic (a-z, A-Z)}

_{- Returns 1 if the character is a letter, 0 otherwise}

_{- Logic: Verifies if c is between 'a'-'z' or 'A'-'Z'}

_{ft_isdigit}

_{- Checks if a character is a numeric digit (0-9)}

_{- Returns 1 if the character is a digit, 0 otherwise}

_{- Logic: Verifies if c is between '0'-'9'}

_{ft_isalnum}

_{- Checks if a character is alphanumeric}

_{- Returns 1 if the character is a letter or digit, 0 otherwise}

_{- Logic: Combines ft_isalpha and ft_isdigit}

_{ft_isascii}

_{- Checks if a character is in the ASCII table (0-127)}

_{- Returns 1 if the character is ASCII, 0 otherwise}

_{- Logic: Verifies if c is between 0 and 127}

_{ft_isprint}

_{- Checks if a character is printable (32-126)}

_{- Returns 1 if the character is printable, 0 otherwise}

_{- Logic: Verifies if c is between 32 and 126 (space to tilde)}

_{ft_toupper}

_{- Converts a lowercase letter to uppercase}

_{- Returns the uppercase equivalent if c is lowercase, otherwise returns c}

_{- Logic: If c is between 'a'-'z', subtracts 32 to convert to uppercase}

_{ft_tolower}

_{- Converts an uppercase letter to lowercase}

_{- Returns the lowercase equivalent if c is uppercase, otherwise returns c}

_{- Logic: If c is between 'A'-'Z', adds 32 to convert to lowercase}

_{String Functions}

_{ft_strlen}

_{- Calculates the length of a string}

_{- Returns the number of characters before the null terminator}

_{- Logic: Iterates through the string until '\0' is found, counting characters}

_{ft_strchr}

_{- Locates the first occurrence of a character in a string}

_{- Returns a pointer to the first occurrence of c in s, or NULL if not found}

_{- Logic: Iterates through the string comparing each character with c}

_{ft_strrchr}

_{- Locates the last occurrence of a character in a string}

_{- Returns a pointer to the last occurrence of c in s, or NULL if not found}

_{- Logic: Iterates through the entire string and saves the position of the last match}

_{ft_strncmp}

_{- Compares two strings up to n characters}

_{- Returns 0 if equal, negative if s1 < s2, positive if s1 > s2}

_{- Logic: Compares characters one by one until finding a difference, reaching n, or finding '\0'}

_{ft_strlcpy}

_{- Copies a string to a destination buffer with size limit}

_{- Returns the total length of the string it tried to create}

_{- Logic: Copies up to size - 1 characters and always null-terminates the destination}

_{ft_strlcat}

_{- Concatenates strings with size limit}

_{- Returns the total length of the string it tried to create}

_{- Logic: Appends src to the end of dst, ensuring null-termination and size limit}

_{ft_strnstr}

_{- Locates a substring in a string (limited to len bytes)}

_{- Returns a pointer to the beginning of the located substring, or NULL if not found}

_{- Logic: Searches for the first occurrence of little in big within len bytes}

_{ft_strdup}

_{- Duplicates a string in dynamically allocated memory}

_{- Returns a pointer to the new string, or NULL if allocation fails}

_{- Logic: Allocates memory with malloc, copies the string, and returns the pointer}

_{Memory Functions}

_{ft_memset}

_{- Fills a block of memory with a specific byte}

_{- Returns a pointer to the memory area s}

_{- Logic: Sets the first n bytes of s to the value c}

_{ft_bzero}

_{- Sets a block of memory to zero}

_{- No return value (void)}

_{- Logic: Calls ft_memset with value 0}

_{ft_memcpy}

_{- Copies n bytes from src to dest (no overlap handling)}

_{- Returns a pointer to dest}

_{- Logic: Copies n bytes from src to dest byte by byte}

_{ft_memmove}

_{- Copies n bytes from src to dest (handles overlapping)}

_{- Returns a pointer to dest}

_{- Logic: Checks if regions overlap and copies forward or backward accordingly to avoid data corruption}

_{ft_memchr}

_{- Locates a byte in a block of memory}

_{- Returns a pointer to the matching byte, or NULL if not found}

_{- Logic: Searches for the first occurrence of c in the first n bytes of s}

_{ft_memcmp}

_{- Compares two blocks of memory}

_{- Returns 0 if equal, negative if s1 < s2, positive if s1 > s2}

_{- Logic: Compares the first n bytes of s1 and s2 byte by byte}

_{Conversion Functions}

_{ft_atoi}

_{- Converts a string to an integer}

_{- Returns the converted integer value}

_{- Logic: Skips whitespace, handles sign (+/-), converts digits to integer until a non-digit is found}

_{ft_calloc}

_{- Allocates memory and initializes it to zero}

_{- Returns a pointer to the allocated memory, or NULL if allocation fails}

_{- Logic: Allocates nmemb * size bytes with malloc and initializes to zero with ft_bzero}

_{Part 2 - Additional Functions}

_{These functions provide additional string manipulation capabilities not in the standard library.}

_{ft_substr}

_{- Extracts a substring from a string}

_{- Returns a new string (substring), or NULL if allocation fails}

_{- Logic: Allocates memory for len characters, copies characters starting from index start}

_{ft_strjoin}

_{- Concatenates two strings into a new string}

_{- Returns a new string containing s1 followed by s2, or NULL if allocation fails}

_{- Logic: Allocates memory for both strings, copies s1, then appends s2}

_{ft_strtrim}

_{- Removes characters from the beginning and end of a string}

_{- Returns a trimmed copy of the string, or NULL if allocation fails}

_{- Logic: Finds the start and end positions by skipping characters in set, then extracts the substring}

_{ft_split}

_{- Splits a string into an array of strings using a delimiter}

_{- Returns an array of strings, or NULL if allocation fails}

_{- Logic: Counts words separated by c, allocates array, extracts each word into a new string}

_{ft_itoa}

_{- Converts an integer to a string}

_{- Returns a string representing the integer, or NULL if allocation fails}

_{- Logic: Calculates number of digits, handles negative numbers, converts each digit to character}

_{ft_strmapi}

_{- Applies a function to each character of a string}

_{- Returns a new string with the function applied, or NULL if allocation fails}

_{- Logic: Creates a new string, applies function f to each character with its index}

_{ft_striteri}

_{- Applies a function to each character of a string (modifies in place)}

_{- No return value (void)}

_{- Logic: Iterates through the string applying function f to each character with its index}

_{ft_putchar_fd}

_{- Writes a character to a file descriptor}

_{- No return value (void)}

_{- Logic: Uses write system call to output character c to file descriptor fd}

_{ft_putstr_fd}

_{- Writes a string to a file descriptor}

_{- No return value (void)}

_{- Logic: Uses write to output the entire string s to file descriptor fd}

_{ft_putendl_fd}

_{- Writes a string followed by a newline to a file descriptor}

_{- No return value (void)}

_{- Logic: Calls ft_putstr_fd followed by write to output a newline character}

_{ft_putnbr_fd}

_{- Writes an integer to a file descriptor}

_{- No return value (void)}

_{- Logic: Handles negative numbers and edge cases, converts digits to characters recursively and writes them}

_{Part 3 - Linked Lists}

_{These functions provide a complete set of operations for managing singly linked lists.}

_Structure:

typedef struct s_list
{
    void            *content;  // Pointer to the data
    struct s_list   *next;     // Pointer to the next node
}   t_list;

_{ft_lstnew}

_{- Creates a new list node}

_{- Returns a pointer to the new node, or NULL if allocation fails}

_{- Logic: Allocates memory for a new node, initializes content with the parameter, sets next to NULL}

_{ft_lstadd_front}

_{- Adds a node at the beginning of the list}

_{- No return value (void)}

_{- Logic: Sets new->next to the current first node, updates the list head to point to new}

_{ft_lstadd_back}

_{- Adds a node at the end of the list}

_{- No return value (void)}

_{- Logic: If list is empty, sets head to new; otherwise traverses to the last node and sets its next to new}

_{ft_lstsize}

_{- Counts the number of nodes in a list}

_{- Returns the number of nodes}

_{- Logic: Traverses the list from head to tail, counting each node}

_{ft_lstlast}

_{- Returns the last node of the list - Returns a pointer to the last node, or NULL if list is empty - Logic: Traverses the list until finding a node whose next is NULL}

_{ft_lstdelone}

_{- Deletes a single node}

_{- No return value (void)}

_{- Logic: Calls the del function on the node's content, then frees the node itself}

_{ft_lstclear}

_{- Deletes all nodes in the list}

_{- No return value (void)}

_{- Logic: Iterates through the list, deleting each node with ft_lstdelone and sets the head to NULL}

_{ft_lstiter}

_{- Applies a function to each node's content}

_{- No return value (void)}

_{- Logic: Traverses the list and applies function f to each node's content}

_{ft_lstmap}

_{- Creates a new list by applying a function to each node}

_{- Returns a pointer to the new list, or NULL if allocation fails}

_{- Logic: Iterates through the original list, applies f to each content, creates new nodes, and builds a new list. If any allocation fails, clears the new list using del}

Compilation with the library

cc -Wall -Wextra -Werror your_program.c libft.a -o program

Available commands

Comand	Description
make	Compiles the library
make clean	Deletes all the object files (.o)
make fclean	Deletes the object files and the library
make re	Compiles everything again

_{Testing the functions:}

_{Here you have the Main File I have created to test my functions.}

Memory verification with Valgrind:

# Compile your program with the library
gcc -g -Wall -Wextra -Werror your_program.c -L. -lft -o program

# Run with Valgrind
valgrind --leak-check=full ./program

# Show all possible Leaks
valgrind --leak-check=full --show-leak-kinds=all ./test_libft

# Display detailed information about the errors
valgrind --leak-check=full --track-origins=yes ./test_libft

# Save the report to a file
valgrind --leak-check=full --log-file=valgrind_report.txt ./test_libft

🟩Without errors🟩

HEAP SUMMARY:
    in use at exit: 0 bytes in 0 blocks
  total heap usage: X allocs, X frees, Y bytes allocated

All heap blocks were freed -- no leaks are possible

🟥With errors🟥

LEAK SUMMARY:
   definitely lost: 24 bytes in 1 blocks

This indicates that there is memory that was allocated with malloc but never freed with free.

Using GDB (GNU Debugger)

GDB is an interactive debugger that allows you to inspect your program while it runs.

Basic usage:

# Compile with debugging symbols
gcc -g -Wall -Wextra -Werror main.c -L. -lft -o test

# Start GDB
gdb ./test

GDB commands

Comand	Description
run	Execute the program
break main	Set a breakpoint at main function
break your_program	Set a breakpoint at your_program
next	Execute next line (step over)
step	Execute next line (step into)
print variable	Print variable value
continue	Continue execution
quit	Exit GDB

Using AddressSanitizer

AddressSanitizer detects memory errors at runtime.

gcc -g -fsanitize=address -Wall -Wextra -Werror main.c -L. -lft -o test
./test

This will automatically detect:

• Buffer overflows

• Use after free

• Memory leaks

• Double free

References used:

• Libft Subject (v19.0) - Official project subject

• Learn-C.org - Interactive C tutorial.

• Make Tutorial - Makefiles tutorial.

• C Reference Manual - Complete C reference documentation.

• GeeksforGeeks - C Programming - C tutorials and examples.

• Stack Overflow - Community for resolving specific queries.

_{Use of AI}

_{During the development of this project artificial intelligence has been used as a learning support tool, not as a shortcut. Similar to consulting a book or asking a classmate, AI has been used to:}

_{- Understand concepts that were not clear in the documentation.}

_{- Obtain guidance on what to study.}

_{- Improve the presentation of documentation.}

_{However, the entire process of reasoning, implementation, and debugging has been manual, ensuring the development of essential skills for the rest of the 42 curriculum and for taking exams without external dependencies.}

_{Educational Use:}

_{- README Aesthetics: Visual design, badges, markdown formatting, and documentation structure.}

_{- Resource Guidance: Advice on which resources, documentation, and tutorials to look for to learn specific concepts.}

_{- Definitions for notes: Creation of clear and concise definitions of programming concepts for my personal notes.}

_{- Debugging tips: Suggestions on debugging tools and methodologies (Valgrind, GDB, etc.)}

_{Not used for:}

_{- Code generation: All function code has been written manually without AI assistance.}

_{- Exercise solving: Algorithms and logic have been developed independently.}

_{- Direct copying of solutions: AI-generated answers have not been used to implement functions.}