<?xml version="1.0" encoding="utf-8"?>
<!-- generator="FeedCreator 1.7.2-ppt DokuWiki" -->
<?xml-stylesheet href="http://www.br-c.org/lib/exe/css.php?s=feed" type="text/css"?>
<rdf:RDF
    xmlns="http://purl.org/rss/1.0/"
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
    xmlns:dc="http://purl.org/dc/elements/1.1/">
    <channel rdf:about="http://www.br-c.org/feed.php">
        <title>BR-C - Wiki para Programação em C.</title>
        <description></description>
        <link>http://www.br-c.org/</link>
        <image rdf:resource="http://www.br-c.org/lib/images/favicon.ico" />
       <dc:date>2010-09-04T20:40:43-07:00</dc:date>
        <items>
            <rdf:Seq>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=accept&amp;rev=1209136719&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=alocacao_memoria&amp;rev=1235400679&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=arquivos_funcoes_de_nivel_2&amp;rev=1207682215&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=atexit&amp;rev=1210889141&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=bind&amp;rev=1209136510&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=break&amp;rev=1210720657&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=case_sensitive&amp;rev=1241804569&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=close&amp;rev=1209130555&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=comandos_repeticao&amp;rev=1210024432&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=comandos_selecao&amp;rev=1209871449&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=comentarios&amp;rev=1241785953&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=connect&amp;rev=1209130050&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=const&amp;rev=1209867849&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=continue&amp;rev=1210721630&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=creat&amp;rev=1209132865&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=daemon&amp;rev=1235397356&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=definicao_funcao&amp;rev=1210724236&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=dowhile&amp;rev=1210720147&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=editor_vi&amp;rev=1235138946&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=entrada_saida&amp;rev=1209754117&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=errno&amp;rev=1209086067&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=estrutura_programa&amp;rev=1267046584&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=exemplo_eco&amp;rev=1235307744&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=exemplo_tftp&amp;rev=1209485615&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=exercicios_resolvidos&amp;rev=1242007755&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=exit&amp;rev=1210722490&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=extern&amp;rev=1210888646&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=for&amp;rev=1210117593&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=fork&amp;rev=1235307020&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=gcc_linux&amp;rev=1235135149&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=getchar&amp;rev=1210115282&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=gethostbyname&amp;rev=1209130613&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=getpeername&amp;rev=1236816468&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=goto&amp;rev=1210722043&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=htonl&amp;rev=1209129034&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=if&amp;rev=1209872143&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=inet_aton&amp;rev=1209136627&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=listen&amp;rev=1209129985&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=lseek&amp;rev=1209132444&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=main&amp;rev=1241804038&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=open&amp;rev=1209132148&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=operador_ternario&amp;rev=1209900633&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=operadores&amp;rev=1241806313&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=padronizacao&amp;rev=1241785516&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=palavras_reservadas&amp;rev=1241805732&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=perror&amp;rev=1209137460&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=ponteiros&amp;rev=1242092179&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=pre_compilacao&amp;rev=1241731330&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=printf&amp;rev=1210114228&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=processos&amp;rev=1234639053&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=programas_uteis&amp;rev=1241998374&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=putchar&amp;rev=1210114539&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=read&amp;rev=1209131282&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=recv&amp;rev=1209130507&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=rede&amp;rev=1235135286&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=remove&amp;rev=1209132757&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=rename&amp;rev=1209132823&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=return&amp;rev=1210888380&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=scanf&amp;rev=1210114963&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=send&amp;rev=1209136887&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=shutdown&amp;rev=1209135981&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=sinal&amp;rev=1235337203&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=sizeof&amp;rev=1209144982&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=sleep&amp;rev=1235337552&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=snprintf&amp;rev=1242007267&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=sockaddr_in&amp;rev=1209130743&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=socket&amp;rev=1225231757&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=sprintf&amp;rev=1242007289&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=sscanf&amp;rev=1242005616&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=start&amp;rev=1242092330&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=static&amp;rev=1210888771&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=strcat&amp;rev=1241810062&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=strcmp&amp;rev=1241810106&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=strcpy&amp;rev=1241809597&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=strerror&amp;rev=1209132960&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=strings&amp;rev=1242005167&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=strlen&amp;rev=1241810036&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=strncat&amp;rev=1242006143&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=strncmp&amp;rev=1242006927&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=strncpy&amp;rev=1242006623&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=strstr&amp;rev=1242089884&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=strtok&amp;rev=1242090517&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=switch&amp;rev=1210024514&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=threads_posix&amp;rev=1234810914&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=tipos_dados&amp;rev=1234643546&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=typedef&amp;rev=1209143946&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=unlink&amp;rev=1209132702&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=variavel_definicao&amp;rev=1209143356&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=vetor_matriz&amp;rev=1211909830&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=wait&amp;rev=1235309469&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=waitpid&amp;rev=1235336889&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=while&amp;rev=1210117899&amp;do=diff"/>
                <rdf:li rdf:resource="http://www.br-c.org/doku.php?id=write&amp;rev=1242011327&amp;do=diff"/>
            </rdf:Seq>
        </items>
    </channel>
    <image rdf:about="http://www.br-c.org/lib/images/favicon.ico">
        <title>BR-C - Wiki para Programação em C.</title>
        <link>http://www.br-c.org/</link>
        <url>http://www.br-c.org/lib/images/favicon.ico</url>
    </image>
    <item rdf:about="http://www.br-c.org/doku.php?id=accept&amp;rev=1209136719&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-04-25T08:18:39-07:00</dc:date>
        <title>accept</title>
        <link>http://www.br-c.org/doku.php?id=accept&amp;rev=1209136719&amp;do=diff</link>
        <description>Sintaxe:

int accept(int socket, struct sockaddr *addr, socklen_t *addrlen);


----------


Após ter utilizado a função listen para habilitar as conexões, é necessário aceitar a conexões. A função accept aceita as conexões efetuadas pelos clientes. Deve ser passado para a função o socket aberto, a estrutura que irá receber os dados do cliente e o tamanho do endereço. A função irá retornar um descritor para a conexão aceita ou –1 se houve erro.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=alocacao_memoria&amp;rev=1235400679&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-02-23T06:51:19-07:00</dc:date>
        <title>alocacao_memoria</title>
        <link>http://www.br-c.org/doku.php?id=alocacao_memoria&amp;rev=1235400679&amp;do=diff</link>
        <description>Funções

	*  malloc
	*  free
	*  calloc
	*  realloc
	*  memset
	*  memcpy
	*  memcmp
	*  memmove</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=arquivos_funcoes_de_nivel_2&amp;rev=1207682215&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-04-08T12:16:55-07:00</dc:date>
        <title>arquivos_funcoes_de_nivel_2</title>
        <link>http://www.br-c.org/doku.php?id=arquivos_funcoes_de_nivel_2&amp;rev=1207682215&amp;do=diff</link>
        <description>Como a linguagem C foi originalmente desenvolvida sobre o sistema operacional Unix, ela inclui um segundo sistema de E/S com arquivos em disco que reflete basicamente as rotinas de arquivo em disco de baixo nível do Unix. O sistema de arquivo tipo Unix usa funções que são separadas das funções do sistema de arquivo com buffer.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=atexit&amp;rev=1210889141&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-05-15T15:05:41-07:00</dc:date>
        <title>atexit</title>
        <link>http://www.br-c.org/doku.php?id=atexit&amp;rev=1210889141&amp;do=diff</link>
        <description>Sintaxe:

int atexit(void (*func)(void))


Arquivo Header: stdlib.h


----------

Conforme definido no ANSI C, pode-se registrar até 32 funções que serão automaticamente executadas quando um processo termina. Estas funções são chamadas de exit handlers e são registradas através da chamada à função atexit.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=bind&amp;rev=1209136510&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-04-25T08:15:10-07:00</dc:date>
        <title>bind</title>
        <link>http://www.br-c.org/doku.php?id=bind&amp;rev=1209136510&amp;do=diff</link>
        <description>Sintaxe:

