+------------------------------------------+
| Artigo sobre C. (1a. Parte)              |
| Escrito por dec0d3r <dec0d3r@bol.com.br> |
| Desenvolvido para RootsPage (RTP)              |
+------------------------------------------+
.._________
| INDICE:  \_____________________
 \_______________________________\  

  1. Introducao.
  2. Arquivos pre-definidos.
    2.1. stdin.
    2.2. stdout.
    2.3. stderr.
   
  3. *printf.
    3.1. fprintf
    3.2. sprintf
    3.3. snprintf
   
  4. Strings.
    4.1. strcpy 
    4.2. strncpy
    4.3. strcat
    4.4. strncat
    4.5. strlen/sizeof
    4.6. strcmp
    4.7. strncmp
    4.8. strstr
   
  5. Acesso a arquivos.
    5.1. ferror
    5.2. perror
    5.3. feof
    5.4. remove
    5.5. fgets
    5.6. fputs
    5.7. fread
    5.8. fwrite
   
  6. *scanf.  
    6.1. fscan
    6.2. sscanf
  
  7. Outros.
    7.1. argumentos ARGC e ARGV
    7.2. funcao atoi()
    7.3. operador ?
    7.4. execl
  
  8. Referencia.
  9. Finalizando.


.._______________
| 1.INTRODUCAO:  \_____________________
 \_____________________________________\ 

  Bem este breve artigo, foi escrito para NEWBIES, logo ELITES naum ha
nada oq ler no mesmo.
  Este artigo abrange algumas funcoes q para alguns newbies sao 
desconhecidas ou conhecidas e para outros restam duvidas, sendo, 
tudo aqui escrito eh bem superficial, caso queira aprofundar-se, 
fica por sua conta...
  Creio q vc ja saiba pelo menos o basico da linguagem C, pois este 
artigo naum ensina o basico e sim algumas funcoes, argumentos entre 
outras coisas q podem ser usadas em seus sources para assim melhora-los.


..___________________________
| 2.ARQUIVOS PRE-DEFINIDOS:  \_____________________
 \_________________________________________________\

  Quando se comeca a execucao de um programa, o sistema automaticamente
abre alguns arquivos pre-definidos: stdin, stdout, stderr, stdaux, stdprn.
  No entanto, trataremos apenas das tres primeiras constantes...

2.1.STDIN:
---------

  O stdin eh o dispositivo de entrada padrao (geralmente o teclado).

Ex: 
    #include <stdio.h>

    main () {
 char la;
 printf ("DIGITE UMA STRING: ");
 la = getc(stdin); /* entrada, pega-se o 1o. caractere da string */
 printf ("A 1a.LETRA DIGITADA FOI: %c\n",la);
 return 0;
        }

2.2.STDOUT:
----------
  
  O stdout eh o dispositivo de saida padrao (geralmente o video).
 
Ex:
    #include <stdio.h>

    main () {
 char la[50];
 int a;
 printf ("DIGITE UMA STRING: ");
 gets(la);
 printf ("A STRING DIGITADA FOI:\n");
 for(a=0;a<strlen(la);a++) putc(la[a], stdout); /* strlen(); sera
                                             explicado mais na frente. */
 printf ("\n");
 return 0;
        }
  
2.3. STDERR:
-----------
 
  O stderr eh o dispositivo de saida de erro padrao (geralmente o video).
  Geralmente o stderr eh mais usado do q o stdout. q=]
  
Ex: 
    #include <stdio.h>

    main () {
 char la[50];
 printf ("DIGITE UMA STRING: ");
 gets(la);
  /* fprintf() sera explicado ja ja! */
 fprintf (stderr, "A STRING DIGITADA FOI: %s\n", la);
 return 0;
        }


..____________
| 3.*PRINTF:  \_____________________
 \__________________________________\

 
  Explicarei tres funcoes *printf(), elas sao fprintf, sprintf e snprintf.
  Sao as mais usadas e tem um boa importancia na otimizacao dos sources!
  As tres pertencem ao header <stdio.h> .  

3.1.fprintf:
-----------
  
  SINTAXE: Usada para copiar uma string para um arquivo.
  PROTOTIPO:  int fprintf (FILE *fp, const char *format,...);

 - FILE *fp: arquivo onde se deseja imprimir a string.(pode-se substituir
por stderr ou stdout.) 
 - const char *format: string q se deseja imprimir no FILE. q=]

