Fabiano Furtado

Em 16/06/2022 em 06:42, fredericopissarra disse:

A segunda forma é... confusa. E potencialmente não portável. Ao converter um ponteiro para uint64_t você tem o potencial de bagunçar o endereço (para isso existe o tipo uintptr_t ou intptr_t... mas, mesmo assim, não recomando).
...
PS: Tanto as especificações POSIX, quanto a documentação da glibc, proíbem a nomeação de identificadores com o sufixo _t (minúsculo), reservando-o para bibliotecas nativas. Eu evito isso nomeando meus tipos com o sufixo _T (maiúsculo), como em person_T.

EXCELENTE!!! Muito obrigado pela explicação!

Em 10/06/2022 em 20:29, fredericopissarra disse:

Se você só tem um ponteiro e aloca o espaço dinamicamente, terá que mander o registro do tamanho em algum lugar. Não tem como obter o tamanho do buffer pós-facto.

Oi Frederico, concordo novamente com você. Entretanto, estou "contando" em runtime o número de ítens do array alocado dinamicamente através do uso de um ítem NULL em sua última posição. Desde que não seja permitido que os ítens do array sejam nulos, essa técnica te retorna o número de ítens deste array, com o contra de usar uma posição deste array para isso (o úitimo item NULL).

Eu só gostaria de saber se a 2^a forma de contagem que descrevi no enunciado é a mais correta ou se há alguma outra forma melhor de se fazer isso.

Obrigado!

13 minutos atrás, fredericopissarra disse:

sizeof p te dará a quantidade de bytes do objeto p (o identificador do array).
sizeof p[0] te dará a quantidade de bytes de um elemento (o primeiro) do objeto p[0] (o elemento do array).

Assim, a quantidade de elementos do array pode ser calculada como sizeof p / sizeof p[0].

A vantagem de usar essa aproximação é que sizeof p / sizeof p[0] será avaliada em tempo de compilação para uma constante.

Note que, com isso, não é necessário usar o elemento final NULL:

person_t p[] = {
  { "Fulano", 32 },
  { "Ciclano", 41 }
};

for ( int i = 0; i < sizeof p / sizeof p[0]; i++ )
  printf( "\"%s\", %d anos.\n", p[i].name, p[i].age );

Sim, eu concordo. Entretanto, conforme informei, o array é dinâmico e terá de ser avaliado em runtime.

Pessoal, tudo bem?

Uma dúvida básica sobre qual é a melhor maneira de se fazer uma contagem de ítens dentro de um array.

Segue o trecho do código em C como exemplo:

...
typedef struct {
  char * name;
  unsigned char age;
} person_t;
...
  uint16_t c;
  person_t p[] = {
    {"Fulano", 32},
    {"Ciclano", 41},
    {NULL}
  );
...

Um detalhe é que esse array é dinâmico e não posso calcular o seu total de ítens usando sizeof(p)/sizeof(person_t) pois preciso fazer isso em tempo de execução. Por isso o uso do "NULL" ao final, marcando o fim do array.

Formas:

1a) Mais específica pois faço referência ao campo "name":
  for ( c = 0 ; p[c].name != NULL ; c++ );

2a) Mais genérica pois uso apenas aritmética de ponteiros, sem a referência ao campo "name":
  for( c = 0 ; (void *)(*(uint64_t *)(p+c)) != NULL ; c++ );

Os dois códigos acima geram o mesmo ASM e pergunto: essa segunda forma com aritmética de ponteiros é a melhor maneira de se fazer essa contagem? Queria algo mais genérico,  independende de arquitetura e que também não faca referência aos campos da "struct". Talvez esse "uint64_t" não funcione em 32 bits, tornando essa forma dependente da arquitetura 64 bits.

Obrigado!

Em 04/04/2019 em 22:58, fredericopissarra disse:

https://bitismyth.wordpress.com/2019/04/04/overflows-em-multiplicacoes/

https://bitismyth.wordpress.com/2019/04/04/overflows-com-divisoes-inteiras/

EXCELENTE!!!! Uma dúvida...

Qual seria mais rápido? Usar a sua função int mul_ints(int *r, int a, int b);, descrita em seu artigo sobre "overflows em multiplicações", ou o builtin do compilador bool __builtin_smul_overflow (int a, int b, int *res)?

Como se faz para medir este tempo gasto nestas duas funções?

Desde já, agradeço.

Pessoal, disponibilizei no meu GitHub o meu primeiro projeto OpenSource, como forma de retornar para a comunidade o que tenho aprendido nestes últimos anos.

O projeto se chama LIBCPF (C Plugin Framework - https://github.com/fabianofurtado/libcpf/) e se trata de uma biblioteca/framework pra gerenciamento de Plugins (".so") no Linux, feita em C. Para maiores detalhes, veja a documentação no arquivo README.md.

Ela foi lançada utilizando-se a licença GPL v2, uma vez que não entendo muito sobre esse assunto e precisava de uma licença para o projeto.

Espero que, de alguma forma, este projeto possa ser útil para você. Mesmo que não exista a necessidade de utilização desta lib em sua aplicação, a mesma pode ser usada para listar os nomes das funções e os offsets que existem dentro de uma shared library, algo que considero bem interessante. Veja no exemplo como isso funciona.

Como qualquer programa em C, o desenvolvimento deu muito trabalho pois tentei desenvolvê-la com foco na segurança, tentando evitar possíveis "buffer overflows" ou qualquer outro tipo de vulnerabilidades.

Sugestões e críticas serão sempre bem-vindas!

Desde já, agradeço.

Pessoal, estou desenvolvendo um pequeno projeto OpenSource em C para o Linux e quero discutir aqui qual é a melhor licença a ser aplicada.

Como é o meu primeiro projeto que vou disponibilizar para a comunidade, fico muito perdido quando começo a ler o texto contendo a definição da licença e solicito uma ajudinha para quem tem experiência, no intuito de entender melhor o contexto.

Estava pensando na GPL v2, mas a GPL v3 é mais moderna, porém, mais longa e mais difícil de se entender.

O que acham?

Desde já agradeço.

Em 18/05/2019 em 08:09, fredericopissarra disse:

Um artiguinho meu (e o follow up mostrando como montei o gráfico animado) - escritos em Agosto de 2017:

https://bitismyth.wordpress.com/2017/08/23/estatisticamente-insignificante/

https://bitismyth.wordpress.com/2017/08/25/o-grafico-animado-dos-sorteios-howto/

Muito bom os artigos!!!! Realmente fica quase impossível adivinhar esses números diante de tantas possíveis combinações.

Pessoal, desenvolvi recentemente 2 programas em C para gerar e filtrar números/combinações numéricas das loterias Dupla Sena e Lotofácil (eles podem ser adaptados facilmente para outros tipos de concursos, por exemplo).

Gostaria de um feedback de vocês pois não sei se fiz da melhor forma possível. Achei a leitura do arquivo texto contendo as combinações um pouco lenta.

Enfim... todas as críticas são bem-vindas pois tenho certeza que poderia ter feito ele de outra maneira mais otimizada.

https://github.com/fabianofurtado/random-lottery-numbers

Há, basicamente, duas formas de vocês o utilizarem:

1) Através de um arquivo texto contendo as combinações (pode ser gerada no random.org)

2) Através do parâmetro -n onde o sistema utilizará as funções srand() e rand() da libc.

Valeu!