int bind(int sockfd, const struct sockaddr *my_addr, socklen_t addrlen );


----------


A função bind associa o socket criado a porta local do sistema operacional. Nesta associação é verificado se a porta já não está sendo utilizada por algum outro processo. Será através desta associação (porta) que o programa irá receber dados (bytes) de outros programas. É passada para a função a estrutura criada anteriormente assim como o socket criado. A função bind retorna 0 (zero) em caso de suc…</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=break&amp;rev=1210720657&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-05-13T16:17:37-07:00</dc:date>
        <title>break</title>
        <link>http://www.br-c.org/doku.php?id=break&amp;rev=1210720657&amp;do=diff</link>
        <description>Sintaxe:



while (condição)
{
   bloco de comandos;
   if( condição )
   {
      break;
   }
}


OU


for (condição)
{
   bloco de comandos;
   if( condição )
   {
      break;
   }
}



OU


do
{
   bloco de comandos;
   if( condição )
   {
      break;
   }
}
while(condição)</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=case_sensitive&amp;rev=1241804569&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-05-08T10:42:49-07:00</dc:date>
        <title>case_sensitive</title>
        <link>http://www.br-c.org/doku.php?id=case_sensitive&amp;rev=1241804569&amp;do=diff</link>
        <description>Um ponto importante da linguagem C e que deve ser ressaltado: o C é Case Sensitive, isto é, maiúsculas e minúsculas fazem diferença. Se declarar uma variável com o nome soma ela será diferente de Soma, SOMA, SoMa ou sOmA. Da mesma maneira, os comandos do C if e for, por exemplo, só podem ser escritos em minúsculas pois senão o compilador não irá interpretá-los como sendo comandos, mas sim como variáveis.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=close&amp;rev=1209130555&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-04-25T06:35:55-07:00</dc:date>
        <title>close</title>
        <link>http://www.br-c.org/doku.php?id=close&amp;rev=1209130555&amp;do=diff</link>
        <description>Sintaxe:

int close (int iFileDescriptor);


----------


Quando se fecha um arquivo, todas as operações de saída pendentes em memória são gravadas no disco e as estruturas de controle interno são liberadas pelo sistema operacional.

Quando um processo termina normalmente com a chamada à função exit ou executa-se o último comando da rotina main do programa, todos os arquivos abertos pelo mesmo são fechados automaticamente pelo sistema operacional.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=comandos_repeticao&amp;rev=1210024432&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-05-05T14:53:52-07:00</dc:date>
        <title>comandos_repeticao</title>
        <link>http://www.br-c.org/doku.php?id=comandos_repeticao&amp;rev=1210024432&amp;do=diff</link>
        <description>*  Comando for
	*  Comando while
	*  Comando do..while
	*  Comando break
	*  Comando continue
	*  Comando goto
	*  Comando exit</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=comandos_selecao&amp;rev=1209871449&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-05-03T20:24:09-07:00</dc:date>
        <title>comandos_selecao</title>
        <link>http://www.br-c.org/doku.php?id=comandos_selecao&amp;rev=1209871449&amp;do=diff</link>
        <description>*  Comando if
	*  Comando if..else
	*  Operador ?:
	*  Comando switch..case


 --- Marcos Laureano 2008/05/03 20:22</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=comentarios&amp;rev=1241785953&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-05-08T05:32:33-07:00</dc:date>
        <title>comentarios</title>
        <link>http://www.br-c.org/doku.php?id=comentarios&amp;rev=1241785953&amp;do=diff</link>
        <description>Os comentários de um programa devem ser colocados entre /* e */. O compilador ANSI C aceita os comentários entre /* e */. Quaisquer textos colocados entre estes dois símbolos serão ignorados pelo compilador.

Deve-se colocar um comentário no início de cada função do programa explicando a função, seu funcionamento, seus parâmetros de entrada e quais são os possíveis retornos que esta função pode devolver.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=connect&amp;rev=1209130050&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-04-25T06:27:30-07:00</dc:date>
        <title>connect</title>
        <link>http://www.br-c.org/doku.php?id=connect&amp;rev=1209130050&amp;do=diff</link>
        <description>Sintaxe:

int connect(int sockfd, const struct sockaddr * serv_addr, socklen_t addrlen);


----------


A função connect inicia uma conexão socket do lado do cliente, não é necessário associar uma parte no cliente. Na estrutura passada é informada as informações relacionadas ao servidor (destino). A função retorna 0 (zero) se a conexão foi bem sucedida ou –1 se houve erro.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=const&amp;rev=1209867849&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-05-03T19:24:09-07:00</dc:date>
        <title>const</title>
        <link>http://www.br-c.org/doku.php?id=const&amp;rev=1209867849&amp;do=diff</link>
        <description>Muitas vezes é desejável que além de uma variável possuir um valor pré-definido, quer-se que este valor não seja modificado por nenhuma função de um programa.

Para que isto aconteça deve-se colocar a palavra const antes da definição da variável, indicando ao compilador que quando detectar uma mudança de valor da variável, seja emitida uma mensagem de erro.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=continue&amp;rev=1210721630&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-05-13T16:33:50-07:00</dc:date>
        <title>continue</title>
        <link>http://www.br-c.org/doku.php?id=continue&amp;rev=1210721630&amp;do=diff</link>
        <description>Sintaxe:



while(condição)
{
   bloco de comandos 01;
   if( condição )
   {
      continue;
   }
   bloco de comandos 02;
}


OU


for(condição)
{
   bloco de comandos 01;
   if( condição )
   {
      continue;
   }
   bloco de comandos 02;
}</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=creat&amp;rev=1209132865&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-04-25T07:14:25-07:00</dc:date>
        <title>creat</title>
        <link>http://www.br-c.org/doku.php?id=creat&amp;rev=1209132865&amp;do=diff</link>
        <description>Sintaxe:

int creat(const char * path, mode_t mode);


----------


Quando se quer abrir um arquivo e criar o mesmo caso não exista ou truncar o mesmo caso já exista pode-se usar a função creat.

O arquivo será aberto somente para gravação pois esta função é equivalente a chamada da função open com os parâmetros abaixo.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=daemon&amp;rev=1235397356&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-02-23T05:55:56-07:00</dc:date>
        <title>daemon</title>
        <link>http://www.br-c.org/doku.php?id=daemon&amp;rev=1235397356&amp;do=diff</link>
        <description>Conceito de daemon

Em várias situações precisa-se que um processo fique em execução continuamente (eternamente) em uma máquina. A estes processos dá-se o nome de daemons ou serviços. 

Geralmente são programas que são iniciados assim que o sistema operacional é inicializado. Coloca-se a chamada dos daemons nos arquivos de configuração para que os mesmos sejam ativados automaticamente durante o processo de boot do sistema. Um daemon só deve ser cancelado quando o sistema operacional está encerra…</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=definicao_funcao&amp;rev=1210724236&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-05-13T17:17:16-07:00</dc:date>
        <title>definicao_funcao</title>
        <link>http://www.br-c.org/doku.php?id=definicao_funcao&amp;rev=1210724236&amp;do=diff</link>
        <description>*  Comando return
	*  Definição extern
	*  Definição static
	*  Função atexit

Criação de Funções


As técnicas de programação dizem que, sempre que possível, evite códigos extensos, separando o mesmo em funções, visando um fácil entendimento e uma manutenção facilitada. De acordo com a técnica, devem-se agrupar códigos correlatos em uma função.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=dowhile&amp;rev=1210720147&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-05-13T16:09:07-07:00</dc:date>
        <title>dowhile</title>
        <link>http://www.br-c.org/doku.php?id=dowhile&amp;rev=1210720147&amp;do=diff</link>
        <description>Sintaxe:



do
{
   bloco de comandos
} 
while (condição);


----------