Ex:  
  #include <stdio.h>
  #include <stdlib.h>

main() {

 char string[50];
 FILE *rtp;

 if( !(rtp = fopen("kraiu.txt","w")) )
  { printf("Erro na abertura do arquivo!");
    exit(1); }

 fprintf(stderr, "DIGITE SEU NOMI: "); /* usando stderr em vez do FILE */
 gets(string);
 fprintf(rtp, " SEU NOMI EH %s\n", string); /* imprime-se no arquivo */
   /* usando stdout em vez do FILE */
 fprintf(stdout, "SEU NOME JA FOI ESCRITO NO ARQUIVO kraiu.txt\n");
 fclose(rtp);
 return(0);
 }

   
3.2.sprintf:
-----------
  
  SINTAXE: Usada para copiar uma string para uma variavel do tipo char.
  PROTOTIPO: int sprintf(char *str, const char *format, ...);

 - char *str: varialvel q armazenara a string copiada.
 - const char *format: string q sera copiada.

Ex:
   #include <stdio.h>

main() {

 char nome[50], idade[20], str[100];

 fprintf(stderr, "DIGITE SEU NOMI: ");
 gets(nome);
 fprintf(stderr, "SUA IDADE: ");
 gets(idade);
  /* copia a string entre " " para str . */
 sprintf(str, "SEU NOMI EH %s E SUA IDADE EH %s \n", nome, idade);
 fprintf(stderr, "%s", str);
 return(0);
 }

3.3.snprintf:
------------
  
  SINTAXE: Usada p/ copiar um determinado numero de caracteres de uma
string p/ uma variavel do tipo char.
  PROTOTIPO: int snprintf(char *str, size_t size, const  char  *format, ...);

 - char *str: varialvel q armazenara a string copiada.
 - size_t size: tamanho maximo de bytes(caracteres + '\0') q serao armazenados.
 - const  char  *format: string q sera copiada.

Ex:
   #include <stdio.h>

main() {

 char nome[50], idade[20], str[100];

 fprintf(stderr, "DIGITE SEU NOMI: ");
 gets(nome);
 fprintf(stderr, "SUA IDADE: ");
 gets(idade);
  /* copia os 8 primeiros bytes da string entre " " para str . */
  /* sendo o 8o. byte sera o '\0'  */
 snprintf(str, 8, "NOMI: %s IDADE: %s \n", nome, idade);
 fprintf(stderr, "%s", str);
 return(0);
 }


..____________
| 4.STRINGS:  \_____________________
 \__________________________________\
  
  Trataremos neste topico de strings, isto eh, como copiar, comparar,
anexar e medir strings.
  As funcoes aqui descritas usam o header <string.h> .
  As strings devem ser igualadas elemento a elemento, como tambem temos
q ter em mente q uma string termina sempre em '\0', sendo ai esta um
exemplo:

   #include <stdio.h>

main () {
 int a;
 char str1[40], str2[40];

 fprintf (stderr, "STRING-1: ");
 gets(str1);
 for(a=0;str1[a];a++)  str2[a] = str1[a];
 str2[a] = '\0'; /* o ultimo byte de str2 sera '\0', terminando assim a string */ 
 fprintf (stderr, "STRING-2: %s\n", str2);
 return 0;
}


4.1.strcpy:
----------

  SINTAXE: Usada para copiar uma string para uma variavel do tipo char.
  PROTOTIPO: char *strcpy(char *destino, const char *origem);

 - char *destino: variavel q recebera a string de ORIGEM.
 - const char *origem: string q sera copiada para DESTINO.

Ex:
   #include <stdio.h>
   #include <string.h>

main () {

 char destino[60], origem[50];

 puts("Digite uma STRING: ");
 gets(origem);
 puts("copiando STRING-1 para STRING-2....");
 strcpy(destino, origem); /* copia-se a string ORIGEM para DESTINO */
 sleep(2);
 puts("copiada com sucesso...");
 printf("STRING-2: %s\n", destino);
 return 0;
}

4.2.strncpy:
-----------

  SINTAXE: Usada p/ copiar um determinado numero de caracteres de uma
string p/ uma variavel do tipo char.
  PROTOTIPO: char *strncpy(char *destino, const char *origem, size_t n);
 
 - char *destino: variavel q recebera a string de ORIGEM.
 - const char *origem: string q sera copiada para DESTINO.
 - size_t n: tamanho maximo de bytes da string ORIGEM a serem
