/* Topic des codeurs couche-tard [1] */

\\Ouranos// · Le 19/06/2010, à 10:41

@Pylade : Tu as essayé le tuto de M@teo21 sur le SdZ, en complétant avec celui de Nanoc (et les exercices qui vont avec) ?

helly · Le 19/06/2010, à 11:34

/me cherche un projet c++ à faire (pour passer le temps) un peu plus complexe et utile que mon jeu de la vie et mon Énigma…
Des idées ?

Compteur du TdCCT · Le 19/06/2010, à 11:37

Scores totaux, depuis le début :

1) 545    samuncle
2) 470    nesthib
3) 465    Pylade
4) 423+5  grim7reaper ** bonus +5 pour avoir répondu à ce post : ./viewtopic.php?pid=3486252#p3486252 **
5) 367    mathieuI
6) 250    cm-t
7) 201    helly
8) 163    gnuuat
9) 121    ǤƦƯƝƬ
10) 107    tshirtman
11) 83    petifrancais
12) 58    \\Ouranos//
13) 38    pierguiard
14) 37    ilagas
15) 30    keny
16) 25    GentooUser
17) 23    Kanor
18) 19    Le Rouge
19) 18    Ph3nix_
20) 14    kouskous
21) 12    stratoboy
21) 12    sailing
23) 11    Lagierl
24) 10    CROWD
24) 10    Toineo
26) 9    xapantu
27) 8    Mornagest
28) 7    Vista
29) 6    Zeibux
29) 6    Р'tite G☢gole :mad:
29) 6    edge_one
32) 5    timsy
33) 4    danychou56
33) 4    Neros
33) 4    Biaise
36) 3    gulp
37) 1    ceric
37) 1    pfriedK
37) 1    geenux

chart?chs=675x280&cht=p3&chco=d80020,d88000,ffd840,20d820,2080ff,101080,a020d8&chf=bg,s,c0c0c0&chl=00h%20-%2000h59|01h%20-%2001h59|02h%20-%2002h59|03h%20-%2003h59|09h%20-%2009h59|13h%20-%2013h59|14h%20-%2014h59|19h%20-%2019h59|20h%20-%2020h59&chd=t:2,4,3,4,2,4,3,1,3&chp=1.6&chtt=R%C3%A9partition%20des%20posts&chts=606060,16

\\Ouranos// · Le 19/06/2010, à 11:41

helly a écrit :

/me cherche un projet c++ à faire (pour passer le temps) un peu plus complexe et utile que mon jeu de la vie et mon Énigma…
Des idées ?

Un mini rpg ?

Sinon, une dernière question avant d'aller bosser : est-ce que ça servirait à quelque chose, de ne pas signer une variable de parcours d'un tableau, quand on fait des opérations sur cette variable ? Par exemple :

unsigned int i = 0;
int table[25] = {0];
for (i = 0; i <= 25; i++)
{
// On manipule i dans le for
}

Compteur du TdCCT · Le 19/06/2010, à 11:45

Scores de la période en cours :

1) 180    Pylade
2) 150    samuncle
3) 145    grim7reaper
4) 143    nesthib
5) 132    mathieuI
6) 68    helly
7) 67    cm-t
8) 66    gnuuat
9) 32    tshirtman
10) 23    \\Ouranos//
11) 20    keny
12) 15    ǤƦƯƝƬ
13) 13    petifrancais
13) 13    pierguiard
15) 9    Kanor
16) 7    Vista
17) 6    edge_one
18) 5    sailing
18) 5    timsy
20) 4    Toineo
20) 4    Lagierl
20) 4    xapantu
23) 3    gulp
23) 3    Р'tite G☢gole :mad:
25) 2    kouskous
25) 2    Mornagest

Ça m’aura fait chier aujourd’hui !
Voilà que je bug, comme le compteur du TdCT…

helly · Le 19/06/2010, à 11:49

Un mini rpg ?

Mouarf c'est un peu chaud je pense
Mais je dérive ton idée → jvais peut être tenter un ptit jeu de plateforme !

Pylades · Le 19/06/2010, à 11:56

helly a écrit :

Pylade a écrit :
Et depuis quand on met void en C++ ?
Édit : j’ai testé, pas de warning. Bizarre…
D'après le farfadet spacial ça permet de se conformer à la future norme C++, tout en restant conforme à la norme actuelle

