C
C
#include <stdlib.h>
int atoi (const char *str);
atoi() converte um string str para um int
a função remove do inicio da string quantas vezes houverem os seguintes:
'\t' horizontal tab
'\n' newline
'\r' cariagge return
'\v' vertical tab
'\f' formfeed page break
' ' space
verifica uma vez se o sinal é positivo ou negativo
verifica se os caracteres são numerais
Exemplo 1:
atoi(" ---+123d1");
=> 0
Exemplo 2:
atoi(" -123");
=> -123
#include "libft.h"
int ft_atoi(const char *str)
{
int i;
int n;
int sinal;
i = 0;
while (str[i] == '\t' || str[i] == '\n'|| str[i] == '\r' ||
str[i] == '\v' || str[i] == '\f' || str[i] == ' ')
i++;
sinal = 0;
if (str[i] == '-' || str[i] == '+')
{
if (str[i] == '-')
sinal = 1;
i++;
}
n = 0;
while (str[i] >= '0' && str[i] <= '9')
{
n = n * 10 + str[i] - '0';
i++;
}
if (sinal > 0)
n = n * (- 1);
return (n);
}
char *ft_substr(char const *s, unsigned int start, size_t len);
Aloca memoria(usando malloc) e retorna uma substring da string s
que inicia em start e segue até o tamanho maximo len.
Retorna NULL se a alocação falhar.
#include "libft.h"
char *ft_substr(char const *s, unsigned int start, size_t len)
{
size_t i;
char *sub;
size_t start_copy;
start_copy = ((size_t)start);
if (s == 0)
return (0);
sub = malloc((len + 1) * sizeof(char));
if (sub == 0)
return (0);
i = 0;
while (i < len && start_copy < ft_strlen(s))
{
sub[i] = s[start_copy + i];
i++;
}
sub[i] = '\0';
return (sub);
}
#include "libft.h"
void *ft_memset(void *dest, int c, size_t len)
{
if (len > 0)
{
while (len--)
{
*(unsigned char *)(dest + len) = (unsigned char)(c);
}
}
return (dest);
}
#include <strings.h>
int bzero (void *s, size_t n);
A função bzero() escreve bytes zero n vezes pela string s.
Se n for 0, bzero() nao faz nada.
#include "libft.h"
void ft_bzero(void *s, size_t n)
{
ft_memset(s, '\0', n);
}
#include "libft.h"
void *ft_memcpy(void *dst, const void *src, size_t n)
{
char *d;
const char *s;
d = dst;
s = src;
if (dst == src)
return (0);
while (n--)
*d++ = *s++;
return (dst);
}
#include "libft.h"
void *ft_memccpy(void *dst, const void *src, int c, size_t n)
{
unsigned char x;
unsigned char *dst_copy;
unsigned char *src_copy;
size_t i;
x = ((unsigned char)c);
dst_copy = ((unsigned char *)dst);
src_copy = ((unsigned char *)src);
i = 0;
if (dst == src)
return (0);
while (i < n)
{
dst_copy[i] = src_copy[i];
if (src_copy[i] == x)
return (&dst_copy[i + 1]);
i++;
}
return (0);
}
#include "libft.h"
void *ft_memmove(void *dst, const void *src, size_t len)
{
char *d;
const char *s;
const char *lasts;
char *lastd;
d = dst;
s = src;
lasts = s + (len - 1);
lastd = d + (len - 1);
if (src == dst)
return (0);
if (d < s)
while (len--)
*d++ = *s++;
else
while (len--)
*lastd-- = *lasts--;
return (dst);
}
#include "libft.h"
void *ft_memchr(const void *s, int c, size_t n)
{
const unsigned char *src;
src = (const unsigned char *)s;
while (n)
{
if (*src == (unsigned char)c)
return ((void *)src);
src++;
n--;
}
return (NULL);
}
#include "libft.h"
int ft_memcmp(const void *s1, const void *s2, size_t n)
{
const unsigned char *str1;
const unsigned char *str2;
size_t i;
str1 = (const unsigned char *)s1;
str2 = (const unsigned char *)s2;
i = 0;
while (i < n)
{
if (str1[i] != str2[i])
return (str1[i] - str2[i]);
i++;
}
return (0);
}
#include "libft.h"
size_t ft_strlen(const char *s)
{
int i;
i = 0;
while (s[i])
i++;
return (i);
}
#include "libft.h"
size_t ft_strlcpy(char *dst, const char *src, size_t dstsize)
{
size_t i;
i = 0;
if (src == 0)
return (0);
if (dstsize > 0)
{
while (src[i] != '\0' && i < (dstsize - 1))
{
dst[i] = src[i];
i++;
}
dst[i] = '\0';
}
return (ft_strlen(src));
}
#include "libft.h"
size_t ft_strlcat(char *dst, const char *src, size_t dstsize)
{
size_t i;
size_t len_src;
size_t len_dst;
size_t j;
len_dst = ft_strlen(dst);
len_src = ft_strlen(src);
i = len_dst;
if (dst == src)
return (0);
if (dstsize != 0 && i < (dstsize - 1))
{
j = 0;
while (i < (dstsize - 1) && src[j] != '\0')
{
dst[i] = src[j];
i++;
j++;
}
dst[i] = '\0';
}
if (len_dst > dstsize)
return (dstsize + len_src);
return (len_dst + len_src);
}
#include <string.h>
char *strchr(const char *s, int c);
A função localiza a primeira ocorrencia de c (convertido para char)
na string apontada por s.
\0 é considerado parte da string
Ela retorna a posição do charactere na string
ou NULL se o character nao for encontrado.
#include "libft.h"
char *ft_strchr(const char *s, int c)
{
int i;
int len;
char *scpy;
scpy = (char *)s;
i = 0;
len = ft_strlen(scpy);
if (c == '\0')
return (&scpy[len]);
while (scpy[i] != '\0')
{
if (scpy[i] == c)
return (&scpy[i]);
i++;
}
return (0);
}
#include <string.h>
char *strrchr(const char *s, int c);
A função localiza a ultima ocorrencia de c (convertido para char)
na string apontada por s.
\0 é considerado parte da string
Ela retorna a posição do charactere na string
ou NULL se o character nao for encontrado.
#include "libft.h"
char *ft_strrchr(const char *s, int c)
{
int i;
int len;
char *scpy;
scpy = (char *)s;
len = ft_strlen(scpy);
i = len - 1;
if (c == '\0')
return (&scpy[len]);
while (i >= 0)
{
if (scpy[i] == c)
return (&scpy[i]);
i--;
}
return (0);
}
#include <string.h>
char *strnstr(const char *haystack, const char *needle, size_t len);
A função procura a primeira ocorrencia da string needle dentro da string haystack.
Essa procura é limitada pelo argumento len.
strnstr pode ter problemas de portabilidade
Se needle é uma string vazia a função retorna o haystack.
Se needle não esta em haystack, retorna NULL.
Se encontrado needle em haystack a função retorna o ponteiro da primeira occorrencia.
#include "libft.h"
char *ft_strnstr(const char *haystack, const char *needle, size_t len)
{
size_t i;
size_t j;
char *hay;
char *need;
hay = (char *)haystack;
need = (char *)needle;
if (need[0] == '\0')
return (hay);
i = 0;
while (hay[i] != '\0')
{
j = 0;
if (hay[i] == need[0])
{
while (hay[i + j] == need[j] &&
(j + i) < len && need[j] != '\0')
j++;
if (need[j] == '\0')
return (&hay[i]);
}
i++;
}
return (0);
}
#include "libft.h"
int ft_strncmp(const char *s1, const char *s2, size_t n)
{
unsigned char *s1_copy;
unsigned char *s2_copy;
size_t i;
s1_copy = ((unsigned char *)s1);
s2_copy = ((unsigned char *)s2);
i = 0;
while (i < n && (s1_copy[i] != '\0' || s2_copy[i] != '\0'))
{
if (s1_copy[i] != s2_copy[i])
return (s1_copy[i] - s2_copy[i]);
i++;
}
return (0);
}
#include <ctype.h>
int isalpha(int c);
A função verifica se o charactere passado é um caratere do alfabeto.
retorna 1 se verdadeiro
retorna 0 se falso
#include "libft.h"
int ft_isalpha(int c)
{
if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z'))
return (1);
return (0);
}
#include <ctype.h>
int isdigit(int c);
A função verifica se o charactere passado é um digito entre 0 e 9
#include "libft.h"
int ft_isdigit(int c)
{
if (c >= '0' && c <= '9')
return (1);
return (0);
}
#include <ctype.h>
int isalnum(int c);
função verifica se o charactere passado é uma letra ou numero.
retorna 1 se verdadeiro
retorna 0 se falso
#include "libft.h"
int ft_isalnum(int c)
{
if ((c >= '0' && c <= '9') ||
(c >= 'A' && c <= 'Z') ||
(c >= 'a' && c <= 'z'))
return (1);
else
return (0);
}
#include <ctype.h>
int isascii(int c);
A função testa se o character passado consta na tabla ascii.
#include "libft.h"
int ft_isascii(int c)
{
int y;
if (c >= 0 && c <= 127)
y = 1;
else
y = 0;
return (y);
}
#include <ctype.h>
int isprint(int c);
A função testa se o character passado é imprimivel.
#include "libft.h"
int ft_isprint(int c)
{
if (c >= 32 && c <= 126)
return (1);
return (0);
}
#include <ctype.h>
int toupper(int c);
A função converte um charactere minusculo em maiusculo.
#include "libft.h"
int ft_toupper(int c)
{
if (c >= 'a' && c <= 'z')
c -= 32;
return (c);
}
#include <ctype.h>
int toupper(int c);
A função converte um charactere maiusculo em minusculo.
#include "libft.h"
int ft_tolower(int c)
{
if (c >= 'A' && c <= 'Z')
c += 32;
return (c);
}
#include <stdlib.h>
void *calloc(size_t count, size_t size);
A função aloca a memoria requerida e retorna o ponteiro para o espaco alocado,
ou NULL se o requerimento falhar
a diferença entre malloc() e calloc() eh que malloc nao zera a memoria alocada
#include "libft.h"
void *ft_calloc(size_t count, size_t size)
{
char *str;
size_t i;
i = 0;
str = (char *)malloc(count * size);
if (str == 0)
return (0);
while (i < count * size)
{
str[i] = 0;
i++;
}
return ((void *)str);
}
#include "libft.h"
char *ft_strdup(const char *s1)
{
char *s1_copy;
size_t len;
size_t i;
len = ft_strlen(s1);
s1_copy = malloc((len + 1) * sizeof(char));
i = 0;
if (s1_copy == 0)
return (0);
while (i < len)
{
s1_copy[i] = s1[i];
i++;
}
s1_copy[i] = '\0';
return (s1_copy);
}
char *ft_strjoin(char const *s1, char const *s2);
Aloca memoria (usando malloc) e retorna o string novo produto da concatenação de s1 e s2,
ou NULL se a alocação falhar.
#include "libft.h"
char *ft_strjoin(const char *s1, const char *s2)
{
char *sjoin;
size_t size;
size_t i;
size_t j;
if (s1 == 0 || s2 == 0)
return (0);
size = ft_strlen(s1) + ft_strlen(s2) + 1;
sjoin = malloc(size * sizeof(char));
if (sjoin == 0)
return (0);
i = 0;
while (i < ft_strlen(s1))
{
sjoin[i] = s1[i];
i++;
}
j = 0;
while (j < ft_strlen(s2))
{
sjoin[i + j] = s2[j];
j++;
}
sjoin[i + j] = '\0';
return (sjoin);
}