copiadas para variavel DESTINO.

Ex:
    #include <stdio.h>
    #include <string.h>

main () {

 char destino[60], origem[50];
 
 puts("Digite uma STRING: ");
 fgets(origem, 100, stdin); /* veremos fgets no topico 5 */
 puts("copiando STRING-1 para STRING-2....");
 /* copia-se os 6 primeiros bytes da string ORIGEM para variavel DESTINO */
 /* OBS: sendo, se entre os 5 bytes nao tiver '/0', DESTINO sera preenchido
                           com caracteres nulos. */
 /* sizeof() mede o tamanho MAXIMO da string. */
 strncpy(destino, origem, sizeof(origem));
 sleep(1);
 puts("copiada com sucesso...");
 printf("STRING-2: %s\n", destino);
 return 0;
}

4.3.strcat:
----------

  SINTAXE: Usada p/ anexar uma string(origem) no final de outra string(destino). 
  PROTOTIPO: char *strcat(char *destino, const char *origem);

 - char *destino: string onde sera anexada a string ORIGEM.
 - const char *origem: string q sera anexada no final da string DESTINO.

Ex:
   #include <stdio.h>
   #include <string.h>
int main ()
{
  char origem[100], destino[100];
  printf("Digite um NOME: ");
  gets (destino);
  printf("Digite um ELOGIO: ");
  gets (origem);
  strcat (destino, origem); /* ORIGEM sera armazenada no final do DESTINO. */
  printf ("\nDESTINO: %s\n", destino);
  return(0);
}

4.4.strncat:
-----------

  SINTAXE: Usada para anexar um determinado No. de caracteres de uma
string(origem) no final de outra string(destino).
  PROTOTIPO: char *strncat(char *destino, const char *origem, size_t n);

 - char *destino: string onde sera anexada a string ORIGEM.
 - const char *origem: string q sera anexada no final da string DESTINO.
 - size_t n: tamanho maximo de bytes de ORIGEM a serem copiados para DESTINO. */

Ex: 
   #include <stdio.h>
   #include <string.h>
int main ()
{
  char origem[100], destino[100];
  printf("Digite um NOME: ");
  gets (destino);
  printf("Digite um ELOGIO: ");
  gets (origem);
/* os 4 primeiros bytes de ORIGEM seram armazenados no final do
DESTINO. */
  strncat (destino, origem, 4);
  printf ("\nDESTINO: %s\n", destino);
  return(0);
}

4.5.strlen/sizeof:
-----------------

  SINTAXE: Usadas para medir o tamanho de armazenamento de uma string(sizeof)
e para o medir o tamanho de bytes armazenados numa string(strlen).
  PROTOTIPO: size_t strlen(const char *s);
             size_t sizeof(const char *s);                              

 - const char *s: string a ser medida.
 
 OBS: strlen e sizeof servem para quase o mesmo proposito, medir uma string,
porem sizeof retorna um inteiro com o tamanho maximo q a string pode alocar.
Em strlen o terminador nulo nao eh contado('\0'). Isto quer dizer que, de fato,
o comprimento do vetor da string deve ser um a mais que o inteiro retornado
por strlen().

Ex: 
   #include <stdio.h>
   #include <string.h>

  main () {
 
   char str[100];
   printf ("Entre com uma STRING: ");
   gets (str);
/* como podem ver, strlen() retorna o comprimento da string, enquanto sizeof()
retorna o comprimento maximo q a string pode suportar, no caso 100. */
   printf ("TAMANHO DA STRING-strlen: %d", strlen(str));
   printf ("TAMANHO DA STRING-sizeof: %d", sizeof(str));
   return(0);
 }

4.6. strcmp:
-----------
  
  SINTAXE: Usada para comparar duas string entre si.
  PROTOTIPO: int strcmp(const char *s1, const char *s2);

 - const char *s1: string_1 a ser comparada.
 - const char *s2: string_2 a ser comparada.

 OBS: Se as strings forem identicas retornaram um valor 0, no entanto 
se forem diferentes retornam um valor nao-zero. 

Ex:
   #include <stdio.h>
   #include <string.h>
 main () {

  char string_1[100], string_2[100];
  printf ("STRING_1: ");
  gets (string_1);
  printf ("STRING_2: ");
  gets (string_2);
  if ( !strcmp(string_1, string_2) )
  puts("AS DUAS STRINGS SAO IGUAIS!!");
  else puts("SAO DIFERENTES!!");
  return(0);
}