Cool !
J’en suis vraiment très heureux !
(Ça faisait partie des trucs que je trouvais moche dans le C++. )

helly a écrit :

Au fait c'est quoi déjà le nom du truc qui va «dépasser» le C++ ?
Un nom genre C+.0x, ou un nom dans le genre, jm'en souviens plus…

Ben, la nouvelle norme. Après le C++98, on était sensés avoir le C++0x, mais là on va plutôt avoir du C++1x.

\\Ouranos// a écrit :

@Pylade : Tu as essayé le tuto de M@teo21 sur le SdZ, en complétant avec celui de Nanoc (et les exercices qui vont avec) ?

Celui de M@téo21, j’ai vu, mais il a peu d’égards pour la rigueur, et il demande de connaître le C. Pour moi, si on te demande de connaître un autre langage avant d’enseigner un langage, ce n’est pas bon…

\\Ouranos// a écrit :

Sinon, une dernière question avant d'aller bosser : est-ce que ça servirait à quelque chose, de ne pas signer une variable de parcours d'un tableau, quand on fait des opérations sur cette variable ? Par exemple :
unsigned int i = 0;
int table[25] = {0];
for (i = 0; i <= 25; i++)
{
// On manipule i dans le for
}

\\Ouranos// entre les deux posts du bot ! \o/
Ben non, les variables non signée, c’est quand tu es certain que la variable ne prendra pas un valeur négative, et que tu as des raisons de penser qu’il risquerait d’y avoir un integer overflow avec le type signé. Donc en pratique, on (moi en tous cas) ne s’en sert pratiquement jamais.

nany · Le 19/06/2010, à 12:07

Bonjour chez vous.

Compteur du TdCCT a écrit :

[…]
Ça m’aura fait chier aujourd’hui !
Voilà que je bug, comme le compteur du TdCT…

C’est dû à la limitation des 10s entre deux posts (merci tshirtman).

        for i in range(15):
            try:
                post(file, stats, debug)
                time.sleep(10)
                stats = {}
                break
            except:
                if i == 14: raise
                time.sleep(60)

\\Ouranos// · Le 19/06/2010, à 12:15

Pylade a écrit :

\\Ouranos// a écrit :
@Pylade : Tu as essayé le tuto de M@teo21 sur le SdZ, en complétant avec celui de Nanoc (et les exercices qui vont avec) ?
Celui de M@téo21, j’ai vu, mais il a peu d’égards pour la rigueur, et il demande de connaître le C. Pour moi, si on te demande de connaître un autre langage avant d’enseigner un langage, ce n’est pas bon…

developpez.com ?
Une fois que tu connais bien, tu peux compléter avec le tuto de Nanoc (C++ - Notions avancées).

\\Ouranos// a écrit :
Sinon, une dernière question avant d'aller bosser : est-ce que ça servirait à quelque chose, de ne pas signer une variable de parcours d'un tableau, quand on fait des opérations sur cette variable ? Par exemple :
unsigned int i = 0;
int table[25] = {0];
for (i = 0; i <= 25; i++)
{
// On manipule i dans le for
}
\\Ouranos// entre les deux posts du bot ! \o/
Ben non, les variables non signée, c’est quand tu es certain que la variable ne prendra pas un valeur négative, et que tu as des raisons de penser qu’il risquerait d’y avoir un integer overflow avec le type signé. Donc en pratique, on (moi en tous cas) ne s’en sert pratiquement jamais.

Clâsse !
Merci de l'info.

grim7reaper · Le 19/06/2010, à 12:59

Hello World !

\\Ouranos// a écrit :

Sinon, une dernière question avant d'aller bosser : est-ce que ça servirait à quelque chose, de ne pas signer une variable de parcours d'un tableau, quand on fait des opérations sur cette variable ? Par exemple :
unsigned int i = 0;
int table[25] = {0];
for (i = 0; i <= 25; i++)
{
// On manipule i dans le for
}

Dans le cas où tu modifies le i dans la boucle, alors du point de vue algorithmique il ne faut pas utiliser un for mais un while.

