Re: Programação em c.

["Fabio A Mazzarino" <fabio.mazzarino@gmail.com>]

Só pra resolver a dúvida do nosso amigo Marcos.

Eu fiz um programinha pra demonstrar:

int main() {
       float tchan = 123.456789;

       printf("%%.2f: [%.2f]\n", tchan);
       printf("%%10.4f: [%10.4f]\n", tchan);
       printf("%%12f: [%12f]\n", tchan);
       printf("%%4.f: [%4.f]\n", tchan);
}

A saída

%.2f: [123.46]
%10.4f: [  123.4568]
%12f: [  123.456787]
%4.f: [ 123]

Portanto um número depois do ponto limita a qtde de casas decimais
Um número antes do ponto, ou nenhum ponto foça o tamanho *mínimo* do
número como um todo, nesse caso vc poderia tb colocar %012f pra
preencher com 0 ao invés de espaços.

Se não colocar número antes do ponto não haverá tamanho mínimo para o
número. Se não colocar ponto, não haverá número máximo de casas
decimais. Se não colocar nada depois do ponto não haverá casas
decimais.

Passado a limpo. :o)

Fabio







On 5/8/06, Marcos Vinicius Lazarini <lazarini@nics.unicamp.br> wrote:
> Fabio A Mazzarino wrote:
> [...]
> >
> >  Solução:
> >  Existem duas soluções. Ambas passam por um processo de alocar memória
> > para armazenar o texto convertido.
> >  Solução #1 (mais simples) - alocar um array ao invés de um ponteiro
> >
> > 1    float pi = 3.1415;
> > 2    char escreve[10];
> > 3    sprintf(escreve, "%f", pi);
> >
> >  Note que na linha 2 vc está alocando 10 caracteres, e que na linha 2
> > vc passa o array sem índice, que é equivalente a um ponteiro.
>
> dois comentários:
> * vc poderia usar ao invez do "%f" algo como "%9f" pra limitar o numero
> de caracteres (lembre-se que vc tbm tem que lembrar do \0 que vai no
> final). Só não estou bem certo se a sintaxe %9f funciona ou se tem que
> ser %9.5f... meu C já está enferrujado :-)
> Não sei qtos caracteres o %f mostra no máximo, mas do jeito que está,
> deixa margem pra dar um SegFault ainda. Ou então, vc resolve mudar de
> float p/ double e esquece de aumentar a string... ai tá feita a
> mercadoria - e mais um bug (grave) p/ estatísticas...
> * sempre que possível, é interessante evitar deixar coisas implicitas,
> então, onde for usar como ponteiro, deixe bem claro pra evitar
> 'incidentes' depois; algo bem explicito como
> sprintf(&(escreve[0]), ...
> ou talvez
> sprintf(&escreve[], ...
> ou ainda
> sprintf(&escreve, ...
> É, definitivamente meu C está bem enferrujado - só testando os comandos
> acima, mas acredito que todos funcionem da mesma forma.
>
> >  Solução #2 (mais complexa e desnecessária) - alocar um ponteiro e
> > alocar memória manualmente
> >
> > 1    float pi = 3.1415;
> > 2    char *escreve;
> > 3    escreve = malloc(10 * sizeof(char));
> > 4    sprintf(escreve, "%f", pi);
> > 5    free(escreve);
> >
> >  Nesta solução vc continua alocando um ponteiro para caracter, mas
> > logo abaixo explicitamente aloca 10 caracteres em memória. Assim vc
> > tem memória alocada e o ponteiro aponta uma posição de memória alocada
> > para uso do programa.
> >  Note que depois do comando free vc não pode mais usar o ponteiro
> > escreve como um ponteiro para uma área de memória alocada, e portanto,
> > dependendo da operação, pode causar outro seg-fault.
>
> Nunca é demais lembrar: SEMPRE fazer free() de TODOS os mallocs()!!!
> :-)
>
> Outro dia vi numa camiseta (nerd no último) aqui na unicamp:
> Feed the children.
> Save the wales.
> Free mallocs.
>
> :-)
>
>
> --
> Marcos


--
Não existem Killer Applications de Código Aberto em Java.
Ajude a provar o contrário:
http://drupal.gulivap.org/?q=node/106