O comando do...while diferencia-se do comando while somente em um detalhe. O bloco de comando indicado é sempre executado pelo menos uma vez. Após a execução do bloco a condição é testada. Caso seja verdadeira, o bloco continua a ser executado.
A execução passará para o próximo comando somente quando a condição retornar falso.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=editor_vi&amp;rev=1235138946&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-02-20T06:09:06-07:00</dc:date>
        <title>editor_vi</title>
        <link>http://www.br-c.org/doku.php?id=editor_vi&amp;rev=1235138946&amp;do=diff</link>
        <description>Comandos no teclado

Retirado da página do Aurélio

[Mapa do teclado]</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=entrada_saida&amp;rev=1209754117&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-05-02T11:48:37-07:00</dc:date>
        <title>entrada_saida</title>
        <link>http://www.br-c.org/doku.php?id=entrada_saida&amp;rev=1209754117&amp;do=diff</link>
        <description>São funções que permitem realizar a leitura/escrita de informações a partir da/para entrada padrão. Para trabalhar adequadamente com estas e outras funções é necessário conhecer os formatadores de tipo de dados e algumas constantes reconhecidas pelo compilador.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=errno&amp;rev=1209086067&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-04-24T18:14:27-07:00</dc:date>
        <title>errno</title>
        <link>http://www.br-c.org/doku.php?id=errno&amp;rev=1209086067&amp;do=diff</link>
        <description>A maioria das funções devolve somente uma indicação de que houve erro em sua execução, seja através de um valor negativo, seja através de um ponteiro nulo. 

O erro ocorrido na função é armazenado na variável errno, definida internamente no sistema e disponibilizada no programa através da colocação do arquivo errno.h na compilação do programa. Dentro deste arquivo header também são definidas as constantes mnemônicas dos possíveis erros que podem acontecer nas funções.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=estrutura_programa&amp;rev=1267046584&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2010-02-24T13:23:04-07:00</dc:date>
        <title>estrutura_programa</title>
        <link>http://www.br-c.org/doku.php?id=estrutura_programa&amp;rev=1267046584&amp;do=diff</link>
        <description>Um programa básico em C possui os seguintes blocos:



Um programa C deve possuir uma certa estrutura para ser válido. Basicamente têm-se três blocos distintos nos programas. Inicialmente deve-se ter uma seção onde serão feitos os includes necessários para o programa.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=exemplo_eco&amp;rev=1235307744&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-02-22T05:02:24-07:00</dc:date>
        <title>exemplo_eco</title>
        <link>http://www.br-c.org/doku.php?id=exemplo_eco&amp;rev=1235307744&amp;do=diff</link>
        <description>Um servidor de ECO simplesmente recebe uma mensagem e retorna a mesma mensagem (eco) sem modificações.

Cliente TCP de ECO

Este cliente recebe uma mensagem via linha de comando e envia 10 vezes (1 por segundo) para o servidor de eco.


#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;strings.h&gt;
#include &lt;errno.h&gt;
#include &lt;sys/types.h&gt;
#include &lt;sys/socket.h&gt;
#include &lt;netinet/in.h&gt;
#include &lt;arpa/inet.h&gt;
#include &lt;unistd.h&gt;
#include &lt;string.h&gt;