Si tu ne touches pas à i (comme ça devrai être le cas dans un for), ça sert à passer pour un mec qui réfléchi un minimum.
Tu n'utiliseras jamais les valeur négatives de toute manières (dans le cas d'un parcours de tableau comme ci-dessus) donc pourquoi utiliser un type donc la moitié des valuers est inutile.
Il est de bon ton d'utiliser size_t pour tout ce qui est taille et variable de parcours de tableau. Après, rien ne t'y oblige.

Pylade a écrit :

helly a écrit :
Au fait c'est quoi déjà le nom du truc qui va «dépasser» le C++ ?
Un nom genre C+.0x, ou un nom dans le genre, jm'en souviens plus…
Ben, la nouvelle norme. Après le C++98, on était sensés avoir le C++0x, mais là on va plutôt avoir du C++1x.

Non, c'est fait. On va avoir du C++1x (à moins que l'idée de Sutter soit accepté, dans ce cas ça sera le C++11).

Pylades · Le 19/06/2010, à 13:14

\\Ouranos// a écrit :

developpez.com ?
Une fois que tu connais bien, tu peux compléter avec le tuto de Nanoc (C++ - Notions avancées).

Nan. J’ai cherché sur developpez.com, mais je n’ai pas trouvé mon bonheur. J’ai téléchargé le tuto de cplusplus.com, il m’a l’air à peu près correct.

Enfin bon, je n’ai pas encore un niveau suffisant pour vraiment juger la qualité des tutos, mais je pense ne pas trop me tromper.

Pylades · Le 19/06/2010, à 13:29

grim7reaper a écrit :

Tu n'utiliseras jamais les valeur négatives de toute manières (dans le cas d'un parcours de tableau comme ci-dessus) donc pourquoi utiliser un type donc la moitié des valuers est inutile.

Bof. Si tu n’utilise que les valeurs de 0 à 26, de toutes façons tu n’utilisera pas la plupart des valeurs. Et aucune de celles comprises entre INT_MAX et UINT_MAX, ce qui représente tout de même la moitié des valeurs. Pourquoi alors utiliser le type non signé, puisque la moitié des valeurs sont aussi inutiles ? Dans ce cas là, à rien (à part peut-être à bien montrer au lecteur que la valeur ne sera jamais négative, mais ça je crois qu’il l’a compris en voyant le for).
De toutes façons, j’ai l’habitude d’initialiser mon compteurs à -1 et de les incrémenter avec ++i;, donc de toutes façons je ne peux pas utiliser le type non-signé.

grim7reaper a écrit :

Il est de bon ton d'utiliser size_t pour tout ce qui est taille et variable de parcours de tableau. Après, rien ne t'y oblige.

Ça fait vraiment plus pro, où c’est juste histoire de dire ?

grim7reaper · Le 19/06/2010, à 13:48

Pylade a écrit :

grim7reaper a écrit :
Tu n'utiliseras jamais les valeur négatives de toute manières (dans le cas d'un parcours de tableau comme ci-dessus) donc pourquoi utiliser un type donc la moitié des valuers est inutile.
Bof. Si tu n’utilise que les valeurs de 0 à 26, de toutes façons tu n’utilisera pas la plupart des valeurs. Et aucune de celles comprises entre INT_MAX et UINT_MAX, ce qui représente tout de même la moitié des valeurs. Pourquoi alors utiliser le type non signé, puisque la moitié des valeurs sont aussi inutiles ? Dans ce cas là, à rien (à part peut-être à bien montrer au lecteur que la valeur ne sera jamais négative, mais ça je crois qu’il l’a compris en voyant le for).

Les négatives sont inutiles à 100%, celles entre INT_MAX et UINT_MAX pourraient être utile dans le futur.

De toutes façons, j’ai l’habitude d’initialiser mon compteurs à -1 et de les incrémenter avec ++i;, donc de toutes façons je ne peux pas utiliser le type non-signé.

Ça vient d'où cette habitude étrange (le prend pas mal hein , c'est juste que je n'ai jamais compris l'intérêt) ?

grim7reaper a écrit :
Il est de bon ton d'utiliser size_t pour tout ce qui est taille et variable de parcours de tableau. Après, rien ne t'y oblige.
Ça fait vraiment plus pro, où c’est juste histoire de dire ?

