Neste capítulo é apresentada uma listagem e uma breve descrição sobre as funções mais importantes da Biblioteca Standard da linguagem C.
As funções estão agrupadas pelas categorias definidas na própria biblioteca. Cada categoria possui o seu próprio ficheiro de inclusão (com a extensão .h) que é indicado no início da respetiva lista.
Quando se pretende utilizar alguma das funções de uma determinada categoria o respetivo ficheiro de inclusão deverá ser incluído no ficheiro fonte que faz a chamada a essa função.
Para uma descrição mais detalhada pode consultar um dos livros da bibliografia, ou os
manuais on-line do UNIX (comando man) ou ainda a documentação (geralmente on-line) que acompanha os compiladores de C.
void *memchr(const void *buf, int c, size_t count);
A função procura a primeira ocorrência do valor c (0 a 255)
nos primeiros countbytes do buffer de
memória apontado por buf. Pára quando
encontra o primeiro valor c ou quando já
examinou countbytes. Retorna um
apontador para o local da primeira ocorrência de c ou
NULL se não encontrar c.
int memcmp(const void *buf1, const void *buf2, size_t count);
A função compara os primeiros countbytes dos buffers apontados
por buf1 e buf2.
Retorna um valor que indica a sua relação (<0
se buf1 é menor
que buf2; = 0
se buf1 é igual
a buf2 >0
se buf1 é maior
que buf2).
void *memcpy(void *dest, const void * src, size_t count);
A função copia countbytes do buffer apontado
por src para o buffer apontado
por dest. Não deve ser utilizada se os
buffers src e dest tiverem
uma zona sobreposta (nesse caso
usar memmove).
Retorna dest.
void *memmove(void *dest, const void *src, size_t count);
Idêntica à função anterior, mas garante um bom funcionamento mesmo em caso
de haver uma região sobreposta
nos bufferssrc e dest.
void *memset(void *dest, int c, size_t count);
Preenche todos os
primeiros countbytes do buffer apontado
por dest com o
valor c (0-255).
Retorna dest.
double atof(const char *string);
Converte a cadeia de caracteres apontada
por string para um
valor double, desde que essa cadeia possa ser
interpretada como um valor numérico desse tipo. Retorna 0.0 se a
cadeia string não for reconhecida como
representando um double.
int atoi(const char *string);
Converte a cadeia de caracteres apontada por string para
um valor int, desde que essa cadeia possa ser
interpretada como um valor numérico desse tipo. Retorna 0 se a
cadeia string não for reconhecida como
representando um int.
long atol(const char *string);
Converte a cadeia de caracteres apontada
por string para um valor inteiro
longo long, desde que essa cadeia possa ser
interpretada como um valor numérico desse tipo. Retorna 0L se a
cadeia string não for reconhecida como
representando um long.
char *itoa(int value, char *string, int radix);
Converte o valor inteiro value para uma
representação em cadeia de caracteres e armazena-a na memória apontada
por string (ocupando um máximo de 17 bytes).
A conversão é feita utilizando a
base radix (2-36). Retorna o
apontador string.
char *ltoa(long value, char *string, int radix);
Converte o valor inteiro longo value para
uma representação em cadeia de caracteres e armazena-a na memória apontada
por string (ocupando um máximo de 33 bytes).
A conversão é feita utilizando a
base radix (2-36). Retorna o
apontador string.
double strtod(const char *nptr, char **endptr);
Converte a cadeia de caracteres apontada por nptr para
um valor double. A conversão pára quando, na
cadeia nptr, surge um caractere que não pode
ser interpretado como fazendo parte do valor, ou quando a cadeia acaba
(com \0). Quando a conversão é interrompida antes do fim da cadeia,
coloca-se no apontador *endptr o endereço
do primeiro caractere não convertido; caso
contrário *endptr é preenchido com NULL.
Retorna 0.0 se a conversão não for feita.
long strtol(const char *nptr, char **endptr, int base);
Converte a cadeia de caracteres apontada por nptr para
um valor long. A conversão pára quando, na
cadeia nptr, surge um caractere que não pode
ser interpretado como fazendo parte do valor, ou quando a cadeia acaba
(com \0). Quando a conversão é interrompida antes do fim da cadeia,
coloca-se no apontador *endptr o endereço
do primeiro caractere não convertido; caso
contrário *endptr é preenchido com NULL.
Esta função pressupõe que o valor está representado na
base base. Retorna 0L se a conversão não for
feita.
unsigned long strtoul(const char *nptr, char **endptr, int base);
Converte a cadeia de caracteres apontada
por nptr para um
valor unsigned long. A conversão pára quando,
na cadeia nptr surge um caractere que não
pode ser interpretado como fazendo parte do valor, ou quando a cadeia
acaba (com \0). Quando a conversão é interrompida antes do fim da cadeia,
coloca-se no apontador *endptr o endereço do
primeiro caractere não convertido; caso
contrário *endptr é preenchido com NULL.
Esta função pressupõe que o valor está representado na
base base. Retorna 0L se a conversão não
for feita.
Forma de o utilizar: #include <dir.h> (em
Windows utilizar direct.h)
int chdir(char *dirname);
Muda o diretório corrente para aquele indicado
por dirname. (Em Windows não muda o
volume corrente, embora este possa estar especificado
em dirname). Retorna 0 se não ocorrer erro
e -1 no caso contrário.
int chdrive(int drive);
Muda o volume corrente para aquele indicado
por drive (0=A, 1=B, 2=C, etc.). Retorna
0 se não ocorrer erro e -1 no caso contrário. (só existe em Windows).
char *getcwd(char *buffer, int maxlen);
Coloca em buffer o nome completo do
diretório corrente, se este não
exceder maxlenbytes. Retorna o
apontador buffer se não ocorrer erro e
NULL no caso contrário.
int getdrive(void);
Retorna o valor do volume corrente (0=A, 1=B, 2=C, etc.). (só existe em
Windows).
int mkdir(char *dirname);
Cria um novo diretório especificado
em dirname. Retorna 0 se não ocorrer erro
e -1 no caso contrário.
int rmdir(char *dirname);
Remove o diretório especificado
em dirname. Este deverá estar vazio para
poder ser removido. Retorna 0 se não ocorrer erro e -1 em caso
contrário.
Forma de os utilizar: #include <sys/stat.h> #include <sys/types.h> e #include <io.h>
int chmod(char *filename, int pmode);
Modifica as permissões de acesso ao
ficheiro filename. O
argumento pmode é construído através da
operação or (|) de uma ou várias
constantes de permissão de acesso definidas
em sys/stat.h. Retorna 0 se não ocorrer erro
e -1 no caso contrário.
int fstat(int handle, struct stat *buffer);
Obtém a informação acerca do ficheiro aberto associado
a handle. Essa informação é colocada na
estrutura stat apontada por buffer e
descrita em sys/stat.h. Retorna 0 se não
ocorrer erro e -1 no caso contrário.
int chmod(char *filename, int pmode);
Modifica as permissões de acesso ao
ficheiro filename. O
argumento pmode é construído através da
operação or (|) de uma ou várias
constantes de permissão de acesso definidas
em sys/stat.h. Retorna 0 se não ocorrer erro
e -1 no caso contrário.
int remove(const char *filename);
Apaga o ficheiro especificado
por filename. Retorna 0 se não ocorrer
erro e -1 no caso contrário.
int rename(const char *oldname, const char *newname);
Muda o nome de um ficheiro ou diretório . O nome atual é dado pela
cadeia de caracteres apontada
por oldname, enquanto que o novo nome é
especificado em newname. Retorna 0 se não
ocorrer erro e -1 no caso contrário.
int stat(char *filename, struct stat *buffer);
Obtém informação acerca do ficheiro especificado
em filename. Essa informação é colocada
na estrutura stat apontada por buffer e
descrita em sys/stat.h. Retorna 0 se
não ocorrer erro e -1 no caso contrário.
int umask(int pmode);
Modifica as permissões de acesso aos ficheiros criados a partir deste
ponto. O argumento pmode é construído através
da operação or (|) de uma ou várias
constantes de permissão de acesso definidas
em sys/stat.h. Retorna o valor anterior
de pmode.
Estas funções manipulam dados que são vistos como uma sequências contínua
(streams) de caracteres ou bytes. Geralmente
estes streams são associados a ficheiros armazenados em disco, e
são referenciados através de um apontador (stream pointer) para uma
estrutura que os descreve (FILE *).
void clearerr(FILE *stream);
Limpa o indicador de erro associado ao
stream stream. Este indicador de erro não
é limpo automaticamente uma vez ocorrido. As únicas funções capazes de
limpar um indicador de erro
são clearerr(), fseek(), fsetpos() e rewind() (as
duas do meio apenas para o erro de fim-de-ficheiro).
int fclose(FILE *stream);
Fecha o stream stream. Retorna 0 se não
ocorrer nenhum erro ou EOF no caso contrário.
int feof(FILE *stream);
Testa se o stream stream chegou ou não ao
fim. Retorna 0 se a posição atual não for o fim-de-ficheiro ou um valor
diferente de 0 se já tiver ocorrido uma operação de leitura que tentasse
ler para além do fim-de-ficheiro.
int ferror(FILE *stream);
Testa se ocorreu um erro de leitura ou escrita no
stream stream. Retorna 0 se nenhum erro
tiver ocorrido. Este tipo de erros só pode ser limpo através
de clearerr() ou rewind().
int fflush(FILE *stream);
Despeja o buffer associado a stream.
Estes buffers são automaticamente despejados quando
o stream é fechado ou quando o processo termina normalmente.
Retorna 0 se não ocorrer nenhum erro ou EOF no caso contrário.
int fgetc(FILE *stream);
Lê e devolve o valor de um único caractere colocado na posição atual
(avançando esta posição) do
stream stream. Retorna EOF se ocorrer um
erro de leitura ou se a posição atual for o fim-de-ficheiro.
int fgetpos(FILE *stream, fpos_t *pos);
Coloca o indicador de posição do
stream stream na memória apontada
por pos. Retorna 0 se não ocorrer nenhum
erro.
char *fgets(char *string, int n, FILE *stream);
Lê uma cadeia de caracteres a partir da posição atual (avançando esta
posição) do stream stream e coloca-a
em string. A leitura pára quando se tiver
lido um caractere de mudança de linha (\n), quando se chegar ao
fim-de-ficheiro, ou quando se já tiverem
lido n-1 caracteres. É sempre
acrescentado um caractere 0
a string. Retorna string ou
NULL se ocorrer um erro de leitura ou se a posição atual for o
fim-de-ficheiro.
FILE *fopen(const char *name, const char *mode);
Abre o ficheiro ou dispositivo identificado
por name num modo de funcionamento
especificado por mode. Os modos de
funcionamento podem ser: r - leitura
apenas; w - escrita apenas; a - escrita
apenas mas no fim-de-ficheiro (append); r+ - leitura e
escrita (o ficheiro tem já de existir); w+ - leitura e
escrita (novo ficheiro) e a+ - leitura e escrita no
fim-de-ficheiro. A estes modos podem ainda ser acrescentadas as
letras t (ficheiros de texto)
ou b (ficheiros binários). Retorna um apontador para
stream ou NULL em caso de erro.
int fprintf(FILE *stream, const char *format, ...);
Formata e escreve uma série de caracteres na posição atual (avançando
esta) do stream stream. Os caracteres a
escrever são especificados na
cadeia format e nos argumentos seguintes
(ver no capítulo de Entrada e Saída, a descrição
de printf). Retorna o número de caracteres escritos, ou um número negativo
em caso de erro.
int fputc(int c, FILE *stream);
Escreve o valor de um único
caractere c (0-255) colocando-o na
posição atual (avançando esta posição) do
stream stream. Retorna EOF se ocorrer um erro
ou o valor do caractere escrito no caso contrário.
int fputs(const char *string, FILE *stream);
Escreve a cadeia de caracteres string a
partir da posição atual (avançando esta posição) do
stream stream. O caractere 0 terminador
de string não é escrito. Retorna 0
ou um valor positivo, ou EOF em caso de erro.
size_t fread(void *buf, size_t size, size_t count, FILE *stream);
Lê até um conjunto de count itens
com sizebytes de tamanho cada,
a partir da posição atual (avançando esta posição) do
stream stream, e coloca-os
em buf. Retorna o número de itens lido,
que pode ser menor do que count (em caso
de erro ou fim-de-ficheiro).
FILE *freopen(const char *name, const char *mode, FILE *stream);
Fecha o ficheiro associado a stream e
associa o mesmo stream a um novo ficheiro
especificado em name e mode, de
modo semelhante ao já descrito em fopen().
int fscanf(FILE *stream, const char *format, ...);
Lê uma série de caracteres formatados da posição atual (avançando esta)
do stream stream. Os caracteres a ler são
especificados na cadeia format e nos
argumentos seguintes (ver no capítulo
de Entrada e Saída, a descrição de scanf).
Retorna o número de campos lidos e passados para argumentos, ou EOF em
caso de erro.
int fseek(FILE *stream, long offset, int origin);
Move o indicador de posição do
stream stream para a
posição offset. O
argumento offset (em bytes) é
contado a partir da posição atual, para trás a partir do fim do ficheiro,
ou a partir do início do ficheiro, consoante o valor
de origin seja SEEK_CUR, SEEK_END, ou
SEEK_SET. Retorna 0 se não ocorrer nenhum erro.
int fsetpos(FILE *stream, const fpos_t *pos);
Coloca o indicador de posição do stream stream com
o valor indicado em pos. Este valor deve
ter sido obtido com uma chamada
a fgetpos(). Retorna 0 se não
ocorrer nenhum erro.
long ftell(FILE *stream);
Retorna o indicador de posição do stream stream ou
-1L se ocorrer um erro.
size_t fwrite(const void *buf, size_t size, size_t count, FILE *stream);
Escreve até um conjunto de count itens
com sizebytes de tamanho cada,
a partir da posição atual (avançando esta posição) do
stream stream, retirando-os
do bufferbuf. Retorna o número
de itens efetivamente escrito, que pode ser menor do
que count (em caso de erro).
int getc(FILE *stream);
Lê e devolve o valor de um único caractere colocado na posição atual
(avançando esta posição) do
stream stream. Retorna EOF se ocorrer um
erro de leitura ou se a posição atual for o fim-de-ficheiro.
int getchar(void);
Idêntica a getc(stdin).
char *gets(char *buffer);
Lê uma linha de caracteres do
stream stdin e coloca-a
em buffer. A leitura pára quando se tiver
lido um caractere de mudança de linha (\n), que é substituído por um
caractere 0. Retorna buffer ou NULL se
ocorrer um erro de leitura ou se a posição atual for o fim-de-ficheiro.
int printf(const char *format, ...);
Formata e escreve uma série de caracteres na posição atual (avançando
esta) do stream stdout. Os caracteres a
escrever são especificados na
cadeia format e nos argumentos seguintes
(ver no capítulo de Entrada e Saída, a descrição
de printf). Retorna o número de caracteres escritos, ou um número negativo
em caso de erro.
int putc(int c, FILE *stream);
Escreve o valor de um único
caractere c (0-255) colocando-o na
posição atual (avançando esta posição) do
stream stream.
Retorna EOF se ocorrer um erro ou o valor do caractere escrito no caso
contrário.
int putchar(int c);
Idêntica a putc(c, stdout).
int puts(const char *string);
Escreve uma linha de caracteres para o
stream stdout e retirando-a
de string. O caractere terminador 0 é
substituído por mudança de linha (\n). Retorna EOF se ocorrer um
erro.
void rewind(FILE *stream);
Repõe a posição do indicador do
stream stream para o seu início.
int scanf(const char *format, ...);
Lê uma série de caracteres formatados do
stream stdin. Os caracteres a ler são
especificados na cadeia format e nos
argumentos seguintes (ver no capítulo
de Entrada e Saída a descrição de scanf). Retorna
o número de campos lidos e passados para argumentos, ou EOF em caso de
erro.
void setbuf(FILE *stream, char *buffer);
Substitui o buffer de sistema associado ao
stream stream por um outro alocado pelo
utilizador e passado em buffer.
Se buffer for NULL a operação
de stream será não bufferizada.
No caso contrário buffer deverá ter espaço
suficiente para BUFSIZ bytes.
int setvbuf(FILE *stream, char *buffer, int mode, size_t size);
Substitui o buffer de sistema associado ao
stream stream por um outro alocado pelo
utilizador e passado em buffer com
tamanho size (0-32768) bytes.
Se buffer for NULL será automaticamente
alocado um buffer de sistema
com size (0-32768) bytes. O
argumento mode pode ser IOFBF
(full buffering) ou
IONBF (stream não bufferizado independentemente
do valor de buffer ou size).
Retorna 0 se não ocorreu nenhum erro.
int sprintf(char *string, const char *format, ...);
Formata e escreve uma série de caracteres
em string, que deve ter espaço suficiente
para os receber. Os caracteres a escrever são especificados na
cadeia format e nos argumentos seguintes
(ver no capítulo de Entrada e Saída a descrição
de printf). Retorna o número de caracteres escritos, ou um número negativo
em caso de erro.
int sscanf(const char *string, const char *format, ...);
Lê uma série de caracteres formatados da
cadeia string. Os caracteres a ler são
especificados na cadeia format e nos
argumentos seguintes (ver no capítulo
de Entrada e Saída a descrição de scanf). Retorna
o número de campos lidos e passados para argumentos, ou EOF em caso de
erro.
FILE *tmpfile(void);
Cria um ficheiro temporário e devolve um apontador de stream. O ficheiro é
apagado automaticamente quando for fechado. Retorna valor NULL se ocorrer
um erro.
char *tmpnam(char *string);
Gera um nome de ficheiro único capaz de ser aberto sem conflitos com
ficheiros já existentes. O nome é colocado
em string.
Retorna string ou NULL em caso de
erro.
int ungetc(int c, FILE *stream);
Escreve de volta o caractere c (0-255) no
stream stream e limpa a indicação de
fim-de-ficheiro se tiver ocorrido. Retorna EOF se ocorrer um erro ou o
valor do caractere escrito, no caso contrário.
int abs(int n);
Calcula e devolve o valor absoluto do inteiro n.
double acos(double x);
Calcula e devolve valor do arco cujo coseno é x.
O valor devolvido está entre 0 e pi. O valor
de x deverá estar entre -1 e 1.
double asin(double x);
Calcula e devolve o valor do arco cujo seno é x.
O valor de retorno está entre -pi/2 e pi/2. O valor
de x deverá estar entre -1 e 1.
double atan(double x);
Calcula e devolve o valor do arco cuja tangente é x.
O valor devolvido está entre -pi/2 e pi/2.
double atan2(double y, double x);
Calcula e devolve o valor do arco cuja tangente
é y/x. O
valor devolvido está entre -pi e pi. A função usa os valores
de y e x para
determinar o quadrante.
double ceil(double x);
Calcula e devolve (como double) o menor inteiro que é maior ou igual
a x.
double cos(double x);
Calcula e devolve o coseno de x. O valor
de x deverá estar em radianos.
double cosh(double x);
Calcula e devolve o coseno hiperbólico
de x.
div_t div(int numer, int denom);
Calcula e devolve o quociente e o resto da divisão inteira
de numer por denom. O
tipo div_t é uma estrutura contendo dois campos
inteiros: quot e rem.
double exp(double x);
Calcula e devolve o valor da função exponencial com
expoente x.
double fabs(double x);
Calcula e devolve o valor absoluto do número real
(double) x.
double floor(double x);
Calcula e devolve (como double) o maior inteiro que é menor ou igual
a x.
double fmod(double x, double y);
Calcula a divisão inteira
de x/y,
devolvendo apenas o resto.
double frexp(double x, int *expptr);
Decompõe o valor x em mantissa e expoente
de base 2. Devolve a mantissa, sendo o expoente inteiro colocado na
posição apontada por expptr.
long labs(long x);
Calcula e devolve o valor absoluto do número inteiro
longo x.
double ldexp(double x, int exp);
Reconstrói um número real a partir da sua
mantissa (x) e
expoente (exp) de base 2.
ldiv_t ldiv(long numer, long denom);
Calcula e devolve o quociente e o resto da divisão inteira
de numer por denom.
O tipo ldiv_t é uma estrutura contendo dois
campos inteiros
longos: quot e rem.
double log(double x);
Calcula e devolve o valor do logaritmo natural de x.
double log10(double x);
Calcula e devolve o valor do logaritmo de base 10
de x.
double modf(double x, int *intptr);
Decompõe o valor x em parte inteira e
fracionária. Devolve parte fracionária, sendo a parte inteira colocada na
posição apontada por intptr.
double pow(double x, double y);
Calcula e devolve o valor de x elevado
a y.
double rand(void);
Calcula e devolve um valor aleatório entre 0 e RAND_MAX. Deve
usar-se srand() como dado
inicial.
double sin(double x);
Calcula e devolve o seno de x. O valor
de x deverá estar em radianos.
double sinh(double x);
Calcula e devolve o seno hiperbólico de x.
double sqrt(double x);
Calcula e devolve a raiz quadrada de x.
void srand(unsigned int seed);
Inicializa o gerador de números aleatórios. Usar
como seed qualquer inteiro sem sinal. Os
números aleatórios devem ser gerados com chamadas
a rand().
double tan(double x);
Calcula e devolve a tangente de x. O
valor de x deverá estar em
radianos.
double tanh(double x);
Calcula e devolve a tangente hiperbólica
de x.
void *calloc(size_t num, size_t size);
Aloca espaço de memória suficiente para armazenar um vetor
de num elementos, cada um deles
com sizebytes. Os elementos do
vetor são inicializados com 0. Retorna um apontador para a área alocada ou
valor NULL se a memória for insuficiente.
void free(void *memblock);
Liberta uma área de memória, apontada por memblock, e
previamente alocada com uma chamada
a calloc(), malloc() ou realloc().
void *malloc(size_t size); Aloca
espaço de memória suficiente para
armazenar sizebytes. Retorna um
apontador para a área alocada ou valor NULL se a memória for
insuficiente.
void *realloc(void *memblock, size_t size);
Altera o tamanho de um bloco de memória previamente alocado com uma
chamada a calloc(), malloc() ou realloc() e
apontado por memblock para sizebytes. O
conteúdo do sub-bloco de memória que permanece não é alterado. Retorna um
apontador para a área alocada ou valor NULL se a memória for insuficiente
(neste caso o bloco original não é alterado).
void abort(void);
Imprime uma mensagem em stderr e envia ao
processo o sinal SIGABRT. Em resposta a este sinal, normalmente o processo
termina em erro.
void assert(int exp);
Imprime uma mensagem em stderr e
chama abort() se a
expressão exp for avaliada como falsa
(0).
int atexit(void (* func)(void));
Regista para execução, quando o processo terminar normalmente, a
função func. Podem ser registadas mais do que
uma função de terminação com várias chamadas
a atexit(). Neste caso serão
executadas por ordem de registo.
void exit(int status);
Termina normalmente o processo que a invocou com código de
terminação status.
A terminação normal consta da execução das funções de terminação
registadas, se as houver, do esvaziamento dos buffers dos
ficheiros abertos, e ainda do fecho destes.
char *getenv(const char *varname);
Retorna um apontador para a definição da variável de
ambiente varname. Se a variável não existir
devolve valor NULL.
void longjmp(jmp_buf env, int value);
Executa um salto (entre funções) para o local onde foi definido
o bufferjmp_buf env com uma
chamada a setjmp(). O
argumento value especifica o valor
que setjmp() devolve nesse salto.
int putenv(char *envstring);
Cria, modifica ou remove uma variável de ambiente. O
argumento envstring deve apontar para uma
cadeia de caracteres com a
forma varname=string.
Se varname existir, é modificada; se não
existir, é criada; se existir e se string não
estiver presente (o sinal de = terá de
estar) é removida.
int raise(int sig);
Envia ao processo que está a executar, o
sinal sig. Se tiver sido instalada uma
função de tratamento do sinal
(com signal()), essa função é
invocada; caso contrário é executada a ação por defeito para o sinal
(normalmente termina o processo). Retorna 0 se não ocorrer nenhum erro.
int setjmp(jmp_buf env);
Marca o local da chamada definindo
um bufferjmp_buf env. Esse
local pode depois ser usado como alvo de uma chamada
a longjmp(), mesmo de outra
função. Retorna 0 quando da chamada que define o buffer; devolve
o valor especificado
em longjmp() como resultado
desse salto. (Assim que se efectua um salto é como
se setjmp() acabasse de devolver com
o valor especificado).
void (*signal(int sig, void (*func)(int sign)))(int sign);
Regista a função func como sendo a que
vai tratar o sinal sig daqui para a
frente. Retorna um apontador para a função que tratava esse sinal
anteriormente. As funções de tratamento de um sinal devem aceitar um
argumento inteiro e não devolver nada. Em vez destas funções podem ser
usadas as constantes SIG_DFL (corresponde à ação por defeito definida no
sistema operativo) e SIG_IGN (corresponde a ignorar o sinal). A
função signal() também pode devolver
uma destas constantes.
int system(const char *command);
Executa o comando contido na cadeia de
caracteres command como se fosse invocado
a partir de uma consola. Retorna 0 se não ocorrer nenhum erro.
void *bsearch(const void *key, const void *base, size_t num, size_t width, int (*compare)(const void *elem1, const void *elem2));
Executa uma pesquisa binária num vetor
de num elementos passado
por base, em que cada elemento
tem widthbytes. O valor a pesquisar
é passado por key. Esta função necessita que
lhe seja passada uma outra função (compare)
que aceite 2 apontadores para elementos
de widthbytes e retorne um
valor que indique qual é o
maior (<0 se elem1 menor do
que elem2, =0 se elem1 for idêntico
a elem2, >0 se elem1 for maior do
que elem2).
Retorna um apontador para a posição de ocorrência
de key no
vetor base, ou valor NULL
se key não for encontrado.
void qsort(void *base, size_t num, size_t width, int (*compare)(const void *elem1, const void *elem2));
Implementa uma ordenação, utilizando o algoritmo quicksort, num vetor
de num elementos passado
por base, em que cada elemento
tem widthbytes. Esta função
necessita que lhe seja passada uma outra função
(compare) que aceite 2 apontadores para
elementos de widthbytes e
retorne um valor que indique qual é o maior
(<0 se elem1 menor do que elem2, =0
se elem1 for idêntico a elem2, >0
se elem1 for maior do que elem2).
Todas estas funções esperam que as cadeias de caracteres estejam terminadas
com o caractere 0, como é normal em C.
char *strcat(char *string1, const char *string2);
Concatena o conteúdo
de string2 a string1,
que deve ter espaço suficiente para isso.
Retorna string1.
char *strchr(const char *string, int c);
Procura a primeira ocorrência de c (0-255)
na cadeia apontada por string. Retorna um
apontador para essa primeira ocorrência, ou valor NULL se não existir.
int strcmp(const char *string1, const char *string2);
Compara as duas
cadeias string1 e string2.
Retorna <0 se string1 for menor do
que string2; =0
se string1 for idêntico
a string2; e >0
se string1 for maior do
que string2.
char *strcpy(char *string1, const char *string2);
Copia o conteúdo
de string2 para string1,
que deve ter espaço suficiente para isso.
Retorna string1.
size_t strcspn(const char *string1, const char *string2);
Retorna o índice do primeiro caractere
de string1 que pertence ao conjunto de
caracteres definido em string2. Se não
existir nenhum devolve o comprimento
de string1.
size_t strlen(const char *string);
Retorna o comprimento de string.
char *strncat(char *string1, const char *string2, size_t count);
Idêntica a strcat(),
mas concatenando o máximo de count caracteres.
int strncmp(const char *string1, const char *string2, size_t count);
Idêntica a strncmp(),
mas comparando o máximo de count caracteres.
char *strncpy(char *string1, const char *string2, size_t count);
Idêntica a strcpy(),
mas copiando o máximo de count caracteres.
char *strnset(char *string, int c, size_t count);
Idêntica a strset(), mas
inicializando o máximo de count caracteres.
char *strrchr(const char *string, int c);
Procura a última ocorrência de c (0-255) na
cadeia apontada por string. Retorna um
apontador para essa última ocorrência, ou valor NULL se não existir.
char *strnset(char *string, int c);
Inicializa todos os caracteres de string com
o valor c (0-255). O terminador 0 não é alterado.
char *asctime(const struct tm *timeptr);
Converte o instante descrito numa
estrutura struct tm (que pode ser obtida
através de chamadas
a gmtime() ou localtime()),
passada através do apontador timeptr, para
uma cadeia de caracteres contendo dia da semana, dia, mês, ano e hora.
A string resultante contém exatamente 26 caracteres.
clock_t clock(void);
Retorna o número de ticks que o processo que chama a função já
gastou no processador. A constante CLOCKS_PER_SEC contém o número
de ticks por segundo. A função pode devolver -1 se não for
possível obter o número de ticks do processo.
char *ctime(const time_t *timer);
Converte o instante descrito num valor time_t (que
pode ser obtido através da chamada
a time()), passado através do
apontador timer, para uma cadeia de
caracteres contendo dia da semana, dia, mês, ano e hora.
A string resultante contém exatamente 26 caracteres.
double difftime(time_t timer1, time_t timer0);
Calcula, em segundos, a diferença entre os instantes timer0
e timer1 (timer1-timer0) descritos
em valores time_t (que podem ser obtidos através
de chamadas a time()).
struct tm *gmtime(const time_t *timer);
Converte o instante descrito num
valor time_t (que pode ser obtido através da
chamada a time()), passado
através do apontador timer, para uma
estrutura do tipo struct tm, descrita
em time.h.
struct tm *localtime(const time_t *timer);
Converte o instante descrito num valor time_t
(que pode ser obtido através da chamada a time()),
passado através do apontador timer, para uma estrutura do
tipo struct tm, descrita
em time.h,
eventualmente corrigido para a hora local.
time_t time(time_t *timer);
Retorna o número de segundos decorridos desde a meia-noite (00:00:00) do
dia 31 de Dezembro de 1899. A função devolve esse número de segundos e
também preenche a posição de memória apontada
por timer.
Para auxiliar o tratamento e a deteção de erros na chamada a funções da
biblioteca standard, algumas destas funções usam uma variável global
denominada errno. Esta variável pode ser usada em qualquer
programa de duas formas distintas:
Comparando o valor de errno com as constantes definidas
no ficheiro de inclusão errno.h;
Utilizando as funções da biblioteca
standard perror() ou strerror(). A
função perror() escreve uma
mensagem em stderr enquanto
que strerror() a coloca numa
cadeia de caracteres.
Uma vez que se determine a ocorrência de um erro, a
variável errno deverá ser utilizada imediatamente
(diretamente ou através
de perror() ou strerror()).
Caso contrário o valor de errno poderá ser modificado por
outras chamadas.
void perror(const char *string);
Imprime uma mensagem em stderr. Primeiro
é impressa a cadeia de caracteres string,
seguida de :, seguida ainda de uma
mensagem descrevendo o erro contido em errno nesse
momento.
char *strerror(int errnum);
Retorna um apontador para uma mensagem descrevendo o erro passado
em errnum. Geralmente deverá ser passada no
argumento errnum a variável
global errno, logo a seguir à ocorrência de um erro.