4.7.strncmp: 
-----------
  
  SINTAXE: Usada p/ comparar um determinado No. de caracteres de uma
string(*s2) com outra string(*s1).
  PROTOTIPO: int strncmp(const char *s1, const char *s2, size_t n);

 - const char *s1: string_1 a ser comparada.
 - const char *s2: string_2 a ser comparada.
 - size_t n: tamanho maximo de bytes da string_2 a serem comparados.

 OBS: Se as strings forem identicas ou se os N primeiros bytes de string_2
forem identicos aos primeiros bytes de string_1 retornara um valor 0, caso
seja diferentes retornara um valor nao-zero.

Ex:
    #include <stdio.h>
    #include <string.h>
 main () {

  char string_1[100], string_2[100];
  printf ("STRING_1: ");
  gets (string_1);
  printf ("STRING_2: ");
  gets (string_2);
/* compare-se os 4 primeiros bytes de string_2 com string_1, se forem
iguais retornara 0, se deiferentes retornara nao-zero */
  if ( !strncmp(string_1, string_2, 4) )
  puts("AS DUAS STRINGS SAO IGUAIS!!");
  else puts("SAO DIFERENTES!!");
  return(0);
}

4.8.strstr:
----------
  
  SINTAXE: Usada para procurar uma palavra numa string.
  PROTOTIPO: char *strstr(const char *haystack, const char *needle);

 - const char *haystack: STRING onde se encontra a palavra chave.
 - const char *needle: PALAVRA_CHAVE que se deseja encontrar em *haystack.
 
 OBS: Se a P_CHAVE nao conter em STRING a funcao retornara um valor 0,
caso P_CHAVE contenha em STRING retornara um valor nao-zero. Logo a
terminacao '\0' nao eh comparada com o restante dos caracteres.

Ex:
    #include <stdio.h>
    #include <string.h>

 main () {

  char frase[200];
  char chave[50];

   fprintf (stderr, "Digite um FRASE: ");
   gets(frase);
    if(strlen(frase) > 200) { puts("FRASE grande demais"); exit(1); }
   fprintf (stderr, "Digite a PALAVRA CHAVE: ");
   gets(chave);
    if(strlen(chave) > 50) { puts("P_CHAVE grande demais"); exit(1); }

/* procura-se P_CHAVE na STRING retornando um valor nao-zero caso
encontrada, e NULL se nao encontrada. */
   if(strstr(frase, chave)) puts("P_CHAVE existe em FRASE");
   else puts("P_CHAVE nao existe em FRASE");
   return 0;
}


..______________________
| 5.ACESSO A ARQUIVOS:  \_____________________
 \____________________________________________\

  Bem, neste topico veremos alguns comandos de acesso a arquivos, creio
que vcs ja saibam como abrir um arquivo tanto para leitura com escrita,
como tb alguns de vcs ja conhecam as funcoes q aqui citarei, mas para quem
tem duvidas ou nao conhece aqui estao elas. q=]
  Atencao, juntarei algumas funcoes nos exemplos deste topico para assim
termos um melhor entendimento, como tb essas funcoes trabalham melhores
juntas. q=P
  As funcoes aqui destacadas usam o header <stdio.h>.

5.1.ferror:
----------
  
  SINTAXE: Usada p/ verificar erros durante o acesso a um arquivo.
  PROTOTIPO: int ferror( FILE *stream);

 - FILE *stream: Arquivo a ser lido.

 OBS: A funcao verifica se cada acesso a um arquivo teve sucesso, de modo
q consigamos garantir a integridade de nossos dados, a mesma retornara 0
se nenhum erro ocorrer e nao-zero caso tenha ocorrido algum durante o
acesso.

5.2.perror:
----------

  SINTAXE: Usada p/ imprimir um argumento de erro.
  PROTOTIPO: void perror(const char *s);
 
 - const char *s: String de erro a ser imprimida.

 OBS: Esta funcao pode ser usada em conjunto com ferror(), sendo imprimida
a string de erro q normalmente indicara onde ocorreu o erro no programa.