Ce n'est ni une question de capacités (bien sur que les valeurs signées sont suffisantes dans 75% des cas) ni une question professionalisme, c'est juste une question de logique de base.
Utiliser un type qui peut représenter des valeurs négatives pour une action qui n'en nécessite pas c'est juste totalement illogique (pour rester poli ) à mon sens.
Mais après chacun fait comme il veut, ce n'est pas un standard de fait non plus.

helly · Le 19/06/2010, à 13:54

Quelqu'un a un bon tuto de gtk à me proposer?
Pis c'est vraiment différent de QT ?

Pylades · Le 19/06/2010, à 14:01

helly a écrit :

Quelqu'un a un bon tuto de gtk à me proposer?
Pis c'est vraiment différent de QT ?

*PAN*
On écrit « Qt ».

Et oui, ça n’a strictement rien à voir.

@grim7reaper : ma réponse arrive…

grim7reaper · Le 19/06/2010, à 14:06

helly a écrit :

Quelqu'un a un bon tuto de gtk à me proposer?

Oui, regarde là (en particulier celui-ci et celui-là) + la doc officiel
Les tutos ne sont peut-être pas super à jour, d'où l'intérêt de consulter la doc officiel.
C'est des tuto C mais la transposition au C++ est facile (d'ailleur en C++ c'est GTKmm qu'il faut utiliser à la place de GTK+).
Si tu veux vraiment des trucs exprès pour GTKmm regarde là pour un tuto et là pour la doc.

Pis c'est vraiment différent de Qt ?

Je ne sais pas je n'ai jamais fait de Qt, mais je pense que c'est différent.
Qt c'est limite un langage par desssus le C++ (il a son propre type string, faut utilise un précompilateur, je crois qu'il a aussi son propre Make, etc).

Dernière modification par grim7reaper (Le 19/06/2010, à 14:15)

helly · Le 19/06/2010, à 14:13

merci

Pylades · Le 19/06/2010, à 14:55

grim7reaper a écrit :

Les négatives sont inutiles à 100%, celles entre INT_MAX et UINT_MAX pourraient être utile dans le futur.

Ouah, c’te mauvaise foi !
Et moi je dis que dans la plupart des cas, celles entre INT_MAX et UINT_MAX sont inutiles à 100 %.

grim7reaper a écrit :

Ça vient d'où cette habitude étrange (le prend pas mal hein , c'est juste que je n'ai jamais compris l'intérêt) ?

J’ai l’habitude, je trouve ça plus pratique. Ça permet d’avoir une valeur de i à la sortie de la boucle qui correspond à la dernière utilisation qui en a été faite. C’est plus agréable, pour moi.

grim7reaper a écrit :

Utiliser un type qui peut représenter des valeurs négatives pour une action qui n'en nécessite pas c'est juste totalement illogique (pour rester poli ) à mon sens.

Utiliser un type qui peut représenter des valeurs énormes alors qu’on peut se contenter de bien plus petites, c’est juste totalement illogique.
Enfin, je te comprends un peu, mais avec mon expérience personnelle, je ne considère pas les entiers négatifs comme des nombres particuliers. Pour moi, il n’y a pas plus de différences entre 3 et 8 qu’entre -3 et 2. Vraiment. C’est comme ça, cela tient à ma représentation linéaire des nombres (pour les additions). Donc du coup, je peux comprendre ton point de vue, mais on ne pourra pas être d’accord.
Mais bon, ça c’est personnel.

Cependant, je t’accorde que dans certains contextes, les types non-signés peuvent être utiles, mais dans le cas où a besoin de représenter des valeurs supérieures à la borne supérieure minimale du du type signé. Mais de tels cas où l’usage du type non-signé est justifié et correct sont rares.

grim7reaper · Le 19/06/2010, à 15:15

Pylade a écrit :

grim7reaper a écrit :
Les négatives sont inutiles à 100%, celles entre INT_MAX et UINT_MAX pourraient être utile dans le futur.
Ouah, c’te mauvaise foi !
Et moi je dis que dans la plupart des cas, celles entre INT_MAX et UINT_MAX sont inutiles à 100 %.

C'est avec un raisonnement comme le tien que l'on a fait pété une Ariane 5 lors du vol 501 (le bug à 370 millions de dollars) .
Avec le mien il y a beaucoup moins de chance que ça se produise.

