Anthony Jaguenaud a écrit 1957 commentaires

Le 386 avait deux variantes : SX et DX. Dans les deux cas le processeur avait des registres 32 bits, mais le bus du 386/SX était 16 bits

C'est marrant, moi mon souvenir c'était que le DX embarquait un coprocesseur mathématique et pas le SX… Ça ne remet pas en question ton affirmation, juste qu'on ne garde pas les même souvenir.

Du code spaghetti pour réparer du code spaghetti, donc :D

Non, avec les exceptions, en plus de pouvoir utiliser les héritages pour les classes d’exception, le try est définie dans un bloc clairement identifier, rien à voir avec un systhème de goto ou de if sur une profondeurs de dix appels.

Une classe définie une erreur, elle peut throw l’exception dans n’importe quelle méthode, sous méthode sans compliqué son code avec des if. À l’utilisateur de récupérer l’exception.

Sinon comme proposé on peut avoir une méthode sans exception :

retCode fct_no_except(...)
{
    retCode = rc = NO_ERROR;
    try {
       ftc(...)
    } catch (Erreur e) {
        rc = e.getCodeNumber();
    } catch (...)
    {
        rc = UNKNOWN_ERROR;
    }
    return rc;
}

Sérieusement, qu’on applique la réforme de 1990, ok. Mais les contraintes de non-genre des féministes je suis contre. Ici ça reste compréhensible, mais dans plein de cas ça rend le texte difficile à lire. Si certain(e)s veulent le faire dans leurs commentaires ok, c’est leur choix, mais sur les règles d’écriture du site, je trouve plus pertinent de respecter les règles officielles.

À moins, que cette nouvelle forme est été approuvée. Est-ce le cas ?

Les prix sont en $, pourquoi ne pas pouvoir choisir € ?

J’ai un peu de mal a savoir où mettre quoi ? Les slots disponibles sont gris, mais c’est quoi ? il aurait été utile de mettre : PCI-e, RAM, CPU sur les emplacements gris. Ça facilite la compréhension. De même que si on sélectionne un slot, ce serait bien de voir d’un coup d’œil les éléments enfichable à cet endroit.

Bonne continuation.

Les fonctionnaires sont des abrutis, des fainéants… c’est connu tout le monde le dit alors tu le crois. Le problème c’est que 90% de ce « tout le monde » est incapable de réussir un concours pour justement devenir fonctionnaire. Donc laisse moi rire.

Il y a des glandeurs chez les fonctionnaires ? Oui, mais je pense que le pourcentage de glandeur est le même que dans le privé.

Je ne suis pas fonctionnaire moi même, mais j’en connais un certain nombre (enseignants principalement mais pas que) et ils ne glandent pas… mais c’est peut être pour ça que je m’entends bien avec eux, et que je pense que j’aurais du mal avec toi.

Mes grands ont 11 et 9,5 ans. Mon fils (11) passerait sa vie sur l’ordinateur, faire du python, du minecraft, du scratch… ce n’est pas inintéressant en soit, mais il me semble important qu’il fasse autre chose : voir la lumière du jour, nager, faire du vélo, de la voile, jouer de la musique…
Ma fille 9,5 ans passerait sa vie à lire, mais ça me semble important qu’elle fasse aussi autre chose : voir ci dessus.

Quand ils seront adultes, il me remercieront ou me détesteront de les avoir obligés à s’ouvrir l’esprit, à avoir l’habitude de faire du sport pour être bien dans sa tête et son corps.

Néanmoins, cette année, mon fils s’est enfin ouvert aux autres, notamment activité foot à la récréation… tout ça parce qu’il a joué et parlé de minecraft avec les copains. Donc les deux sont liés, mais il est toujours compliqué en tant que parent de décider ce qui est le mieux et où mettre le curseur entre les différentes activités.

Résultat du projet dans 10 ans, sans retour en arrière possible ! :-|

Elle nous a pris de court

Sauf si le nous ne concerne que des personnes au féminin. Dans ce cas, le prises est correcte, non ?

*avent
oui je sais ça pique les yeux, mais c'est comme ça…

Ben non, ça pique pas les yeux, ça dit juste que ça n’a rien à voir avec une notion temporelle…

Je plagie juste wikipedia : L'Avent (du latin adventus : avènement, arrivée du Messie)

Salut,
Je navigue dans les mêmes conditions, et honnêtement, j’ai vu du mieux. Avant on ne pouvait pas payer, aujourd’hui, une fois la première redirection chez le prestataire, j’ai un bouton qui me dit de cliquer dessus pour faire la redirection. Je n’ai presque plus de problème pour faire des achats en ligne.