5.3.feof:
--------
  
  SINTAXE: Usada p/ verificar o fim de um arquivo. 
  PROTOTIPO: int feof( FILE *stream)

 - FILE *stream: Arquivo a ser lido.

 OBS: EOF (End of File) indica o fim de um arquivo. Geralmente quando
mexemos com arquivos temos que vericar onde o mesmo termina, para isso
existe a funcao feof(), retornando nao-zero caso tenha chegado ao fim do
arquivo e retornando 0 caso nao.

5.4.remove:
----------
  
  SINTAXE: Usada para remover(apagar) um arquivo.
  PROTOTIPO: int remove(const char *nome_do_arquivo);

 - const char *nome_do_arquivo: Nome do arquivo a ser removido.

 OBS: Se a funcao remove() obtiver sucesso retornara 0(zero), caso haja
algum erro a mesma retornara -1.

5.5.fgets:
---------
  
  SINTAXE: Usada para ler uma string em arquivos.
  PROTOTIPO: char *fgets(char *s, int size, FILE *stream);

 - char *s: BUFFER q armazenara a string lida de FILE.
 - int size: Tamanho maximo de caracteres a serem lidos de FILE.
 - FILE *stream: Arquivo a ser lido por fgets().

 OBS: fgets() nao ler mais nem menos o FILE de acordo com o tamanho
estabelecido por SIZE, sendo que o mesmo so terminara de ler depois q
encontrar o EOF ou um '\n', como tb sera armazenado o '\n' no BUFFER e o
'\0' sera armazenado depois do ultimo caractere no BUFFER.
      Lembrando q pode colocar "stdin" no lugar de FILE.

5.6.fputs:
---------
  
  SINTAXE: Usada para escrever uma string em arquivos.
  PROTOTIPO: int fputs(const char *s, FILE *stream);

 - const char *s: String a ser armazenada no FILE.
 - FILE *stream: Arquivos que recebera a String.

 OBS: A funcao escreve a string no arquivo, porem sem '\0'.

Ex:
   
#include <stdio.h>
#include <stdlib.h>

main() {
 int count;
 char frase[200], rtp[200];
 FILE *arquivo;
 fprintf (stderr, "1 - escrever arquivo\n"
                  "2 - ler arquivo\n"
                  "3 -  remover arquivo\n"
                  "4 - sair\n");
 fprintf (stderr, "ESCOLHA UMA OPCAO: ");
 scanf("%d",&count);
 switch(count) {
   case 1:

    while(strncmp(frase,"!",1)) {
 if( !(arquivo = fopen("dados","a")) )
  {  puts("ERRO na abertura do arquivo!!"); exit(0);  }

   fprintf (stderr, "Digite uma FRASE('!' pra SAIR): ");
 /* usando stdin no lugar de FILE */
   fgets(frase,sizeof(frase),stdin);
   fprintf (stderr, "\nescrevendo _FRASE_ no arquivo\n");
   fputs(frase, arquivo);
/* verificando caso haja algum erro na gravacao. */
 if(ferror(arquivo)) { perror("ERRO na Gravacao"); fclose(arquivo); exit(1); }
   fprintf (stderr, "_FRASE_ escrita!\n"); }
   fclose(arquivo); break;

   case 2:

 if( !(arquivo = fopen("dados","r")) )
  {  puts("ERROR na abertura do arquivo!!"); exit(0);  }

   fprintf (stderr, "LENDO ARQUIVO\n");
   while(!feof(arquivo)) { /* enquanto nao chegar ao fim do arquivo.. */
   fgets(rtp, 200, arquivo); /* pega-se linha por linha do arquivo */
   sleep(1);
   fprintf (stderr, "%s", rtp); }
   fclose(arquivo); break;

   case 3:

  fprintf (stderr ,"Removendo arquivo...\n");
/* se nao houver erro, remova o arquivo */
if(remove("dados")==-1) {fprintf(stderr,"Arquivo inexistente\n"); exit(0);}
  sleep(1); fprintf (stderr, "Arquivo removido!\n");
  break;

   default: break;
}
   return 0;
}

5.7.fread:
---------
  
  SINTAXE: Usada para ler blocos de dados em arquivos.
  PROTOTIPO: size_t fread(void *buffer, int size, int count, FILE *stream);

 - void *buffer: Regiao da memoria onde ficara armazenada os dados lidos.
 - int size: Tamanho de bytes a ser lido do arquivo.
 - int count: Quantos vezes serao lidos o mesmo arquivo.
 - FILE *stream: Arquivo a ser lido.

 OBS: O numero total de bytes a ser lido eh: int size*int count .
