OBTENIR TOUTES LES NOMBRES PREMIERS DANS UNE GRANDE RANGÉE AU MOINS DE 10 MS!

Commentaire de BruNews le 19/04/2007 18:55:20 administrateur CS

d=U-L+1;
char flag[d];  ça compile ???

Commentaire de BruNews le 19/04/2007 19:35:40 administrateur CS

Ben ça s'arrange pas, tu n'as aucun controle du moment de la desalloc.

Commentaire de elkasimi2007 le 19/04/2007 20:01:21

salut,
vraiment c'est formidable on ressent vraiment que le monde est vivant
avec 4 commentaires,merci pour votre soutien les gars.
je vous promis toujours mon meilleur possible!

Commentaire de Cyberboy2054 le 19/04/2007 20:27:05

Moi aussi j'ai du mal à comprendre comment ce genre de syntaxe peut etre géré efficacement dans un programme de plus grande échelle. D'ailleurs tu devrais etre content Brunews, mais apparement ce genre d'ecriture ferait partie des futures normes du c++ (selon un pote en iut info, qui le tient d'un de ses profs). On leur apprend même a utiliser l'ecriture ci dessus O_o

A remplacer bien evidemment par un char *flag = (char*)malloc (d*sizeof(char)) puis free (flag) en fin de programme, pour rester dans du C propre et portable. D'ailleurs ca ne compile pas sous visual C++ 6.

Commentaire de acx01b le 19/04/2007 20:56:56

salut

http://mx.isti.cnr.it/cgi-bin/conan?key=CC~Language_topics~Builtin_Functions~__ALLOCA&title=VMS%20Help&referer=


avec gcc -S sous cygwin:

void alala() {
int d = 50;
char c[d];
}

       .globl _alala
       _alala:
pushl %ebp
movl %esp, %ebp

subl $8, %esp
movl %esp, %edx
movl $50, -4(%ebp)
movl -4(%ebp), %eax
addl $15, %eax
addl $15, %eax
shrl $4, %eax
sall $4, %eax
movl %eax, -8(%ebp)
movl -8(%ebp), %eax
call __alloca
movl %edx, %esp
leave
ret

en clair ça veut dire que c'est équivalent à:
void alala() {
int d = 50;
char *c = __alloca(50);
}

Commentaire de BruNews le 19/04/2007 21:13:03 administrateur CS

dans le cas de:
d=U-L+1;
char flag[d];
le compilo ne pourrait pas présumer que ça va tenir sur stack.

Commentaire de BruNews le 19/04/2007 23:06:45 administrateur CS

Le nescafé non plus, sauf que ça n'a plus rien à voir avec du café.

Commentaire de Kirua le 20/04/2007 11:09:04

+1 pour brunews, autant pour le café que pour le garbage collector :) et j'adore le café.

C'est une question d'habitude on va dire, garbge collector ou pas ... Mais je me sens terriblement impuissant quand je programme avec un GC personnellement :/. La gestion de la mémoire est vrmnt un souci central quand on programme. C'est déjà compliqué de savoir quand l'argument est passé par valeur ou par référence en Java O_o.

Du reste, le petit détail de syntaxe qui vous occupe est une extension GCC je crois. Suffit de ne pas l'utiliser.

Au fait: le screenshot est peut-être pas super utile, et bon ... "grande rangée", ça reste à voir. Pour les nombres premiers, couvrir tous les nombres représentables avec un int est assez standard, donc ne nous emballons pas ;).

Commentaire de ThicAThic le 20/04/2007 15:49:29

Peux-tu me donner un lien vers un site qui expliquerait l'algorithme de sieve, SVP ? Je n'en ai pas trouvé sur BibMath ni d'autres algo donnant et/ou calculant la suite des nombres premiers. Et ça m'intéresse. Merci.

Commentaire de Kirua le 20/04/2007 17:51:29

"Sieve", c'est pas juste le mot anglais pour "crible" (d'Eratosthène) ? Le coup classique qui marche bien si on a bcp de mémoire quoi :)

Commentaire de Yunchi le 20/07/2007 10:21:04

il n'y a pas une infinite de nombres premiers ?

Commentaire de _michel le 28/06/2008 15:17:00

"exactement Kirva!
son seul inconvénient c'est la grande mémoire!dieu merci qu'on est dans l'époque des 1Go de RAM!
a bientot.."
Justement pour la mémoire il y a une optimisation : on peut juste utiliser un bit par nombre impair, ça diminue par 16 l'espace mémoire requis. Comme ça on gagne 8 ans sur la technologie (loi de Moore). Pour la rapidité je ne sais pas si ça rend plus rapide ou moins (je dirais moins mais on ne sais pas car les opérateurs << et >> sont extremement rapides).