Par contre, je me pose aussi la question de l’accessibilité… mes enfants étant dans une école qui accueille des mal/non voyant. Tous ces sites en javascript sont-ils utilisable avec une machine braille ?

Il me semblait que les bonnes pratiques étaient plus ou moins obligatoire (enfin dans les années 2000) :

• Mettre un menu au début pour sauter rapidement à la bonne partie de la page
• Le champ ALT pour décrire l’image qui ne peut être visualisé
• …

Mon besoin était de surveiller (monitoring) des services dont l'un n'avait pas de mode démon. Il n'écrivait même pas son PID dans un fichier. Ça a l'air tout bête, mais il n'y a guère d'outil pour surveiller un service de ce type, et le relancer en cas de crash ou de signal d'arrêt. C'est pour ça que j'avais opté pour runit.

Et une ligne dans /etc/inittab ?

id:345:respawn:/chemin/process

Ça ne marchait pas ?

Oui, mais j’ai fait simple. Comme j’ai un nombre de nœuds et de liens connu au démarrage (lecture fichier) et que c’est statique ensuite, j’ai fait un tableau vecteur de nœuds, ensuite je créé également un vecteur de liens. Je peux construire mes liens avec des références, puisque connue à la construction et que le reserve me garanti que les éléments de mon vecteur ne seront pas déplacé.

Ce que j’ai fait n’a rien de complexe à la base, je voulais m’entrainer au c++11 pour une fois que je ne suis pas coincé par du 03 voir antérieur… du coup, c’est un fail pour mon essai des shared_ptr. Par contre j’ai progressé dans le choix de quand les utiliser ou non.

La solution de faire des vecteurs de pointeurs me semble faire de l’overengineering… donc pas de c++11 pour cette partie :'(

J’ai essayé, mais le programme crash quand il cherche à désallouer mais objets statiques…

C’est quoi la bonne méthode pour pointer sur un objet static ou global en c++11 ?

• Garder les pointeurs standard ?
• Les références dans mon cas je peux le faire.
• Les shared ptr ne semble pas adapté.
• Les weak ptr peut-être ?

Un avis sur la question ?

Oui, je sais que ça marche comme ça. Mais dans mon vrai code, qui est une implémentation de graph, je fais les get dans les constructeur de liens entre mes Nodes… pas à deux lignes d’intervalle comme dans l’exemple.

Bon, en gros, je continue avec des pointeurs standard… je devrais me trouver un autre exercice pour utiliser les pointeurs intelligent. Moi qui pensait qu’on allait pouvoir s’affranchir complètement des pointeurs historique…

Ben avec gcc et clang ça ne marche pas chez moi.