A funcao retorna o numero de unidades efetivamente lidas(nao o numero 
caracteres). Este numero pode ser menor que count quando o fim do arquivo
for encontrado ou ocorrer algum erro.

5.8.fwrite:
----------
 
 SINTAXE: Usada para escrever blocos de dados em arquivos.
 PROTOTIPO: size_t fwrite(void *buffer, int size, int count, FILE *stream);

 - void *buffer: Regiao da memoria onde ficara os dados a serem escritos.
 - int size: Tamanho de bytes as serem escritos no arquivo.
 - int count: Quantas vezes serao escritos no mesmo arquivo.
 - FILE *stream: Arquivo a ser escrito.

 OBS: O numero total de bytes a ser escrito eh: int size*int count .
A funcao retorna o numero de itens escritos. Este valor sera igual a
count a menos que ocorra algum erro.

Ex:

 #include <stdio.h>
 #include <stdlib.h>

 main() {
char txt[100],uia[100];
FILE *rtp;

if(!(rtp=fopen("dados","w"))) {puts("Erro: abertura de arquivo."); exit(0);}

fprintf(stderr,"Digite uma frase:\n");
fgets(txt,sizeof(txt),stdin);
puts("frase lida..."); sleep(1);

 /* Usando fwrite e verificando caso haja erro, como podem ver, se a
funcao for diferente de "count" imprima a msg de erro.. */
if(fwrite(&txt,strlen(txt),1,rtp) != 1) puts("erro na escrita do arquivo.");
puts("frase escrita no arquivo dados"); sleep(1); fclose(rtp);

if(!(rtp=fopen("dados","r"))) {puts("Erro: abertura de arquivo."); exit(0);}

/* usando fread para ler o arquivo. */
if(!feof(rtp)) fread(&uia,100,1,rtp);
uia[strlen(uia) -1] = 0;   
puts("lendo do arquivo..."); sleep(1);
fprintf(stderr,"\n%s\n",uia);
fclose(rtp); return 0; }


..___________
| 6.*scanf:  \_____________________
 \_________________________________\

  Bem, veremes aqui neste curto topico duas funcoes, fscanf() e sscanf().
  Elas pertencem ao header <stdio.h>.

6.1.fscanf:
----------
 
  SINTAXE: Usada p/ ler uma string de um arquivo.
  PROTOTIPO: int fscanf( FILE *stream, const char *format, ...);

 - FILE *stream: Arquivo de onde sera lido a string.
 - const char *format: variavel q armazenara a string lida do arquivo.

 OBS: fscanf() so possue uma diferenca em relacao a scanf(), a
especificacao do arquivo de destino. Voce pode usar stdin no lugar de FILE.

6.2.sscanf:
----------

  SINTAXE: Usada p/ copiar uma string para uma variavel.
  PROTOTIPO: int sscanf( const char *str, const char *format, ...);

 - const char *str: Variavel de onde sera lida a string.
 - const char *format: Variavel onde ficara armazenada a string.
 
 OBS: Esta funcao apenas ler a string ate o primeiro "espaco", ou seja,
caso vc tenha uma string assim "decodi ruti e anju" a funcao ira ler
apenas "decodi". Espero ter sido claro. q=P 

Ex:
  
 #include <stdio.h>
 #include <stdlib.h>