grim7reaper a écrit :
Ça vient d'où cette habitude étrange (le prend pas mal hein , c'est juste que je n'ai jamais compris l'intérêt) ?
J’ai l’habitude, je trouve ça plus pratique. Ça permet d’avoir une valeur de i à la sortie de la boucle qui correspond à la dernière utilisation qui en a été faite. C’est plus agréable, pour moi.

Ok, effectivement vu comme ça.
Mais bon là on est dans des considérations subjectives, débattre serait vain.

grim7reaper a écrit :
Utiliser un type qui peut représenter des valeurs négatives pour une action qui n'en nécessite pas c'est juste totalement illogique (pour rester poli ) à mon sens.
Utiliser un type qui peut représenter des valeurs énormes alors qu’on peut se contenter de bien plus petites, c’est juste totalement illogique.

Non, ça n'a rien d'illogique.
De plus ton arguments est bancal, car que ça soit signé ou pas la taille est la même mais dans un cas tu gères une gamme plus large de nombre positif. Si c'est les grandes valeurs qui te dérange prend un signed char

Donc pour une taille mémoire de X, c'est con d'utiliser une gamme qui va de 0 à Y alors que l'on peut avoir une gamme de 0 à 2Y (on passera sur les approximations) pour la même taille. C'est ton raisonnement qui est illogique, pas le mien .

On peut se contenter de petites valeurs maintenant, mais si un jour le code évolue et tu dois en gérer des plus grandes, il se passe quoi si tu oublies de mettre à jour le code (Ariane 5 ?).
J'ai l'impression que tu imagine qu'un code une fois écrit n'évolue plus. Ou que s'il évolue c'est toujours le concepteur qui s'en occupe.
C'est totalement faux dans la vrai vie. Un logiciel à une durée de vie moyenne de 5 à 10 ans (pas sûr des chiffres, à vérifier) et la maintenance et l'évolution ne sont quasiment jamais assuré par l'équipe de conception.
Développer quelque chose sans penser à la réutilisation et l'évolution du code c'est suicidaire.

Enfin, je te comprends un peu, mais avec mon expérience personnelle, je ne considère pas les entiers négatifs comme des nombres particuliers. Pour moi, il n’y a pas plus de différences entre 3 et 8 qu’entre -3 et 2.

Pourtant il y en a une de taille : le bit de signe.
Et puis un nombre négatif est représenté en complement à 2, pas un nombre positif.

Vraiment. C’est comme ça, cela tient à ma représentation linéaire des nombres (pour les additions). Donc du coup, je peux comprendre ton point de vue, mais on ne pourra pas être d’accord.
Mais bon, ça c’est personnel.

Tout à fait, là on entre dans des considérations subjectives où le débat n'apportera pas grand-choses de constructifs étant donné que chacun à ses habitudes .

Dernière modification par grim7reaper (Le 19/06/2010, à 15:20)

Pylades · Le 19/06/2010, à 16:29

grim7reaper a écrit :

C'est avec un raisonnement comme le tien que l'on a fait pété une Ariane 5 lors du vol 501 (le bug à 370 millions de dollars) .
Avec le mien il y a beaucoup moins de chance que ça se produise.

Plaît-il ?

grim7reaper a écrit :

Donc pour une taille mémoire de X, c'est con d'utiliser une gamme qui va de 0 à Y alors que l'on peut avoir une gamme de 0 à 2Y (on passera sur les approximations) pour la même taille. C'est ton raisonnement qui est illogique, pas le mien .

Tu veux représenter des nombres entre 0 et X. Tu disposes de deux types, l’un va de -Y à Y, l’autre de 0 à 2Y ; avec X < Y. Les deux fournissent plus de valeurs que nécessaire. Et tu viens m’expliquer qu’il y en a un qui est plus logique que l’autre ? O_o'

grim7reaper a écrit :

Pylade a écrit :
Enfin, je te comprends un peu, mais avec mon expérience personnelle, je ne considère pas les entiers négatifs comme des nombres particuliers. Pour moi, il n’y a pas plus de différences entre 3 et 8 qu’entre -3 et 2.
Pourtant il y en a une de taille : le bit de signe.

Je parlais d’un point de vue mathématique…

grim7reaper a écrit :