int main(int argc, char ** argv )
{
   int iSock;…</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=exemplo_tftp&amp;rev=1209485615&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-04-29T09:13:35-07:00</dc:date>
        <title>exemplo_tftp</title>
        <link>http://www.br-c.org/doku.php?id=exemplo_tftp&amp;rev=1209485615&amp;do=diff</link>
        <description>O Trivial File Transfer Protocol (ou apenas TFTP) é um protocolo de transferência de arquivos, muito simples, semelhante ao FTP.

O TFTP é usualmente utilizado para transferir pequenos arquivos entre hosts numa rede. O TFPT trabalha com o protocolo de transporte UDP, o servidor TFTP recebe conexões na porta 69 e o tamanho de cada bloco é de 512 bytes.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=exercicios_resolvidos&amp;rev=1242007755&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-05-10T19:09:15-07:00</dc:date>
        <title>exercicios_resolvidos</title>
        <link>http://www.br-c.org/doku.php?id=exercicios_resolvidos&amp;rev=1242007755&amp;do=diff</link>
        <description>Esta página irá conter exercícios de entrada e saída, estruturas condicionais, estruturas de repetição, funções e vetores e matrizes. As respostas serão colocadas em forma de algoritmo (nomenclatura do VisualAlg) e sempre com o código C correspondente.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=exit&amp;rev=1210722490&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-05-13T16:48:10-07:00</dc:date>
        <title>exit</title>
        <link>http://www.br-c.org/doku.php?id=exit&amp;rev=1210722490&amp;do=diff</link>
        <description>Sintaxe:

void exit( int valor_de_retorno);

Arquivo header:  

stdlib.h


----------

A função exit deve ser usada quando se quer terminar a execução do programa, retornando para o sistema operacional um indicativo. Tanto em Unix/Linux como em Windows/DOS existem maneiras de se obter o número retornado.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=extern&amp;rev=1210888646&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-05-15T14:57:26-07:00</dc:date>
        <title>extern</title>
        <link>http://www.br-c.org/doku.php?id=extern&amp;rev=1210888646&amp;do=diff</link>
        <description>Sintaxe:

extern tipo_variável nome_variável


----------

Quando o sistema é separado em vários programas, pode-se ter o problema de acesso a certas variáveis globais, pois a definição da mesma pode estar em um programa fonte e é necessário acessar estas variáveis em outro programa fonte.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=for&amp;rev=1210117593&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-05-06T16:46:33-07:00</dc:date>
        <title>for</title>
        <link>http://www.br-c.org/doku.php?id=for&amp;rev=1210117593&amp;do=diff</link>
        <description>Sintaxe:



   for(inicialização;
       condição de parada;
       incremento)
   {
      bloco de comandos
   }


----------


Quando se quer executar um bloco de comando um número determinado de vezes deve-se utilizar o comando for. Na sua declaração, o comando for determina três áreas distintas:</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=fork&amp;rev=1235307020&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-02-22T04:50:20-07:00</dc:date>
        <title>fork</title>
        <link>http://www.br-c.org/doku.php?id=fork&amp;rev=1235307020&amp;do=diff</link>
        <description>Sintaxe:

 #include &lt;unistd.h&gt;


pid_t fork(void);


----------

A função fork é uma função que duplica o processo atual dentro do sistema operacional. O processo que inicialmente chamou a função fork é chamado de processo pai. O novo processo criado pela função fork é chamado de processo filho. Todas as áreas do processo são duplicadas dentro do sistema operacional (código, dados, pilha, memória dinâmica).</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=gcc_linux&amp;rev=1235135149&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-02-20T05:05:49-07:00</dc:date>
        <title>gcc_linux</title>
        <link>http://www.br-c.org/doku.php?id=gcc_linux&amp;rev=1235135149&amp;do=diff</link>
        <description>GCC


Compilar é transformar um arquivo legível para o homem (chamado de código-fonte, source file em inglês) para um arquivo legível para a máquina (binário, binary). Quem faz esse trabalho é o compilador. 

O compilador C/C++ padrão no Linux é o gcc. Muitas distribuições vêm o gcc incluído. O Compilador gcc é um dos compiladores mais versáteis e avançados existentes. O gcc suporta todos os padrões modernos do C atualmente usados, como o padrão ANSI C, assim como muitas extensões específicas do…</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=getchar&amp;rev=1210115282&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-05-06T16:08:02-07:00</dc:date>
        <title>getchar</title>
        <link>http://www.br-c.org/doku.php?id=getchar&amp;rev=1210115282&amp;do=diff</link>
        <description>Sintaxe:

int getchar();

Header:

stdio.h


----------

Quando for necessário realizar a entrada de um único caractere pode ser utilizado esta função. Ela lê um caractere do terminal e devolve o código ASCII do mesmo. Sendo assim é possível assinalar o valor da função para uma variável do tipo caractere (char).</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=gethostbyname&amp;rev=1209130613&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-04-25T06:36:53-07:00</dc:date>
        <title>gethostbyname</title>
        <link>http://www.br-c.org/doku.php?id=gethostbyname&amp;rev=1209130613&amp;do=diff</link>
        <description>Sintaxe:

struct hostent * gethostbyname(const char * name);


----------


A função gethostbyname retorna a partir de um nome passado o endereço IP associado ao nome. A função realizar o papel de um DNS. Ela retorna um ponteiro para uma estrutura ou NULL em caso de erro.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=getpeername&amp;rev=1236816468&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-03-11T17:07:48-07:00</dc:date>
        <title>getpeername</title>
        <link>http://www.br-c.org/doku.php?id=getpeername&amp;rev=1236816468&amp;do=diff</link>
        <description>Sintaxe:

#include &lt;sys/socket.h&gt;


int getpeername(int iSocket, struct sockaddr * stNome, socklen_t * iTamanho_nome);

----------

A função getpeername retorna o nome de um cliente que conectou­-se ao servidor. A função retorna 0 (zero) em caso de sucesso ou –1 se houve algum erro.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=goto&amp;rev=1210722043&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-05-13T16:40:43-07:00</dc:date>
        <title>goto</title>
        <link>http://www.br-c.org/doku.php?id=goto&amp;rev=1210722043&amp;do=diff</link>
        <description>Sintaxe:



bloco de comandos;
...
goto saida;
...
saida: comandos
...


----------


O comando goto realiza o desvio da execução para o comando que possuir o label indicado. Apesar de existir este comando, todas as boas técnicas de programação dizem que seu uso deve ser evitado.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=htonl&amp;rev=1209129034&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-04-25T06:10:34-07:00</dc:date>
        <title>htonl</title>
        <link>http://www.br-c.org/doku.php?id=htonl&amp;rev=1209129034&amp;do=diff</link>
        <description>Sintaxe:

uint32_t htonl(uint32_t hostlong);

uint16_t htons(uint16_t hostshort);

uint32_t ntohl(uint32_t netlong);

uint16_t ntohs(uint16_t netshort);


----------

As funções convertem e retornam um o endereço passado como parâmetro para um ordenamento de byte significativo. Sendo que as funções htons e htonl retornam o valor na ordem de bytes da rede e as funções ntohs e ntohl retornam o valor na ordem de bytes de um host.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=if&amp;rev=1209872143&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-05-03T20:35:43-07:00</dc:date>
        <title>if</title>
        <link>http://www.br-c.org/doku.php?id=if&amp;rev=1209872143&amp;do=diff</link>
        <description>Sintaxe:



   if (condição)
   {
      bloco de comandos
   }


----------

O comando if funciona da seguinte maneira. Primeiramente a expressão da condição é avaliada. Caso o resultado seja verdadeiro (diferente de zero, o que significa verdadeiro em C) o bloco de comandos entre {} é executado. Caso a expressão resulte em falso (igual a zero) o bloco de comandos não será executado.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=inet_aton&amp;rev=1209136627&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-04-25T08:17:07-07:00</dc:date>
        <title>inet_aton</title>
        <link>http://www.br-c.org/doku.php?id=inet_aton&amp;rev=1209136627&amp;do=diff</link>
        <description>Sintaxe:

int inet_aton(const char * cp, struct in_addr *in);

in_addr_t inet_addr(const char * cp);

char * inet_ntoa(struct in_addr in);


----------

A função inet_aton converte o endereço passado (inclusive com pontos) para uma estrutura de endereços (binário) válido. Retorna um valor maior que 0 (zero) se a conversão ocorreu ou 0 (zero) se houve algum erro.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=listen&amp;rev=1209129985&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-04-25T06:26:25-07:00</dc:date>
        <title>listen</title>
        <link>http://www.br-c.org/doku.php?id=listen&amp;rev=1209129985&amp;do=diff</link>
        <description>Sintaxe:

int listen(int iSocket, int backlog);


----------


Após o socket (função socket) ter sido criada e uma porta associada (função bind) é necessário habilitar o socket para receber as conexões. A função listen faz justamente este papel ou seja, habilita que o programa servidor receba conexões de um programa cliente. Deve-se passar o descritor do socket aberto e a quantidade de conexões que podem ficar pendentes até que o programa trate todas as conexões anteriores. A função retorna 0 (z…</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=lseek&amp;rev=1209132444&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-04-25T07:07:24-07:00</dc:date>
        <title>lseek</title>
        <link>http://www.br-c.org/doku.php?id=lseek&amp;rev=1209132444&amp;do=diff</link>
        <description>Sintaxe:

off_t lseek(int iFileDescritor,  off_t offset, int whence);


----------


Como visto anteriormente, tanto a leitura como a gravação de informações no arquivo é realizada a partir da posição atual do arquivo.

Com a função lseek pode-se posicionar em um determinado ponto do arquivo antes da leitura ou gravação de dados. O primeiro byte do arquivo é a posição 0 (zero).</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=main&amp;rev=1241804038&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-05-08T10:33:58-07:00</dc:date>
        <title>main</title>
        <link>http://www.br-c.org/doku.php?id=main&amp;rev=1241804038&amp;do=diff</link>
        <description>Todo programa em C deve ter uma função chamada main. É por esta função que será iniciada a execução do programa. Deve-se especificar o tipo da saída da função, que pode ser int ou void. 

Caso seja colocado int, o valor retornado pela função main estará disponível teste no sistema operacional.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=open&amp;rev=1209132148&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-04-25T07:02:28-07:00</dc:date>
        <title>open</title>
        <link>http://www.br-c.org/doku.php?id=open&amp;rev=1209132148&amp;do=diff</link>
        <description>Sintaxe:

int open(const char * path, int oflag, /* [mode_t mode]*/);


----------


Para se abrir um arquivo deve-se chamar a função open. A função recebe o nome do arquivo como parâmetro juntamente com o flag indicando o modo de abertura e flags informando opções adicionais de abertura e/ou tratamento de arquivo. Pode-se colocar todo o caminho do arquivo juntamente com o seu nome.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=operador_ternario&amp;rev=1209900633&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-05-04T04:30:33-07:00</dc:date>
        <title>operador_ternario</title>
        <link>http://www.br-c.org/doku.php?id=operador_ternario&amp;rev=1209900633&amp;do=diff</link>
        <description>Sintaxe:

(condição ? bloco_verdadeiro : bloco_falso)


----------

O operador ? : é uma maneira simplificada de escrever um if...else. Apesar de possuir a mesma funcionalidade não se deve usar este operador quando os comandos envolvidos são complexos.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=operadores&amp;rev=1241806313&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-05-08T11:11:53-07:00</dc:date>
        <title>operadores</title>
        <link>http://www.br-c.org/doku.php?id=operadores&amp;rev=1241806313&amp;do=diff</link>
        <description>Operadores Aritméticos
 Operador  Operação   +   Adição   -   Subtração   *   Multiplicação   /   Divisão   %   Módulo (resto da divisão) 

Todas estas operações exigem 2 operandos (números).

Operadores Unários
 Operador  Operação   ++   Incremento   --   Decremento 

A posição relativa destes operadores em relação a variável influencia o seu funcionamento. Se os operadores forem colocados antes da variável em uma expressão, inicialmente será efetuado o incremento e depois será utilizado este n…</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=padronizacao&amp;rev=1241785516&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-05-08T05:25:16-07:00</dc:date>
        <title>padronizacao</title>
        <link>http://www.br-c.org/doku.php?id=padronizacao&amp;rev=1241785516&amp;do=diff</link>
        <description>A linguagem de programação C é uma linguagem de programação estruturada e padronizada criada na década de 1970 por Ken Thompson e Dennis Ritchie para ser usada no sistema operacional Unix. Desde então espalhou-se por muitos outros sistemas operacionais, e tornou-se numa das linguagens de programação mais usadas. A linguagem C tem como ponto-forte a sua eficiência e é a linguagem de programação de preferência para o desenvolvimento de aplicações para sistemas operacionais, apesar de também ser us…</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=palavras_reservadas&amp;rev=1241805732&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-05-08T11:02:12-07:00</dc:date>
        <title>palavras_reservadas</title>
        <link>http://www.br-c.org/doku.php?id=palavras_reservadas&amp;rev=1241805732&amp;do=diff</link>
        <description>Todas as linguagens de programação têm palavras reservadas. As palavras reservadas não podem ser usadas a não ser nos seus propósitos originais, isto é, não pode-se declarar funções ou variáveis com os mesmos nomes. Como o C é case sensitive pode-se declarar uma variável For, apesar de haver uma palavra reservada for, mas isto não é uma coisa recomendável de se fazer pois pode gerar confusão.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=perror&amp;rev=1209137460&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-04-25T08:31:00-07:00</dc:date>
        <title>perror</title>
        <link>http://www.br-c.org/doku.php?id=perror&amp;rev=1209137460&amp;do=diff</link>
        <description>Função perror
Sintaxe:

void perror( const char mensagem );


----------


Como a maioria dos erros ocorridos deve ser mostrada de maneira idêntica na saída de erro padrão, e baseado principalmente no valor da variável errno, pode-se usar a função perror que realiza todas estas tarefas automaticamente.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=ponteiros&amp;rev=1242092179&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-05-11T18:36:19-07:00</dc:date>
        <title>ponteiros</title>
        <link>http://www.br-c.org/doku.php?id=ponteiros&amp;rev=1242092179&amp;do=diff</link>
        <description>Conceitos


A Linguagem C implementa o conceito de ponteiro. Um ponteiro é um tipo de dado como int, char ou float. A diferença do ponteiro em relação aos outros tipos de dados é que uma variável que seja ponteiro irá guardar um endereço de memória.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=pre_compilacao&amp;rev=1241731330&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-05-07T14:22:10-07:00</dc:date>
        <title>pre_compilacao</title>
        <link>http://www.br-c.org/doku.php?id=pre_compilacao&amp;rev=1241731330&amp;do=diff</link>
        <description>Fases de uma compilação


[Fases de uma compilação]

O processo de compilação de um programa é constituído de três fases distintas: 

	*  pré-compilação;
	*  compilação; 
	*  link-edição. 


Na fase de pré-compilação, o programa fonte é lido e caso se encontre comandos do pré-compilador, eles serão processados. O pré-compilador gera então um código intermediário que será lido pelo compilador.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=printf&amp;rev=1210114228&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-05-06T15:50:28-07:00</dc:date>
        <title>printf</title>
        <link>http://www.br-c.org/doku.php?id=printf&amp;rev=1210114228&amp;do=diff</link>
        <description>Sintaxe:

int printf(const char “formato”, ...);

Para se realizar a impressão de textos no terminal deve-se utilizar a função printf. Ela possui um número variado de parâmetros, tantos quantos forem necessários.

O primeiro parâmetro da função printf deve ser uma string indicando o texto a ser mostrado. Nesta string deve ser colocado formatadores de tipo para cada variável que será impresso. No texto também podem ser colocados alguns caracteres especiais, indicados através da barra invertida, a…</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=processos&amp;rev=1234639053&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-02-14T11:17:33-07:00</dc:date>
        <title>processos</title>
        <link>http://www.br-c.org/doku.php?id=processos&amp;rev=1234639053&amp;do=diff</link>
        <description>Um programa em execução, o qual é constituído por uma seqüência de instruções, um conjunto de dados e um registro descritor.

Pode-se dizer também que um processo nada mais que um programa em execução, ou seja, o processo nada mais que o programa armazenado em disco em execução na CPU. Lembrando que um programa é estático e imutável e um processo é dinâmico e mutável.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=programas_uteis&amp;rev=1241998374&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-05-10T16:32:54-07:00</dc:date>
        <title>programas_uteis</title>
        <link>http://www.br-c.org/doku.php?id=programas_uteis&amp;rev=1241998374&amp;do=diff</link>
        <description>Esta seção conterá pequenos programas, que em muitos casos são simples, mas ainda sim úteis.

Leitura de senha em C


/* senha.c */

#include &lt;unistd.h&gt;
#include &lt;termios.h&gt;
#include &lt;stdio.h&gt;
#include &lt;string.h&gt;

void getsen(char * psSenha, int iTamanho )
{
  int i;
  char cLetra;
  struct termios stTerminalModificado;
  struct termios stTerminalOriginal;
 
  tcgetattr(0, &amp;stTerminalModificado);
  stTerminalOriginal = stTerminalModificado;

  /* modifica o terminal para não ecoar na tela o que …</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=putchar&amp;rev=1210114539&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-05-06T15:55:39-07:00</dc:date>
        <title>putchar</title>
        <link>http://www.br-c.org/doku.php?id=putchar&amp;rev=1210114539&amp;do=diff</link>
        <description>Sintaxe:

int putchar( int caracter );

Arquivo header:

stdio.h


----------

Esta função é uma maneira simplificada de se mostrar um único caractere na tela. O argumento passado será convertido para caractere e mostrado na tela.

Veja o exemplo:</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=read&amp;rev=1209131282&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-04-25T06:48:02-07:00</dc:date>
        <title>read</title>
        <link>http://www.br-c.org/doku.php?id=read&amp;rev=1209131282&amp;do=diff</link>
        <description>Sintaxe:

ssize_t read (int iFileDescriptor, void  * buffer, size_t nbyte);


----------


A função read realiza a leitura de dados do arquivo para a memória. Deve-se informar de qual descritor devem ser lidos os bytes. O descritor deve estar aberto com opção O_RDONLY ou O_RDWR. Os dados serão lidos a partir da posição corrente.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=recv&amp;rev=1209130507&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-04-25T06:35:07-07:00</dc:date>
        <title>recv</title>
        <link>http://www.br-c.org/doku.php?id=recv&amp;rev=1209130507&amp;do=diff</link>
        <description>Sintaxe:

ssize_t recv(int s, void * buffer, size_t len);

ssize_t recvfrom(int s, void * buffer, size_t len, int flags, struct sockaddr * from, socklen_t * fromlen);


----------


A função recv é utilizada para receber (ler) uma mensagem de um socket. Para leitura de mensagens, também pode ser utilizada a função read. A função retorna o número de bytes lidos ou –1 se houve erro.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=rede&amp;rev=1235135286&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-02-20T05:08:06-07:00</dc:date>
        <title>rede</title>
        <link>http://www.br-c.org/doku.php?id=rede&amp;rev=1235135286&amp;do=diff</link>
        <description>Características para um sistema ser considerado cliente/servidor:

	*  Uma arquitetura cliente/servidor consiste em um processo de cliente e um processo de servidor, que podem ser distinguidos um do outro, embora possam interagir totalmente.
	*  A parte cliente e a parte servidor podem operar em diferentes plataformas de computador.
	*  Tanto a plataforma do cliente como a do servidor podem ser atualizadas sem que se tenha de necessariamente atualizar a outra plataforma.
	*  O servidor pode aten…</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=remove&amp;rev=1209132757&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-04-25T07:12:37-07:00</dc:date>
        <title>remove</title>
        <link>http://www.br-c.org/doku.php?id=remove&amp;rev=1209132757&amp;do=diff</link>
        <description>Sintaxe:

int remove(const char * path);


----------


A função remove/apaga o arquivo especificado pela variável path. Ela devolve 0 (zero) se a operação foi um sucesso e um valor diferente de zero de ocorreu um erro.

Veja o exemplo:


#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;fcntl.h&gt;
#include &lt;errno.h&gt;

int main(int argc, char *argv[])
{
   if( argc &lt; 2 )
   {
      fprintf(stderr, &quot;Obrigatório informar o nome do arquivo\n&quot;);
      exit(1);
   }

   printf(&quot;\nExcluindo o arquivo %s&quot;,…</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=rename&amp;rev=1209132823&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-04-25T07:13:43-07:00</dc:date>
        <title>rename</title>
        <link>http://www.br-c.org/doku.php?id=rename&amp;rev=1209132823&amp;do=diff</link>
        <description>Sintaxe:

int rename (const char * source, const char * target);


----------


A função rename faz com que o arquivo indicado no primeiro parâmetro tenha o seu nome trocado pelo nome informado no segundo parâmetro. 

Caso os nomes se referenciem ao mesmo diretório está sendo realizado uma troca de nomes de arquivos. Caso o diretório origem seja diferente do diretório destino está sendo realizado uma movimentação de um arquivo de um diretório para o outro, com o mesmo ou outro nome. Caso o arqui…</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=return&amp;rev=1210888380&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-05-15T14:53:00-07:00</dc:date>
        <title>return</title>
        <link>http://www.br-c.org/doku.php?id=return&amp;rev=1210888380&amp;do=diff</link>
        <description>Sintaxe:

return expressão;


----------

Quando uma função deve retornar valores utiliza-se o comando return. Quando este comando é executado o valor indicado é retornado para a função e a mesma encerra a sua execução, independente do local onde o return se encontra.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=scanf&amp;rev=1210114963&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-05-06T16:02:43-07:00</dc:date>
        <title>scanf</title>
        <link>http://www.br-c.org/doku.php?id=scanf&amp;rev=1210114963&amp;do=diff</link>
        <description>Sintaxe:

int scanf(const char formato, endereços_argumentos);

Header:

stdio.h


----------

Para realizar a entrada de valores para as variáveis deve ser utilizada a função scanf. A sintaxe desta função é muito parecida com o printf. Primeiramente, são informados quais os formatos que serão fornecidos no terminal, depois os endereços das variáveis que irão receber estes valores.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=send&amp;rev=1209136887&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-04-25T08:21:27-07:00</dc:date>
        <title>send</title>
        <link>http://www.br-c.org/doku.php?id=send&amp;rev=1209136887&amp;do=diff</link>
        <description>Sintaxe:

ssize_t send(int socket, const void * buffer, size_t len, int flags);

ssize_t sendto(int socket, const void * buffer, size_t len, int flags, const struct sockaddr * to, socklen_t tolen);


----------


A função send é utilizada para enviar uma mensagem para outro socket. Para o envio de mensagens, também pode ser utilizada a função write (o mesmo que passar o valor 0 em flags da função send). A função retorna o número de bytes enviados ou –1 se houve erro.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=shutdown&amp;rev=1209135981&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-04-25T08:06:21-07:00</dc:date>
        <title>shutdown</title>
        <link>http://www.br-c.org/doku.php?id=shutdown&amp;rev=1209135981&amp;do=diff</link>
        <description>Sintaxe:

int shutdown(int s, int how);


----------


A função shutdown finaliza toda ou parte de uma conexão full-duplex. As funções retorna 0 (zero) em caso de sucesso ou –1 se houve algum erro.
Se for passado SHUT_RD para how, as recepções serão desabilitas. Caso seja passado SHUT_WR as transmissões serão desabilitadas e se for SHUT_RDWR, toda a conexão será desabilitada.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=sinal&amp;rev=1235337203&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-02-22T13:13:23-07:00</dc:date>
        <title>sinal</title>
        <link>http://www.br-c.org/doku.php?id=sinal&amp;rev=1235337203&amp;do=diff</link>
        <description>Funções

	*  signal
	*  kill
	*  raise
	*  sleep</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=sizeof&amp;rev=1209144982&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-04-25T10:36:22-07:00</dc:date>
        <title>sizeof</title>
        <link>http://www.br-c.org/doku.php?id=sizeof&amp;rev=1209144982&amp;do=diff</link>
        <description>Existe um operador em C que indica o tamanho em bytes que uma determinada variável está utilizando na memória. Pode-se também colocar um determinado tipo como parâmetro que o resultado será o mesmo.

Este operador é muito utilizado quando se faz alocações dinâmicas de memória ou movimentações diretas na memória.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=sleep&amp;rev=1235337552&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-02-22T13:19:12-07:00</dc:date>
        <title>sleep</title>
        <link>http://www.br-c.org/doku.php?id=sleep&amp;rev=1235337552&amp;do=diff</link>
        <description>#include &lt;stdio.h&gt;
#include &lt;time.h&gt;
#include &lt;unistd.h&gt;

int main (void)
{
   time_t st_hora; 

   st_hora = time(NULL);

   /* nao estranhe a quantidade de segundos, é contado a partir de 01/01/1970 */
   printf (&quot;\nNumero de segundos antes  : %d\n&quot;, st_hora);
   printf (&quot;\nDormindo 5 segundos\n&quot;);

   sleep(5); /* o tempo que o programa 'dormirá' */

   time(&amp;st_hora);

   printf (&quot;Numero de segundos depois : %d\n&quot;, st_hora);
   return 0;
}</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=snprintf&amp;rev=1242007267&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-05-10T19:01:07-07:00</dc:date>
        <title>snprintf</title>
        <link>http://www.br-c.org/doku.php?id=snprintf&amp;rev=1242007267&amp;do=diff</link>
        <description>Função snprintf


Arquivo header:


#include &lt;stdio.h&gt;

----------

Sintaxe:
int snprintf( char * endereçoString, size_t iQuantidade, formato, variável1, variável2, ...);


----------

A função snprintf tem a mesma funcionalidade da função sprintf. A saída resultante (respeitando o tamanho máximo, indicador por iQuantidade), após a execução dos formatos, será colocado na variável indicada por endereçoString.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=sockaddr_in&amp;rev=1209130743&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-04-25T06:39:03-07:00</dc:date>
        <title>sockaddr_in</title>
        <link>http://www.br-c.org/doku.php?id=sockaddr_in&amp;rev=1209130743&amp;do=diff</link>
        <description>Para a programação socket, foram definidos estruturas padrão com os parâmetros que devem ser repassados para as demais funções. Para programas TCP/IP utiliza-se a estrutura sockaddr_in. Definida da seguinte forma:


struct sockaddr_in {
   short int sin_family;          /* família do endereço */
   unsigned short int sin_port;   /* número da porta */
   struct in_addr sin_addr;       /* endereço IP */
   unsigned char sin_zero[8];     /* complemento da estrutura, utilizar a função bzero */
};…</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=socket&amp;rev=1225231757&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-10-28T15:09:17-07:00</dc:date>
        <title>socket</title>
        <link>http://www.br-c.org/doku.php?id=socket&amp;rev=1225231757&amp;do=diff</link>
        <description>Sintaxe:


int socket(int domain, int type, int protocol);


----------


A função socket cria um ponto de comunicação e retorna um descritor para um arquivo ou –1 se houve algum erro (como as funções creat e open).
Deve-se passar o domínio da comunicação (tipo da comunicação). Normalmente, para comunicações TCP/IP utiliza-se AF_INET neste campo. O tipo da comunicação (TCP ou UDP), para comunicação TCP utiliza-se SOCK_STREAM e para UDP SOCK_DGRAM. O campo protocolo identifica um protocolo em par…</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=sprintf&amp;rev=1242007289&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-05-10T19:01:29-07:00</dc:date>
        <title>sprintf</title>
        <link>http://www.br-c.org/doku.php?id=sprintf&amp;rev=1242007289&amp;do=diff</link>
        <description>Função sprintf


Arquivo header:


#include &lt;stdio.h&gt;

----------

Sintaxe:
int sprintf( char * endereçoString, formato, variável1, variável2, ...);


----------

A função sprintf tem a mesma funcionalidade da função printf. A saída resultante, após a execução dos formatos, será colocado na variável indicada por endereçoString.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=sscanf&amp;rev=1242005616&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-05-10T18:33:36-07:00</dc:date>
        <title>sscanf</title>
        <link>http://www.br-c.org/doku.php?id=sscanf&amp;rev=1242005616&amp;do=diff</link>
        <description>Função sscanf


Arquivo header:


#include &lt;stdio.h&gt;

----------

Sintaxe:
int sscanf( const  char * EndereçoSring, formato, endereços_variáveis_argumentos);

----------

A função sscanf é idêntica à função scanf, mas os dados são lidos da string. O valor devolvido é igual ao número de variáveis, às quais foram realmente atribuídos valores. Esse número não inclui variáveis que foram saltadas devido ao uso do especificador de formato *. Um valor zero significa que nenhum campo foi atribuído; EOF …</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=start&amp;rev=1242092330&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-05-11T18:38:50-07:00</dc:date>
        <title>start</title>
        <link>http://www.br-c.org/doku.php?id=start&amp;rev=1242092330&amp;do=diff</link>
        <description>Esta página irá conter todas as funções, programas, descrições do livro “Programando em C para ambiente Linux, Unix e Windows”.
Esta página inicial está organizada nos mesmos tópicos do sumário do livro. Todos os programas foram testados no Linux com GCC, portanto, deverão funcionar no ambiente Unix também. Durante o processo de conversão de o livro para Wiki, os textos e programas sofrerão revisões e material adicional será incluído.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=static&amp;rev=1210888771&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-05-15T14:59:31-07:00</dc:date>
        <title>static</title>
        <link>http://www.br-c.org/doku.php?id=static&amp;rev=1210888771&amp;do=diff</link>
        <description>Sintaxe:

static tipo_variável nome_variável


----------

Como padrão toda variável definida dentro de uma função é alocada na pilha interna de execução da função. Ao final da função a pilha é liberada, liberando assim a memória alocada pela variável. Na próxima chamada à função é feita uma nova alocação na pilha assim por diante.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=strcat&amp;rev=1241810062&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-05-08T12:14:22-07:00</dc:date>
        <title>strcat</title>
        <link>http://www.br-c.org/doku.php?id=strcat&amp;rev=1241810062&amp;do=diff</link>
        <description>Arquivo header:

#include &lt;string.h&gt;

Sintaxe:
char * strcat( char * endereçoStringDestino, char * endereçoStringOrigem );


----------


Pode-se fazer a concatenação de dois strings, colocando um ao final do outro. A função para se fazer isto é strcat. Esta função irá concatenar a segunda string ao final da primeira string.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=strcmp&amp;rev=1241810106&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-05-08T12:15:06-07:00</dc:date>
        <title>strcmp</title>
        <link>http://www.br-c.org/doku.php?id=strcmp&amp;rev=1241810106&amp;do=diff</link>
        <description>Arquivo header:


#include &lt;string.h&gt;

Sintaxe:

int strcmp( const char * endereçoString1, const char * endereçoString2 );

----------

Para se comparar o conteúdo de dois strings deve-se usar a função strcmp. Essa função irá fazer a comparação, caractere a caractere, dos dois parâmetros informados. Como não é alterado o conteúdo de nenhum parâmetro, pode ser informado um valor constante em qualquer um deles, apesar de se fazer mais sentido usar a constante como segundo parâmetro.…</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=strcpy&amp;rev=1241809597&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-05-08T12:06:37-07:00</dc:date>
        <title>strcpy</title>
        <link>http://www.br-c.org/doku.php?id=strcpy&amp;rev=1241809597&amp;do=diff</link>
        <description>Arquivo header:



#include &lt;string.h&gt;



Sintaxe:

char * strcpy( char * endereçoStringDestino, char * endereçoStringOrigem );


----------

Quando se quiser copiar o conteúdo de uma string para outro se deve utilizar a função strcpy. O conteúdo da segunda variável ou constante informada será copiado para a área indicada no primeiro parâmetro.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=strerror&amp;rev=1209132960&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-04-25T07:16:00-07:00</dc:date>
        <title>strerror</title>
        <link>http://www.br-c.org/doku.php?id=strerror&amp;rev=1209132960&amp;do=diff</link>
        <description>Sintaxe:

char * strerror(int error);


----------

Caso se queira mostrar a mensagem correspondente ao erro ocorrido, ou se queira gerar um erro dentro do programa que utilize a mesma mensagem padrão do sistema operacional, deve-se usar a função strerror.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=strings&amp;rev=1242005167&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-05-10T18:26:07-07:00</dc:date>
        <title>strings</title>
        <link>http://www.br-c.org/doku.php?id=strings&amp;rev=1242005167&amp;do=diff</link>
        <description>Implementação de Strings

A linguagem C implementa o conceito de cadeia de caracteres, ou strings, utilizando um vetor de caracteres. Ao se definir uma string portanto deve-se definir um vetor de caracteres com determinado tamanho. 

A marcação do fim da string será indicada através da colocação de um caractere zerado, chamado tecnicamente de caractere NULL. Este caractere pode ser indicado, testado, usado através do literal definido NULL quando se incluem arquivos headers stdio.h ou string.h ou…</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=strlen&amp;rev=1241810036&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-05-08T12:13:56-07:00</dc:date>
        <title>strlen</title>
        <link>http://www.br-c.org/doku.php?id=strlen&amp;rev=1241810036&amp;do=diff</link>
        <description>Arquivo header:


#include &lt;string.h&gt;

Sintaxe:

size_t strlen(cost char *nome_da_string);


----------

Esta função irá retornar a quantidade de caracteres existentes em uma string, não considerando o caractere NULL na contagem dos caracteres.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=strncat&amp;rev=1242006143&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-05-10T18:42:23-07:00</dc:date>
        <title>strncat</title>
        <link>http://www.br-c.org/doku.php?id=strncat&amp;rev=1242006143&amp;do=diff</link>
        <description>Arquivo header:


#include &lt;string.h&gt;

----------

Sintaxe:
char * strncat( char * endereçoStringDestino, char * endereçoStringOrigem, size_t iQuantidade );

----------


A função strncat tem o mesmo comportamento da função strcat, exceto por concatenar não mais que quantidade caracteres (indicado por iQuantidade) da string endereçoStringOrigem à string apontada por endereçoStringDestino.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=strncmp&amp;rev=1242006927&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-05-10T18:55:27-07:00</dc:date>
        <title>strncmp</title>
        <link>http://www.br-c.org/doku.php?id=strncmp&amp;rev=1242006927&amp;do=diff</link>
        <description>Arquivo header:


#include &lt;string.h&gt;

----------

Sintaxe:
int strncmp( const char * endereçoString1, const char * endereçoString2, size_t iQuantidade );

----------


Essa função irá fazer a comparação, caractere a caractere, dos dois parâmetros informados, como a função strcmp, exceto por comparar até quantidade caracteres.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=strncpy&amp;rev=1242006623&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-05-10T18:50:23-07:00</dc:date>
        <title>strncpy</title>
        <link>http://www.br-c.org/doku.php?id=strncpy&amp;rev=1242006623&amp;do=diff</link>
        <description>Arquivo header:


#include &lt;string.h&gt;

----------

Sintaxe:
char * strncpy( char * endereçoStringDestino, const char * endereçoStringOrigem, size_t iQuantidade );


----------


A função strncpy tem o mesmo comportamento da função strcpy, exceto por copiar até quantidade caracteres da string endereçoStringOrigem na string endereçoStringDestino.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=strstr&amp;rev=1242089884&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-05-11T17:58:04-07:00</dc:date>
        <title>strstr</title>
        <link>http://www.br-c.org/doku.php?id=strstr&amp;rev=1242089884&amp;do=diff</link>
        <description>Arquivo header:


#include &lt;string.h&gt;

----------

Sintaxe:

char * strstr( const char * endereçoStrOrigem, char * endereçoStrChave);

----------

A função strstr devolve um ponteiro para a primeira ocorrência da string apontada por endereçoStrChave na string apontada por endereçoStrOrigem. Ela devolve um ponteiro nulo de não for encontrada nenhuma coincidência.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=strtok&amp;rev=1242090517&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-05-11T18:08:37-07:00</dc:date>
        <title>strtok</title>
        <link>http://www.br-c.org/doku.php?id=strtok&amp;rev=1242090517&amp;do=diff</link>
        <description>Arquivo header:


#include &lt;string.h&gt;

----------

Sintaxe

char * strtok( char * endereçoStrOrigem, char * endereçoStrDelimitador);


----------

A função strtok devolve um ponteiro para a próxima palavra na string apontada por endereçoStrOrigem. Os caracteres que formam a string apontada por endereçoStrDelimitador são os delimitadores que terminam a palavra. Um ponteiro nulo é devolvido quando não há mais palavras na string.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=switch&amp;rev=1210024514&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-05-05T14:55:14-07:00</dc:date>
        <title>switch</title>
        <link>http://www.br-c.org/doku.php?id=switch&amp;rev=1210024514&amp;do=diff</link>
        <description>Sintaxe:



   switch (expressão) 
   {
      case constante 1:
      { bloco de comandos 1...;
        break;
      }
      case constante 2:
      { bloco de comandos 2...;
        break;
      }
      .......
      default : 
      { 
         bloco de comandos n... 
      }
   }</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=threads_posix&amp;rev=1234810914&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-02-16T11:01:54-07:00</dc:date>
        <title>threads_posix</title>
        <link>http://www.br-c.org/doku.php?id=threads_posix&amp;rev=1234810914&amp;do=diff</link>
        <description>Compilação de um programa C com suporte as threads POSIX:  gcc teste_thread.c -oteste_thread -lpthread

Funções

	*  pthread_detach
	*  pthread_self
	*  pthread_exit
	*  pthread_create
	*  pthread_join
	*  pthread_mutex_lock
	*  pthread_mutex_lock</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=tipos_dados&amp;rev=1234643546&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-02-14T12:32:26-07:00</dc:date>
        <title>tipos_dados</title>
        <link>http://www.br-c.org/doku.php?id=tipos_dados&amp;rev=1234643546&amp;do=diff</link>
        <description>Para se criar variáveis em um programa C deve-se indicar para o compilador qual o tipo desta variável. Uma variável pode ter um tipo básico, intrínseco à linguagem C ou tipo estruturado, montado pelo programador. O programador pode criar novos tipos de dados, utilizando a declaração typedef.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=typedef&amp;rev=1209143946&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-04-25T10:19:06-07:00</dc:date>
        <title>typedef</title>
        <link>http://www.br-c.org/doku.php?id=typedef&amp;rev=1209143946&amp;do=diff</link>
        <description>Na linguagem C pode-se dar um outro nome a um tipo determinado. Isto é feito através da declaração typedef. Isto é muito usado para se manter a compatibilidade entre os sistemas operacionais e também para encurtar algumas definições longas, simplificando o programa.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=unlink&amp;rev=1209132702&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-04-25T07:11:42-07:00</dc:date>
        <title>unlink</title>
        <link>http://www.br-c.org/doku.php?id=unlink&amp;rev=1209132702&amp;do=diff</link>
        <description>Sintaxe:

int unlink(const char * path);


----------


A remoção de um arquivo de um sistema de arquivo é feita através da função unlink. Este nome é devido a que a função simplesmente recebe um nome de arquivo como parâmetro e decrementa o número de links existente no inode do mesmo (consulte o manual do sistema e veja o comando ln). Caso o número de links atinja o valor zero, então os dados do arquivo serão liberados para o sistema como áreas livres para uso.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=variavel_definicao&amp;rev=1209143356&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-04-25T10:09:16-07:00</dc:date>
        <title>variavel_definicao</title>
        <link>http://www.br-c.org/doku.php?id=variavel_definicao&amp;rev=1209143356&amp;do=diff</link>
        <description>Para se usar uma variável em C, ela deve ser definida indicando o seu tipo e o seu nome. Para se fazer isto se deve usar a seguinte sintaxe:

tipo nome1 [, nome2]... ;

Pode-se definir em uma mesma linha mais de uma variável, bastando para isto colocar os nomes das variáveis separados por vírgulas. Isto deve ser usado somente quando as variáveis são simples e não se precisa explicar o uso das mesmas. Como sugestão deve-se colocar sempre uma única variável por linha e após a definição da mesma co…</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=vetor_matriz&amp;rev=1211909830&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-05-27T10:37:10-07:00</dc:date>
        <title>vetor_matriz</title>
        <link>http://www.br-c.org/doku.php?id=vetor_matriz&amp;rev=1211909830&amp;do=diff</link>
        <description>Definindo Vetores


Sintaxe:

tipo_variável nome_vetor[tamanho];


----------

Define-se como vetor uma variável que possui várias ocorrências de um mesmo tipo. Cada ocorrência é acessada através de um índice. Os vetores também são chamados de matrizes unidimensionais por possuírem somente um índice.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=wait&amp;rev=1235309469&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-02-22T05:31:09-07:00</dc:date>
        <title>wait</title>
        <link>http://www.br-c.org/doku.php?id=wait&amp;rev=1235309469&amp;do=diff</link>
        <description>Sintaxe:

#include &lt;sys/types.h&gt;

#include &lt;sys/wait.h&gt;


pid_t wait(int * iStatus);


----------

O processo pai pode esperar o término de um processo filho através da chamada da função wait. A função wait devolverá o status de retorno de qualquer processo filho que termine. O processo que chamar a função apresentará um dos seguintes comportamentos:</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=waitpid&amp;rev=1235336889&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-02-22T13:08:09-07:00</dc:date>
        <title>waitpid</title>
        <link>http://www.br-c.org/doku.php?id=waitpid&amp;rev=1235336889&amp;do=diff</link>
        <description>#include &lt;stdio.h&gt;
#include &lt;unistd.h&gt;
#include &lt;sys/types.h&gt;
#include &lt;sys/wait.h&gt; 

int main(void)
{
   pid_t iPid;
   int iStatus;


   if( (iPid = fork())&lt;0) /* cria um processo filho */
   {
      perror(&quot;Erro no fork&quot;);
      return 0;
   }

   if( iPid != 0) /* no processo pai*/
   {
      printf(&quot;\nCriado o processo %d&quot;, iPid);
      while(1)
      {
         printf(&quot;\nEsperando o status do filho.&quot;);
         waitpid(iPid,&amp;iStatus,WUNTRACED);
         printf(&quot;\nStatus do filho pego.&quot;);

…</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=while&amp;rev=1210117899&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-05-06T16:51:39-07:00</dc:date>
        <title>while</title>
        <link>http://www.br-c.org/doku.php?id=while&amp;rev=1210117899&amp;do=diff</link>
        <description>Sintaxe:



   while (condição)
   {
      bloco de comandos
   }


----------

O comando while deve ser usado quando não se pode determinar com certeza quantas vezes um bloco de comandos será executado. 

Inicialmente a condição é testada. Caso seja falso, o programa não executará o bloco de comando indicado e continuará no comando após o comando while.</description>
    </item>
    <item rdf:about="http://www.br-c.org/doku.php?id=write&amp;rev=1242011327&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-05-10T20:08:47-07:00</dc:date>
        <title>write</title>
        <link>http://www.br-c.org/doku.php?id=write&amp;rev=1242011327&amp;do=diff</link>
        <description>Sintaxe:

ssize_t write (int iFileDescriptor, const void * buffer, size_t nbyte);


----------


A função write grava no arquivo indicado pelo descritor as informações obtidas do endereço fornecido. Os dados serão gravados a partir da posição atual do arquivo. Caso a opção O_APPEND tenha sido especificada na abertura, a posição atual do arquivo será antes atualizada com o valor do tamanho do arquivo. Após a gravação a posição atual do arquivo será somada da quantidade de bytes gravados no arquiv…</description>
    </item>
</rdf:RDF>