In file included from main.cpp:1:
In file included from /usr/lib/gcc/x86_64-pc-linux-gnu/4.9.3/include/g++-v4/iostream:39:
In file included from /usr/lib/gcc/x86_64-pc-linux-gnu/4.9.3/include/g++-v4/ostream:38:
In file included from /usr/lib/gcc/x86_64-pc-linux-gnu/4.9.3/include/g++-v4/ios:42:
In file included from /usr/lib/gcc/x86_64-pc-linux-gnu/4.9.3/include/g++-v4/bits/ios_base.h:41:
In file included from /usr/lib/gcc/x86_64-pc-linux-gnu/4.9.3/include/g++-v4/bits/locale_classes.h:40:
In file included from /usr/lib/gcc/x86_64-pc-linux-gnu/4.9.3/include/g++-v4/string:41:
In file included from /usr/lib/gcc/x86_64-pc-linux-gnu/4.9.3/include/g++-v4/bits/allocator.h:46:
In file included from /usr/lib/gcc/x86_64-pc-linux-gnu/4.9.3/include/g++-v4/x86_64-pc-linux-gnu/bits/c++allocator.h:33:
/usr/lib/gcc/x86_64-pc-linux-gnu/4.9.3/include/g++-v4/ext/new_allocator.h:120:23: error: no matching constructor for initialization of 'MyInt'
        { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
                             ^   ~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/lib/gcc/x86_64-pc-linux-gnu/4.9.3/include/g++-v4/bits/alloc_traits.h:253:8: note: in instantiation of function template specialization '__gnu_cxx::new_allocator<MyInt>::construct<MyInt, MyInt *>' requested here
        { __a.construct(__p, std::forward<_Args>(__args)...); }
              ^
/usr/lib/gcc/x86_64-pc-linux-gnu/4.9.3/include/g++-v4/bits/alloc_traits.h:399:4: note: in instantiation of function template specialization 'std::allocator_traits<std::allocator<MyInt> >::_S_construct<MyInt, MyInt *>' requested here
        { _S_construct(__a, __p, std::forward<_Args>(__args)...); }
          ^
/usr/lib/gcc/x86_64-pc-linux-gnu/4.9.3/include/g++-v4/bits/shared_ptr_base.h:515:30: note: in instantiation of function template specialization 'std::allocator_traits<std::allocator<MyInt> >::construct<MyInt, MyInt *>' requested here
          allocator_traits<_Alloc>::construct(__a, _M_ptr(),
                                    ^
/usr/lib/gcc/x86_64-pc-linux-gnu/4.9.3/include/g++-v4/ext/new_allocator.h:120:23: note: in instantiation of function template specialization 'std::_Sp_counted_ptr_inplace<MyInt, std::allocator<MyInt>, 2>::_Sp_counted_ptr_inplace<MyInt *>' requested here
        { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
                             ^
/usr/lib/gcc/x86_64-pc-linux-gnu/4.9.3/include/g++-v4/bits/alloc_traits.h:253:8: note: in instantiation of function template specialization '__gnu_cxx::new_allocator<std::_Sp_counted_ptr_inplace<MyInt, std::allocator<MyInt>, 2>
      >::construct<std::_Sp_counted_ptr_inplace<MyInt, std::allocator<MyInt>, 2>, const std::allocator<MyInt>, MyInt *>' requested here
        { __a.construct(__p, std::forward<_Args>(__args)...); }
              ^
/usr/lib/gcc/x86_64-pc-linux-gnu/4.9.3/include/g++-v4/bits/alloc_traits.h:399:4: note: (skipping 2 contexts in backtrace; use -ftemplate-backtrace-limit=0 to see all)
        { _S_construct(__a, __p, std::forward<_Args>(__args)...); }
          ^
/usr/lib/gcc/x86_64-pc-linux-gnu/4.9.3/include/g++-v4/bits/shared_ptr_base.h:1089:14: note: in instantiation of function template specialization 'std::__shared_count<2>::__shared_count<MyInt, std::allocator<MyInt>, MyInt *>' requested here
        : _M_ptr(), _M_refcount(__tag, (_Tp*)0, __a,
                    ^
/usr/lib/gcc/x86_64-pc-linux-gnu/4.9.3/include/g++-v4/bits/shared_ptr.h:316:4: note: in instantiation of function template specialization 'std::__shared_ptr<MyInt, 2>::__shared_ptr<std::allocator<MyInt>, MyInt *>' requested here
        : __shared_ptr<_Tp>(__tag, __a, std::forward<_Args>(__args)...)
          ^
/usr/lib/gcc/x86_64-pc-linux-gnu/4.9.3/include/g++-v4/bits/shared_ptr.h:587:14: note: in instantiation of function template specialization 'std::shared_ptr<MyInt>::shared_ptr<std::allocator<MyInt>, MyInt *>' requested here
      return shared_ptr<_Tp>(_Sp_make_shared_tag(), __a,
             ^
/usr/lib/gcc/x86_64-pc-linux-gnu/4.9.3/include/g++-v4/bits/shared_ptr.h:603:19: note: in instantiation of function template specialization 'std::allocate_shared<MyInt, std::allocator<MyInt>, MyInt *>' requested here
      return std::allocate_shared<_Tp>(std::allocator<_Tp_nc>(),
                  ^
main.cpp:91:13: note: in instantiation of function template specialization 'std::make_shared<MyInt, MyInt *>' requested here
  auto p1 = make_shared<MyInt>(&MyInt::get(3));
            ^
main.cpp:13:7: note: candidate constructor (the implicit copy constructor) not viable: no known conversion from 'MyInt *' to 'const MyInt' for 1st argument; dereference the argument with *
class MyInt {
      ^
main.cpp:13:7: note: candidate constructor (the implicit move constructor) not viable: no known conversion from 'MyInt *' to 'MyInt' for 1st argument; dereference the argument with *
class MyInt {
      ^
main.cpp:27:3: note: candidate constructor not viable: no known conversion from 'MyInt *' to 'int' for 1st argument
  MyInt(int n):id(n){}
  ^
1 error generated.

L’operateur [] sera pour la norme 2017.

Rajouter le & devant ne résout pas le problème car ça ne compile pas.

J’ai le choix entre mettre les pointeurs historiques, ou faire un my_ptr<MyInt> qui me garanti juste qu’on pointe sur quelque chose de valide.

J’avais pensé mettre un shared_ptr à la place du vector, mais je ne pense pas qu’on puisse ensuite pointer sur les éléments individuellement, ni y accéder via l’operator [].

J’ai essayé, mais ça ne compile pas… il semble que make_shared alloue de la mémoire et recopie l’objet dedans.

La boisson est le réussite universitaire sont lié, mais pas forcément dans le sens d’implication voulu par celui à qui tu réponds. De ce que j’ai pu voir de mon temps à la FAC, c’est que certains étudiants brillants travaillaient beaucoup, et quand ils décompressaient, ils allaient trop loin dans l’alcool entre autre. Mais je pense que c’est plus corrélé au stress induit qu’à l’intelligence.

Donc si on regarde les étudiants en réussite une parti boivent trop. Proportionnellement plus que les étudiants moins fort. En corrélant ça au stress plus qu’à la réussite, je pense qu’on aurait une meilleurs vision des choses… comme toujours, les stat c’est pratique pour dire ce qu’on veut ;-)

Ajout:
Et puis, ça a un côté rassurant quand on est alcoolique de se dire : « Ce n’est pas ma faute, je suis intelligent ».

Dans la même veine que Scratch : https://code.org/

J’ai aimé aussi https://lightbot.com/

Pour apprendre le python : https://codecombat.com/ j’ai trouvé ça rigolo mais trop répétitif. Sinon il y a aussi https://www.codecademy.com/fr

Je n’aime pas l’utilisation d’une macro pour plusieurs paramètres.

Même si c’est pas mal, on ne comprend pas tout de suite où sont les paramètres manquants, pire, si tu veux faire de la traduction et utiliser la syntaxe permettant de prendre le deuxième paramètre, puis le premier… tu risques d’avoir du mal à compter correctement.

Le C permet de faire des choses sympas, de manière souple, mais il ne faut pas oublier la relecture par un futur collègue, ou même par toi même quand tu reviens quelques mois plus tard. Si tu passes un quart d’heure à re-comprendre alors que tu l’aurais écrit en 5 minutes de plus (je suis large), tu perds du temps globalement.

En fait, c’est un problème d’interpréteur… en prenant le même code dans un fichier : linuxfr.hs

Prelude> :l linuxfr.hs
[1 of 1] Compiling Main             ( linuxfr.hs, interpreted )
Ok, modules loaded: Main.
*Main> f [1,2]
[0.3333333333333333,0.6666666666666666]
*Main> f [1..10]
[1.818181818181818e-2,3.636363636363636e-2,5.454545454545454e-2,7.272727272727272e-2,9.090909090909091e-2,0.10909090909090909,0.12727272727272726,0.14545454545454545,0.16363636363636364,0.18181818181818182]
*Main>

Quand je définie tout dans l’interpréteur ça ne marche pas… bon, ce n’est pas grave. Merci pour la démonstration.

Source :

g s l =  ((map (/s) l),sum l)

f l = let (res,s) = g s l in res

main = putStrLn $ show $ f [1,2]

Je n’arrive pas à reproduire ce que tu décris. J’ai fait mes tests dans l’interpréteur ghci :

Prelude> let g s l =  ((map (/s) l),sum l)
Prelude> let f l = let (res,s) = g s l in res
Prelude> f [1,2]
*** Exception: <<loop>>
Prelude> let r = f [1,2]
Prelude> l
*** Exception: <<loop>>

Par contre :

Prelude> let f l = let (res,s) = g (sum l) l in res
Prelude>  f [1,2]
[0.3333333333333333,0.6666666666666666]
Prelude>

Je me demande si ce n’est pas ton implémentation de g qui ferait que ça marche ?

Du coup ma solution ressemblerait plus à :

char padding[255] = { [0 ... 253] = '.', [254] = 0 }; /* ATTENTION ggc uniquement */
int align = 15;
char *str = "hello";
printf("%.*s%s\n",align-strlen(str),padding,str);

Merci :

• De m’avoir confirmé l’impossibilité ;
• De m’avoir donné un work arround.

Si je dis qu'une Porsche ça se trouve à partir de 50k (j'en sais rien), en quoi ça ferait rire (même jaune)?

Pour rester dans le ton de kantien tu devrais écrire : « Si je dis qu'une voitureça se trouve à partir de 50k » tu comprendrais mieux où il veut en venir.

Si les gens achètent des téléphones si cher, c’est parce qu’il les payent à crédit dans leur abonnement.