Et puis un nombre négatif est représenté en complement à 2, pas un nombre positif.

?

Bon, sinon, à propos de l’utilisation des types qui permettent d’utiliser les valeurs les plus grandes possible pour ne pas se retrouver con, je veux bien, mais il faut quand-même poser des limites, sinon on déclare tout en long long. Je vois mal un gus me passer plus de quatre milliards d’arguments, alors quatre milliards ou huit milliards… bof. Bon, le raisonnement est fondé à la base, mais ça me ferait mal au cul de rajouter des caractères dans le code juste pour prévoir le cas où le programme serait appelé avec entre quatre milliards et huit milliards de paramètres.

grim7reaper · Le 19/06/2010, à 17:25

Pylade a écrit :

grim7reaper a écrit :
Donc pour une taille mémoire de X, c'est con d'utiliser une gamme qui va de 0 à Y alors que l'on peut avoir une gamme de 0 à 2Y (on passera sur les approximations) pour la même taille. C'est ton raisonnement qui est illogique, pas le mien .
Tu veux représenter des nombres entre 0 et X. Tu disposes de deux types, l’un va de -Y à Y, l’autre de 0 à 2Y ; avec X < Y. Les deux fournissent plus de valeurs que nécessaire. Et tu viens m’expliquer qu’il y en a un qui est plus logique que l’autre ? O_o'

Oui, pour la simple et bonne raison que les négatifs ne pourront jamais être utilisé dans n'importe quel cas alors que les autres peuvent potentiellement l'être. C'est toute la différence entre un événement impossible et un événement à faible probabilité.
Il est plus logique de prévoir un cas peu probable qu'un cas impossible.

grim7reaper a écrit :
Pylade a écrit :
Enfin, je te comprends un peu, mais avec mon expérience personnelle, je ne considère pas les entiers négatifs comme des nombres particuliers. Pour moi, il n’y a pas plus de différences entre 3 et 8 qu’entre -3 et 2.
Pourtant il y en a une de taille : le bit de signe.
Je parlais d’un point de vue mathématique…

Ok, je ne pouvais pas non plus le deviner

grim7reaper a écrit :
Et puis un nombre négatif est représenté en complement à 2, pas un nombre positif.
?

Quoi ?
Tu ne connais pas le complément à 2 ?
Si c'est que tu ne vois pas ce que ça fait là, c'est juste que je citais une différence (au même titre que le bit de signe).

Bon, sinon, à propos de l’utilisation des types qui permettent d’utiliser les valeurs les plus grandes possible pour ne pas se retrouver con, je veux bien, mais il faut quand-même poser des limites, sinon on déclare tout en long long.

Oui bien sûr c'est logique, si les principes existes c'est pour donner les grandes lignes de conduite. Les appliquer sans réfléchir c'est être le dernier des abrutis, on est bien d'accord là dessus.
Mais dans le cas présent, tes histoires de capacité inte-types je m'en tamponne l'oreille avec une babouche en satin de ça. Ce n'est pas le sujet.
On parle de type de signe différents (mais de taille identique), pas de taille différente…

Je vois mal un gus me passer plus de quatre milliards d’arguments, alors quatre milliards ou huit milliards… bof. Bon, le raisonnement est fondé à la base, mais ça me ferait mal au cul de rajouter des caractères dans le code juste pour prévoir le cas où le programme serait appelé avec entre quatre milliards et huit milliards de paramètres.

Si tu en est à compter les caractères de ton code source je ne peux plus rien pour toi là .
N'utilise pas d'identificateurs de plus de 3 lettres tant que tu y est, et puis supprime les espaces aussi ça ne sert à rien…

\\Ouranos// · Le 19/06/2010, à 19:06

grim7reaper a écrit :

Pylade a écrit :
grim7reaper a écrit :
Donc pour une taille mémoire de X, c'est con d'utiliser une gamme qui va de 0 à Y alors que l'on peut avoir une gamme de 0 à 2Y (on passera sur les approximations) pour la même taille. C'est ton raisonnement qui est illogique, pas le mien .
Tu veux représenter des nombres entre 0 et X. Tu disposes de deux types, l’un va de -Y à Y, l’autre de 0 à 2Y ; avec X < Y. Les deux fournissent plus de valeurs que nécessaire. Et tu viens m’expliquer qu’il y en a un qui est plus logique que l’autre ? O_o'
Oui, pour la simple et bonne raison que les négatifs ne pourront jamais être utilisé dans n'importe quel cas alors que les autres peuvent potentiellement l'être. C'est toute la différence entre un événement impossible et un événement à faible probabilité.
Il est plus logique de prévoir un cas peu probable qu'un cas impossible.