main() {

int idade;
char nome[50], fone[50];
char uia[200], b[200], buffer[200];
FILE *rtp;

if(!(rtp=fopen("dados","w"))) {puts("erro na abertura de
arquivo"); exit(0);}

fprintf(stderr,"Digite seu: <nome> <idade> <fone>\n");
/* Usamos stdin no lugar de FILE */
fscanf(stdin, "%s %d %s",nome,&idade,fone);
sprintf(buffer,"<%s>__<%d>__<%s>",nome,idade,fone);
/* Lee-se a variavel buffer e a copia p/ variavel uia */
sscanf(buffer,"%s", uia);
fprintf(rtp,"%s",uia); fclose(rtp); sleep(1);

if(!(rtp=fopen("dados","r"))) {puts("erro na abertura de
arquivo"); exit(0);}
/* enquanto nao chegar a EOF sera lido o arquivo e imprimido na tela */
while(!feof(rtp)) { fscanf(rtp,"%s", b); fprintf(stderr,"%s\n", b); }
fclose(rtp);
return 0; }


..___________
| 7.outros:  \_____________________
 \_________________________________\

  Este curto topico nos mostrara o operador ?, argumentos, e duas outras
funcoes, creio eu q estas ja sao conhecidas por boa parte dos newbies mas
sempre existe alguns com duvidas... q=]

7.1.argumentos argc e argv:
--------------------------

  SINTAXE: Os parametros argc e argv dao ao programador acesso a linha de
comando na qual o programa foi executado.
  PROTOTIPO: int main (int argc, char *argv[]);

 - int argc: O argc(argument count) eh um inteiro e possui o No. de
argumentos com a qual a funcao main() foi chamada. Sendo, argc eh contado
a partir de 1, pois o nome do programa eh 0(primeiro_argumento).
 - char *argv[]: O argv(argument values) eh um ponteiro p/ uma matriz de
strings, sendo cada string dessa matriz um dos parametros da linha de
comando, lembrando q argv[0] eh o nome do programa.

 OBS: Entenda argc como o contador p/ cada argumento na linha de comando e
argv como a string dos argumentos.
          Ex: ./scan 127.0.0.1 2000         argv[0] == "./scan"  
                 |        |       |         argv[1] == "127.0.0.1"
ONDE argc:  argc[0]  argc[1]  argc[2]       argv[2] == "2000"

Espero que tenham entendido... q=P 

7.2.funcao atoi():
-----------------
  
  Esta funcao usa o header <stdlib.h>.  

  SINTAXE: Converte strings para inteiro.
  PROTOTIPO: int atoi(const char *nptr);

 - const char *nptr: String a ser convertida.

 OBS: A funcao atoi() nao detecta erros.

7.3.operador ?:
--------------

  Muitos ja devem te-lo visto, porem poucos conhecem tal operador, vou
esplica-lo de maneira direta. q=D

 Uma expresao do tipo:

   if(a>0) b=1;         if(condicao) expressao_1;
   else b=2;            else expressao_2;

 pode ser simplificada usando o operador ?:

  b=a>0?1:2;       condicao?expressao_1:expressao_2;
    
Ex:

  #include <stdio.h>
  #include <stdlib.h>

main (int argc, char *argv[]) {

int idade;
char *nome;
/* verificando-se argumentos na linha de comando... */
if(argc<3) { puts("uso: <nome> <idade>"); exit(0); }

nome = argv[1];
idade = atoi(argv[2]); /* convertendo a string em um inteiro equivalente */

/* Uso do operador ? */
idade>14?fprintf(stderr,"%s tem %d e eh velhu\n",nome,idade):fprintf(stderr,"%s tem %d e eh novinhu\n",nome,idade); 
return 0; }

7.4.execl:
---------

  Esta funcao usa o header <unistd.h>

  SINTAXE: Executar comandos no sitema.
  PROTOTIPO: int execl( const char *path, const char *arg, ...);

 - const char *path: Caminho do arquivo a ser executado.
 - const char *arg:  Argumentos do comando a ser executado.

 OBS: Termina-se os argumentos com um  apontador nulo(NULL, 0, ...).

Ex:
  #include <stdio.h>
  #include <unistd.h>

main() {

puts ("executando o comando [ls -la]");
sleep(1);
/* executando o comando e finalizando os argumentos com NULL */
execl("/bin/ls", "ls", "-la", NULL); 
return 0; }


.._______________
| 8.referencia:  \_____________________
 \_____________________________________\

- Curso de C da UFMG. ------ [ http://ead1.eee.ufmg.br/cursos/C ]
- Programming_in_C ------ [ http://www.cm.cf.ac.uk/Dave/C/CE.html/ ]
- man pages ------ [ man <funcao> ] q=P

..________________
| 9.finalizando:  \_____________________
 \______________________________________\

  Bem, chegamos ao fim deste curto artigo sobre C, esta linguagem q a cada
dia cresce entre fucadores... Todos os exemplos neste artigo foram feitos
por mim e rodados num Slackware 7.1 (2.2.16), sendo, sao exemplos
simples e feitos apenas para demonstrar as funcoes...
 Eh caros newbies, fico aqui e espero ter ajudado vcs... q=D

//---------------------------------------------------------------- [EOF]
                    RootsPage a caminho da etica...
                       r0ot - AnJiNh0' - dec0d3r