[chieur]Ouais, mais pour le cas d'une loi continue (parce qu'avec 4 milliards d'arguments, on s'en approche pas mal), les deux ont une probabilité de 0 [/chieur]

Je vois mal un gus me passer plus de quatre milliards d’arguments, alors quatre milliards ou huit milliards… bof. Bon, le raisonnement est fondé à la base, mais ça me ferait mal au cul de rajouter des caractères dans le code juste pour prévoir le cas où le programme serait appelé avec entre quatre milliards et huit milliards de paramètres.
Si tu en est à compter les caractères de ton code source je ne peux plus rien pour toi là .
N'utilise pas d'identificateurs de plus de 3 lettres tant que tu y est, et puis supprime les espaces aussi ça ne sert à rien…

Et les instructions sur une seule ligne aussi

\\Ouranos// · Le 19/06/2010, à 23:14

Bon, je vais me coucher, BN.

Pylades · Le 19/06/2010, à 23:43

grim7reaper a écrit :

Oui, pour la simple et bonne raison que les négatifs ne pourront jamais être utilisé dans n'importe quel cas alors que les autres peuvent potentiellement l'être. C'est toute la différence entre un événement impossible et un événement à faible probabilité.
Il est plus logique de prévoir un cas peu probable qu'un cas impossible.

J’avais dit X < Y, donc l’événement X > Y est impossible. Quoi q’il arrive, le bit de poids fort sera nul, donc il n’y a pas de différence entre les types signés et et non-signés.

grim7reaper a écrit :

Si tu en est à compter les caractères de ton code source je ne peux plus rien pour toi là .

Voir un unsigned qui n’est pas dûment justifié dans du code, je ne trouve pas ça joli (question de goût).
Et comme j’utilise souvent un valeur négative pour l’initialisation…

grim7reaper a écrit :

N'utilise pas d'identificateurs de plus de 3 lettres tant que tu y est, et puis supprime les espaces aussi ça ne sert à rien…

Tu rigoles, mais je n’utilise pas beaucoup d’identificateurs de plus de trois lettres, pour les variables. Et je n’utilise pas non plus beaucoup d’espaces. Je ne trouve pas ça esthétique (je préfère la coloration, pour me repérer (je sais, ce n’est pas bien de penser que le code ne sera lu que par soi)).

Sache que si je semble virulent, ce que je ne suis pas encore convaincu ; et que j’essaie de provoquer une réponse qui va me convaincre.

\\Ouranos// a écrit :

[chieur]Ouais, mais pour le cas d'une loi continue (parce qu'avec 4 milliards d'arguments, on s'en approche pas mal), les deux ont une probabilité de 0 [/chieur]

Ouais mais non. Avec une loi continue, la probabilité que tu obtienne une valeur discrète est nulle, mais à nous parlons d’un intervalle [2147483647, 4294967295].
Et puis il est interdit de faire de quantités discrètes des quantités continues. Ces approximations, c’est bon pour les physiciens. Avec ce genre de chose, on peut prouver que 2 = √2 (si, je l’ai fait).

\\Ouranos// a écrit :

Et les instructions sur une seule ligne aussi

À la Google.

Bon, sinon je vais probablement faire héberger une archive contenant une version inachevée du code. C’est pour que vous puissiez voir la gueule que ça a et m’assassiner si nécessaire. Mais vous avez interdiction de lire le code tant que vous n’avez pas terminé vos exams respectifs.

grim7reaper · Le 20/06/2010, à 00:05

Pylade a écrit :

J’avais dit X < Y, donc l’événement X > Y est impossible. Quoi q’il arrive, le bit de poids fort sera nul, donc il n’y a pas de différence entre les types signés et et non-signés.

'ffectivement, dans ce cas il n'y a aucune différence (j'avais lu trop vite, du coup j'ai parlé du cas général).

grim7reaper a écrit :
Si tu en est à compter les caractères de ton code source je ne peux plus rien pour toi là .

Voir un unsigned qui n’est pas dûment justifié dans du code, je ne trouve pas ça joli (question de goût).
Et comme j’utilise souvent un valeur négative pour l’initialisation…

Oui c'est sûr que dans ton cas, les unsigned ce n'est pas possible.
Moi j'initialise à zéro car je trouve ça "logique" et j'aime bien avoir la taille du tableau en sortie. Du coup je peut utiliser les unsigned .
Mais c'est le genre de choses qui sont subjectives, chacun fait comme il veux (d'ailleurs je crois que gnuuat fait comme toi).

Sache que si je semble virulent, ce que je ne suis pas encore convaincu ; et que j’essaie de provoquer une réponse qui va me convaincre.

Bah sur ce coup là il y a peu de chance que je te convainque car on est vraiment en plein dans le "guide de style" propre à chacun (comme les accolades, espace vs tabulations, etc).
Donc à moins de sortir des trucs d'une mauvaise foi manifeste, je ne pourrai pas te donner d'arguments irréfutables .

Bon, sinon je vais probablement faire héberger une archive contenant une version inachevée du code. C’est pour que vous puissiez voir la gueule que ça a et m’assassiner si nécessaire. Mais vous avez interdiction de lire le code tant que vous n’avez pas terminé vos exams respectifs.

Dès vendredi 16h mon sort sera scellé.

Dernière modification par grim7reaper (Le 20/06/2010, à 02:08)

Ubuntu-fr

Navigation

Liens de recherche

Annonce

#226 Le 19/06/2010, à 10:41

Re : /* Topic des codeurs couche-tard [1] */

#227 Le 19/06/2010, à 11:34

Re : /* Topic des codeurs couche-tard [1] */

#228 Le 19/06/2010, à 11:37

Re : /* Topic des codeurs couche-tard [1] */

#229 Le 19/06/2010, à 11:41

Re : /* Topic des codeurs couche-tard [1] */

#230 Le 19/06/2010, à 11:45

Re : /* Topic des codeurs couche-tard [1] */

#231 Le 19/06/2010, à 11:49

Re : /* Topic des codeurs couche-tard [1] */

#232 Le 19/06/2010, à 11:56

Re : /* Topic des codeurs couche-tard [1] */

#233 Le 19/06/2010, à 12:07

Re : /* Topic des codeurs couche-tard [1] */

#234 Le 19/06/2010, à 12:15

Re : /* Topic des codeurs couche-tard [1] */

#235 Le 19/06/2010, à 12:59

Re : /* Topic des codeurs couche-tard [1] */

#236 Le 19/06/2010, à 13:14

Re : /* Topic des codeurs couche-tard [1] */

#237 Le 19/06/2010, à 13:29

Re : /* Topic des codeurs couche-tard [1] */

#238 Le 19/06/2010, à 13:48

Re : /* Topic des codeurs couche-tard [1] */

#239 Le 19/06/2010, à 13:54

Re : /* Topic des codeurs couche-tard [1] */

#240 Le 19/06/2010, à 14:01

Re : /* Topic des codeurs couche-tard [1] */

#241 Le 19/06/2010, à 14:06

Re : /* Topic des codeurs couche-tard [1] */

#242 Le 19/06/2010, à 14:13

Re : /* Topic des codeurs couche-tard [1] */

#243 Le 19/06/2010, à 14:55

Re : /* Topic des codeurs couche-tard [1] */

#244 Le 19/06/2010, à 15:15

Re : /* Topic des codeurs couche-tard [1] */

#245 Le 19/06/2010, à 16:29

Re : /* Topic des codeurs couche-tard [1] */

#246 Le 19/06/2010, à 17:25

Re : /* Topic des codeurs couche-tard [1] */

#247 Le 19/06/2010, à 19:06

Re : /* Topic des codeurs couche-tard [1] */

#248 Le 19/06/2010, à 23:14

Re : /* Topic des codeurs couche-tard [1] */

#249 Le 19/06/2010, à 23:43

Re : /* Topic des codeurs couche-tard [1] */

#250 Le 20/06/2010, à 00:05

Re : /* Topic des codeurs couche-tard [1] */

Pied de page des forums