Chercher un livre sur le C avec certains critères.
200 réponses
Francois
Bonjour à tous,
Je débute dans le C et personnellement j'apprends surtout avec les
livres. J'ai commencé "Livre du C premier langage" de Delannoy (je
précise que j'avais quand même des petites notions de programmations,
même si, à mon sens, j'étais [ et suis encore ? ] vraiment ce qu'on
appelle un débutant).
Je suis en train de lire le K&R (deuxième édition) qui est bien sûr
beaucoup plus difficile. C'est du concentré, mais quand on y regarde de
prêt, c'est quand assez précis et bien fait. Ceci étant, il y a des
choses qui ne me satisfont pas complètement.
Je trouve que ce livre à une approche trop éloignée de la machine
(comment une donnée est encodée ? comment se passe l'histoire du signed
ou unsigned du point de vue de la machine etc.). Je m'explique.
Bien sûr, le langage C est un langage abstrait de "haut niveau" qui se
doit (en principe) de ne pas faire référence à la machine. Donc c'est
normal qu'un livre sur le C ne parle pas (trop) des problèmes qui
dépendent de l'architecture. Ceci étant, j'aimerais savoir si un tel
livre existe malgré tout. Un livre qui expose le langage C et qui
n'hésite pas de temps en temps à parler de ce qui se passe dans la
machine (bien sûr, justement, ce qui se passe dépend de la machine et
n'est pas universel, mais le livre pourrait présenter les choses sur
seulement une architecture "classique" par exemple). Bon, si je pouvais
éviter les circuits électroniques et compagnie quand même, ça serait
bien. Qu'on me dise que "le complément à 2 fait que l'addition devient
plus simple pour l'ordinateur puisqu'il suffit de faire une addition
classique" me suffit amplement. Une preuve de cela en passant des
explications sur des circuits électroniques peut-être me serait un peu
indigeste.
Bref, j'espère avoir été clair sur cette sorte de compromis que je
recherche (existe-t-il ?). Vous pouvez aller voir cette discussion (où
mon pseudo est sisco)
Tient, on commence l'année en disant qu'il ne faut pas de variable globale, et à la fin de l'année, quand on faut un mini purify, qui surcharge malloc/calloc/free, ben, on en utilise...
En effet le discours académique selon lequel il ne faut pas utiliser de variables globales (quand ce discours n'est pas accompagné d'une aversion violente contre elles, ahem, visez mon regard) à de quoi surprendre quand on voit la masse de code professionnel rempli de variables globales.
Quand tu dois maintenir une masse de code "professionnel", effectivement rempli de variables globales, et que tu t'aperçois que presque tous les problèmes rencontrés (bugs, plantages, difficultés d'évolution) proviennent presque toujours de l'abus de globales inutiles, tu te dis que le discours académique a quand même un interêt.
Mais bon, pour du code, le qualificatif "professionnel" c'est pas forcement un gage de qualité.
Tient, on commence l'année en disant qu'il ne faut pas de variable
globale, et à la fin de l'année, quand on faut un mini purify,
qui surcharge malloc/calloc/free, ben, on en utilise...
En effet le discours académique selon lequel il ne faut pas utiliser de
variables globales (quand ce discours n'est pas accompagné d'une
aversion violente contre elles, ahem, visez mon regard) à de quoi
surprendre quand on voit la masse de code professionnel rempli de
variables globales.
Quand tu dois maintenir une masse de code "professionnel", effectivement
rempli de variables globales, et que tu t'aperçois que presque tous les
problèmes rencontrés (bugs, plantages, difficultés d'évolution)
proviennent presque toujours de l'abus de globales inutiles, tu te dis
que le discours académique a quand même un interêt.
Mais bon, pour du code, le qualificatif "professionnel" c'est pas
forcement un gage de qualité.
Tient, on commence l'année en disant qu'il ne faut pas de variable globale, et à la fin de l'année, quand on faut un mini purify, qui surcharge malloc/calloc/free, ben, on en utilise...
En effet le discours académique selon lequel il ne faut pas utiliser de variables globales (quand ce discours n'est pas accompagné d'une aversion violente contre elles, ahem, visez mon regard) à de quoi surprendre quand on voit la masse de code professionnel rempli de variables globales.
Quand tu dois maintenir une masse de code "professionnel", effectivement rempli de variables globales, et que tu t'aperçois que presque tous les problèmes rencontrés (bugs, plantages, difficultés d'évolution) proviennent presque toujours de l'abus de globales inutiles, tu te dis que le discours académique a quand même un interêt.
Mais bon, pour du code, le qualificatif "professionnel" c'est pas forcement un gage de qualité.
candide
De mon point de vue une variable globale doit etre pesee, et justifiee. Il faut qu'il y ait de tres tres bonnes raisons (de lisibilite et de performances, le plus souvent) pour avoir des variables globales.
J'aurais plutôt confiance en ce que tu dis. Néanmoins, moi je me contente d'observer, par exemple du code pro ou supposé tel, je viens de prendre un fichier absolument au hasard dans le répertoire où je recueille du code source, je tombe là-dessus :
-----------------------------------8<-------------------------------- /* cairo - a vector graphics library with display and print output etc. */ /* #include omis */
static const cairo_t cairo_nil = { (unsigned int)-1, /* ref_count */ CAIRO_STATUS_NO_MEMORY, /* status */ { /* path */ NULL, NULL, /* op_buf_head, op_buf_tail */ NULL, NULL, /* arg_buf_head, arg_buf_tail */ { 0, 0 }, /* last_move_point */ { 0, 0 }, /* current point */ FALSE, /* has_current_point */ }, NULL /* gstate */ }; ----------------------------------->8-------------------------------- C'est bien une variable globale ça, même si déclarée static.
Je cherche maintenant un exemple dans GMP : bon, je ne trouve pas un exemple immédiatement mais je finis par en trouver, par exemple time.c :
-----------------------------------8<-------------------------------- /* Time routines for speed measurments.
char speed_time_string[256]; int speed_precision = 0; double speed_unittime; double speed_cycletime = 0.0; ----------------------------------->8-------------------------------- et encore je n'ai mis que le début d'une longue liste.
Et je pourrais multiplier les exemples.
De mon point de vue une variable globale doit etre pesee, et justifiee.
Il faut qu'il y ait de tres tres bonnes raisons (de lisibilite et de
performances, le plus souvent) pour avoir des variables globales.
J'aurais plutôt confiance en ce que tu dis. Néanmoins, moi je me
contente d'observer, par exemple du code pro ou supposé tel, je viens de
prendre un fichier absolument au hasard dans le répertoire où je
recueille du code source, je tombe là-dessus :
-----------------------------------8<--------------------------------
/* cairo - a vector graphics library with display and print output
etc.
*/
/* #include omis */
static const cairo_t cairo_nil = {
(unsigned int)-1, /* ref_count */
CAIRO_STATUS_NO_MEMORY, /* status */
{ /* path */
NULL, NULL, /* op_buf_head, op_buf_tail */
NULL, NULL, /* arg_buf_head, arg_buf_tail */
{ 0, 0 }, /* last_move_point */
{ 0, 0 }, /* current point */
FALSE, /* has_current_point */
},
NULL /* gstate */
};
----------------------------------->8--------------------------------
C'est bien une variable globale ça, même si déclarée static.
Je cherche maintenant un exemple dans GMP : bon, je ne trouve pas un
exemple immédiatement mais je finis par en trouver, par exemple time.c :
-----------------------------------8<--------------------------------
/* Time routines for speed measurments.
char speed_time_string[256];
int speed_precision = 0;
double speed_unittime;
double speed_cycletime = 0.0;
----------------------------------->8--------------------------------
et encore je n'ai mis que le début d'une longue liste.
De mon point de vue une variable globale doit etre pesee, et justifiee. Il faut qu'il y ait de tres tres bonnes raisons (de lisibilite et de performances, le plus souvent) pour avoir des variables globales.
J'aurais plutôt confiance en ce que tu dis. Néanmoins, moi je me contente d'observer, par exemple du code pro ou supposé tel, je viens de prendre un fichier absolument au hasard dans le répertoire où je recueille du code source, je tombe là-dessus :
-----------------------------------8<-------------------------------- /* cairo - a vector graphics library with display and print output etc. */ /* #include omis */
static const cairo_t cairo_nil = { (unsigned int)-1, /* ref_count */ CAIRO_STATUS_NO_MEMORY, /* status */ { /* path */ NULL, NULL, /* op_buf_head, op_buf_tail */ NULL, NULL, /* arg_buf_head, arg_buf_tail */ { 0, 0 }, /* last_move_point */ { 0, 0 }, /* current point */ FALSE, /* has_current_point */ }, NULL /* gstate */ }; ----------------------------------->8-------------------------------- C'est bien une variable globale ça, même si déclarée static.
Je cherche maintenant un exemple dans GMP : bon, je ne trouve pas un exemple immédiatement mais je finis par en trouver, par exemple time.c :
-----------------------------------8<-------------------------------- /* Time routines for speed measurments.
char speed_time_string[256]; int speed_precision = 0; double speed_unittime; double speed_cycletime = 0.0; ----------------------------------->8-------------------------------- et encore je n'ai mis que le début d'une longue liste.
Et je pourrais multiplier les exemples.
espie
In article <47d6fe14$0$16528$, candide wrote:
De mon point de vue une variable globale doit etre pesee, et justifiee. Il faut qu'il y ait de tres tres bonnes raisons (de lisibilite et de performances, le plus souvent) pour avoir des variables globales.
J'aurais plutôt confiance en ce que tu dis. Néanmoins, moi je me contente d'observer, par exemple du code pro ou supposé tel, je viens de prendre un fichier absolument au hasard dans le répertoire où je recueille du code source, je tombe là-dessus :
Ah oui, cairo, le truc sympa ou ils ont juste arrete completement le support pour les cartes graphiques en 8 bits... un peu genants pour les vieilles machines.
-----------------------------------8<-------------------------------- /* cairo - a vector graphics library with display and print output etc. */ /* #include omis */
static const cairo_t cairo_nil = { (unsigned int)-1, /* ref_count */ CAIRO_STATUS_NO_MEMORY, /* status */ { /* path */ NULL, NULL, /* op_buf_head, op_buf_tail */ NULL, NULL, /* arg_buf_head, arg_buf_tail */ { 0, 0 }, /* last_move_point */ { 0, 0 }, /* current point */ FALSE, /* has_current_point */ }, NULL /* gstate */ }; ----------------------------------->8-------------------------------- C'est bien une variable globale ça, même si déclarée static.
C'est l'exemple-meme d'une variable globale non justifiee ;-) J'ai le code de cairo sous les yeux, version 1.4.14 (plus recente que la tienne je soupconne, puisque cairo_nil y est devenue _cairo_nil et que (unsigned int)-1 est devenu CAIRO_REF_COUNT_INVALID), et cette variable statique est utilisee dans *exactement* une question. Elle n'a aucune raison de vivre ailleurs...
Apres, le coup de renvoyer une pseudo-structure plutot qu'un pointeur nul, je ne suis pas vraiment sur que l'optimisation en vaille le coup.
Je cherche maintenant un exemple dans GMP : bon, je ne trouve pas un exemple immédiatement mais je finis par en trouver, par exemple time.c :
-----------------------------------8<-------------------------------- /* Time routines for speed measurments.
Sachant que tu es dans du code qui sert juste a faire de l'optimisation, pas du vrai code de production...
Confere le README qui va avec:
The programs in this directory are for knowledgeable users who want to measure GMP routines on their machine, and perhaps tweak some settings or identify things that can be improved.
The programs here are tools, not ready to run solutions. Nothing is built in a normal "make all", but various Makefile targets described below exist.
Relatively few systems and CPUs have been tested, so be sure to verify that results are sensible before relying on them.
----------------------------------->8-------------------------------- et encore je n'ai mis que le début d'une longue liste.
Et je pourrais multiplier les exemples.
Pas la peine, tu as tres bien choisi. Ces deux-la montrent pleinement mon propos ;-)
In article <47d6fe14$0$16528$426a74cc@news.free.fr>,
candide <c-candide@wanadoo.fr> wrote:
De mon point de vue une variable globale doit etre pesee, et justifiee.
Il faut qu'il y ait de tres tres bonnes raisons (de lisibilite et de
performances, le plus souvent) pour avoir des variables globales.
J'aurais plutôt confiance en ce que tu dis. Néanmoins, moi je me
contente d'observer, par exemple du code pro ou supposé tel, je viens de
prendre un fichier absolument au hasard dans le répertoire où je
recueille du code source, je tombe là-dessus :
Ah oui, cairo, le truc sympa ou ils ont juste arrete completement le support
pour les cartes graphiques en 8 bits... un peu genants pour les vieilles
machines.
-----------------------------------8<--------------------------------
/* cairo - a vector graphics library with display and print output
etc.
*/
/* #include omis */
static const cairo_t cairo_nil = {
(unsigned int)-1, /* ref_count */
CAIRO_STATUS_NO_MEMORY, /* status */
{ /* path */
NULL, NULL, /* op_buf_head, op_buf_tail */
NULL, NULL, /* arg_buf_head, arg_buf_tail */
{ 0, 0 }, /* last_move_point */
{ 0, 0 }, /* current point */
FALSE, /* has_current_point */
},
NULL /* gstate */
};
----------------------------------->8--------------------------------
C'est bien une variable globale ça, même si déclarée static.
C'est l'exemple-meme d'une variable globale non justifiee ;-)
J'ai le code de cairo sous les yeux, version 1.4.14 (plus recente que la
tienne je soupconne, puisque cairo_nil y est devenue _cairo_nil et que
(unsigned int)-1 est devenu CAIRO_REF_COUNT_INVALID), et cette variable
statique est utilisee dans *exactement* une question. Elle n'a aucune
raison de vivre ailleurs...
Apres, le coup de renvoyer une pseudo-structure plutot qu'un pointeur
nul, je ne suis pas vraiment sur que l'optimisation en vaille le coup.
Je cherche maintenant un exemple dans GMP : bon, je ne trouve pas un
exemple immédiatement mais je finis par en trouver, par exemple time.c :
-----------------------------------8<--------------------------------
/* Time routines for speed measurments.
Sachant que tu es dans du code qui sert juste a faire de l'optimisation,
pas du vrai code de production...
Confere le README qui va avec:
The programs in this directory are for knowledgeable users who want to
measure GMP routines on their machine, and perhaps tweak some settings or
identify things that can be improved.
The programs here are tools, not ready to run solutions. Nothing is built
in a normal "make all", but various Makefile targets described below exist.
Relatively few systems and CPUs have been tested, so be sure to verify that
results are sensible before relying on them.
----------------------------------->8--------------------------------
et encore je n'ai mis que le début d'une longue liste.
Et je pourrais multiplier les exemples.
Pas la peine, tu as tres bien choisi. Ces deux-la montrent pleinement
mon propos ;-)
De mon point de vue une variable globale doit etre pesee, et justifiee. Il faut qu'il y ait de tres tres bonnes raisons (de lisibilite et de performances, le plus souvent) pour avoir des variables globales.
J'aurais plutôt confiance en ce que tu dis. Néanmoins, moi je me contente d'observer, par exemple du code pro ou supposé tel, je viens de prendre un fichier absolument au hasard dans le répertoire où je recueille du code source, je tombe là-dessus :
Ah oui, cairo, le truc sympa ou ils ont juste arrete completement le support pour les cartes graphiques en 8 bits... un peu genants pour les vieilles machines.
-----------------------------------8<-------------------------------- /* cairo - a vector graphics library with display and print output etc. */ /* #include omis */
static const cairo_t cairo_nil = { (unsigned int)-1, /* ref_count */ CAIRO_STATUS_NO_MEMORY, /* status */ { /* path */ NULL, NULL, /* op_buf_head, op_buf_tail */ NULL, NULL, /* arg_buf_head, arg_buf_tail */ { 0, 0 }, /* last_move_point */ { 0, 0 }, /* current point */ FALSE, /* has_current_point */ }, NULL /* gstate */ }; ----------------------------------->8-------------------------------- C'est bien une variable globale ça, même si déclarée static.
C'est l'exemple-meme d'une variable globale non justifiee ;-) J'ai le code de cairo sous les yeux, version 1.4.14 (plus recente que la tienne je soupconne, puisque cairo_nil y est devenue _cairo_nil et que (unsigned int)-1 est devenu CAIRO_REF_COUNT_INVALID), et cette variable statique est utilisee dans *exactement* une question. Elle n'a aucune raison de vivre ailleurs...
Apres, le coup de renvoyer une pseudo-structure plutot qu'un pointeur nul, je ne suis pas vraiment sur que l'optimisation en vaille le coup.
Je cherche maintenant un exemple dans GMP : bon, je ne trouve pas un exemple immédiatement mais je finis par en trouver, par exemple time.c :
-----------------------------------8<-------------------------------- /* Time routines for speed measurments.
Sachant que tu es dans du code qui sert juste a faire de l'optimisation, pas du vrai code de production...
Confere le README qui va avec:
The programs in this directory are for knowledgeable users who want to measure GMP routines on their machine, and perhaps tweak some settings or identify things that can be improved.
The programs here are tools, not ready to run solutions. Nothing is built in a normal "make all", but various Makefile targets described below exist.
Relatively few systems and CPUs have been tested, so be sure to verify that results are sensible before relying on them.
----------------------------------->8-------------------------------- et encore je n'ai mis que le début d'une longue liste.
Et je pourrais multiplier les exemples.
Pas la peine, tu as tres bien choisi. Ces deux-la montrent pleinement mon propos ;-)
candide
On 11 mar, 09:46, Marc Boyer wrote:
Le chapitre 6 du Harbison&Steele est aussi une bonne chose.
Rappelons à toutes fin utiles ce qui est dit en début de ce chapitre :
------------------------------------- Most programming languages try to hide the details of the language's implementation on a particular computer. For the most part, the C programmer need not to be aware of these details, (....). -------------------------------------
Au passage, je note qu'une telle présentation n'engage pas le programmeur lambda (à la différence de l'implémenteur) à lire le chapitre alors que ce chapitre traite des conversions, question difficilement évitable par le programmeur C.
On 11 mar, 09:46, Marc Boyer <Marc.Bo...@enseeiht.yahoo.fr.invalid>
wrote:
Le chapitre 6 du Harbison&Steele est aussi une bonne chose.
Rappelons à toutes fin utiles ce qui est dit en début de ce chapitre :
-------------------------------------
Most programming languages try to hide the details of the language's
implementation on a particular computer. For the most part, the C
programmer need not to be aware of these details, (....).
-------------------------------------
Au passage, je note qu'une telle présentation n'engage pas le
programmeur lambda (à la différence de l'implémenteur) à lire le
chapitre alors que ce chapitre traite des conversions, question
difficilement évitable par le programmeur C.
Le chapitre 6 du Harbison&Steele est aussi une bonne chose.
Rappelons à toutes fin utiles ce qui est dit en début de ce chapitre :
------------------------------------- Most programming languages try to hide the details of the language's implementation on a particular computer. For the most part, the C programmer need not to be aware of these details, (....). -------------------------------------
Au passage, je note qu'une telle présentation n'engage pas le programmeur lambda (à la différence de l'implémenteur) à lire le chapitre alors que ce chapitre traite des conversions, question difficilement évitable par le programmeur C.
Francois
Au fait, comme le sujet du fil concerne les livres sur le C, je voulais savoir si vous connaissiez ce livre et si votre pouviez me donner un avis dessus :
Beginning C: From Novice to Professional, Fourth Edition Ivor Horton
En fait, je l'ai feuilleté dans une librairie très rapidement (faute de temps) et il m'avait plu. Sur un coup de tête un peu, je l'ai acheté. A dire vrai, je l'ai à peine regardé pour l'instant.
Il ne parle pas trop de d'architecture (même pas du tout), mais au delà de ça, pouvez vous me donner un avis sur ce livre ? Par curiosité.
Merci
François
Au fait, comme le sujet du fil concerne les livres sur le C, je voulais
savoir si vous connaissiez ce livre et si votre pouviez me donner un
avis dessus :
Beginning C: From Novice to Professional, Fourth Edition
Ivor Horton
En fait, je l'ai feuilleté dans une librairie très rapidement (faute de
temps) et il m'avait plu. Sur un coup de tête un peu, je l'ai acheté. A
dire vrai, je l'ai à peine regardé pour l'instant.
Il ne parle pas trop de d'architecture (même pas du tout), mais au delà
de ça, pouvez vous me donner un avis sur ce livre ? Par curiosité.
Au fait, comme le sujet du fil concerne les livres sur le C, je voulais savoir si vous connaissiez ce livre et si votre pouviez me donner un avis dessus :
Beginning C: From Novice to Professional, Fourth Edition Ivor Horton
En fait, je l'ai feuilleté dans une librairie très rapidement (faute de temps) et il m'avait plu. Sur un coup de tête un peu, je l'ai acheté. A dire vrai, je l'ai à peine regardé pour l'instant.
Il ne parle pas trop de d'architecture (même pas du tout), mais au delà de ça, pouvez vous me donner un avis sur ce livre ? Par curiosité.
Merci
François
candide
Au fait, comme le sujet du fil concerne les livres sur le C, je voulais savoir si vous connaissiez ce livre et si votre pouviez me donner un avis dessus :
Beginning C: From Novice to Professional, Fourth Edition Ivor Horton
Oui, je le connais assez bien mais on est très loin du livre objet de ton message initial. On se sent vraiment _en confiance_ avec un livre comme ça. Je le trouve très clair sur certains point techniques ( les tableaux, les pointeurs qui m'ont tant pris la tête) et bien détaillé.
Bon quelques reproches tout de même :
*) la progression est trop lente, les commentaires sont parfois un peu niais et répétitifs, le livre est plutôt verbeux, les exemples sont un peu surchargés ; *) c'est assez incomplet et pas assez approfondi sur certaines questions.
J'avais lu je ne sais plus où des commentaires fort peu aimables sur cet auteur qui doit déplaire aux puristes. Pourtant sur l'ACCU, il y a une critique correcte :
(les critiques d'ouvrages de l'ACCU sont souvent le résultat d'analyses superficielles).
Je persiste à te recommander chaudement la lecture du tutorial du site du zéro (mais avec un certain esprit critique disons). Et d'aller jusqu'à la programmation graphique avec la SDL histoire d'avoir un panorama un peu large et de faires des choses un peu ludiques ce qui est quand même le but quand des gens comme nous apprennent le C. Avec le cours de mateo21, tu iras beaucoup plus loin et beaucoup plus vite qu'avec le bouquin de Horton (qui fait dans 624 pages dans mon édition !). Ensuite, tu peux attaquer beaucoup plus facilement K&R2 (crayon et loupe à la main) dont la lecture reste indispensable de toute façon si tu veux prétendre connaître un peu le C ou même seulement programmer proprement.
A différents endroits du forum du site du zéro, j'avais donné quelques critiques/analyses sommaires d'ouvrages, voici un lien parmi d'autres :
Tu y trouveras une référence meilleure que le Horton voire la meilleure référence que je connaisse pour s'initier.
Au fait, comme le sujet du fil concerne les livres sur le C, je voulais
savoir si vous connaissiez ce livre et si votre pouviez me donner un
avis dessus :
Beginning C: From Novice to Professional, Fourth Edition
Ivor Horton
Oui, je le connais assez bien mais on est très loin du livre objet de
ton message initial. On se sent vraiment _en confiance_ avec un livre
comme ça. Je le trouve très clair sur certains point techniques ( les
tableaux, les pointeurs qui m'ont tant pris la tête) et bien détaillé.
Bon quelques reproches tout de même :
*) la progression est trop lente, les commentaires sont parfois un peu
niais et répétitifs, le livre est plutôt verbeux, les exemples sont un
peu surchargés ;
*) c'est assez incomplet et pas assez approfondi sur certaines questions.
J'avais lu je ne sais plus où des commentaires fort peu aimables sur cet
auteur qui doit déplaire aux puristes. Pourtant sur l'ACCU, il y a une
critique correcte :
(les critiques d'ouvrages de l'ACCU sont souvent le résultat d'analyses
superficielles).
Je persiste à te recommander chaudement la lecture du tutorial du site
du zéro (mais avec un certain esprit critique disons). Et d'aller
jusqu'à la programmation graphique avec la SDL histoire d'avoir un
panorama un peu large et de faires des choses un peu ludiques ce qui est
quand même le but quand des gens comme nous apprennent le C. Avec le
cours de mateo21, tu iras beaucoup plus loin et beaucoup plus vite
qu'avec le bouquin de Horton (qui fait dans 624 pages dans mon édition
!). Ensuite, tu peux attaquer beaucoup plus facilement K&R2 (crayon et
loupe à la main) dont la lecture reste indispensable de toute façon si
tu veux prétendre connaître un peu le C ou même seulement programmer
proprement.
A différents endroits du forum du site du zéro, j'avais donné quelques
critiques/analyses sommaires d'ouvrages, voici un lien parmi d'autres :
Au fait, comme le sujet du fil concerne les livres sur le C, je voulais savoir si vous connaissiez ce livre et si votre pouviez me donner un avis dessus :
Beginning C: From Novice to Professional, Fourth Edition Ivor Horton
Oui, je le connais assez bien mais on est très loin du livre objet de ton message initial. On se sent vraiment _en confiance_ avec un livre comme ça. Je le trouve très clair sur certains point techniques ( les tableaux, les pointeurs qui m'ont tant pris la tête) et bien détaillé.
Bon quelques reproches tout de même :
*) la progression est trop lente, les commentaires sont parfois un peu niais et répétitifs, le livre est plutôt verbeux, les exemples sont un peu surchargés ; *) c'est assez incomplet et pas assez approfondi sur certaines questions.
J'avais lu je ne sais plus où des commentaires fort peu aimables sur cet auteur qui doit déplaire aux puristes. Pourtant sur l'ACCU, il y a une critique correcte :
(les critiques d'ouvrages de l'ACCU sont souvent le résultat d'analyses superficielles).
Je persiste à te recommander chaudement la lecture du tutorial du site du zéro (mais avec un certain esprit critique disons). Et d'aller jusqu'à la programmation graphique avec la SDL histoire d'avoir un panorama un peu large et de faires des choses un peu ludiques ce qui est quand même le but quand des gens comme nous apprennent le C. Avec le cours de mateo21, tu iras beaucoup plus loin et beaucoup plus vite qu'avec le bouquin de Horton (qui fait dans 624 pages dans mon édition !). Ensuite, tu peux attaquer beaucoup plus facilement K&R2 (crayon et loupe à la main) dont la lecture reste indispensable de toute façon si tu veux prétendre connaître un peu le C ou même seulement programmer proprement.
A différents endroits du forum du site du zéro, j'avais donné quelques critiques/analyses sommaires d'ouvrages, voici un lien parmi d'autres :
Tu y trouveras une référence meilleure que le Horton voire la meilleure référence que je connaisse pour s'initier.
Jean-Marc Bourguet
candide writes:
Tient, on commence l'année en disant qu'il ne faut pas de variable globale, et à la fin de l'année, quand on faut un mini purify, qui surcharge malloc/calloc/free, ben, on en utilise...
En effet le discours académique selon lequel il ne faut pas utiliser de variables globales (quand ce discours n'est pas accompagné d'une aversion violente contre elles, ahem, visez mon regard) à de quoi surprendre quand on voit la masse de code professionnel rempli de variables globales.
Ne te contente pas de voir, regarde un peu plus en detail et tu as l'explication que tu cherches...
A+
-- Jean-Marc FAQ de fclc: http://www.isty-info.uvsq.fr/~rumeau/fclc Site de usenet-fr: http://www.usenet-fr.news.eu.org
candide <c-candide@wanadoo.fr> writes:
Tient, on commence l'année en disant qu'il ne faut pas de variable
globale, et à la fin de l'année, quand on faut un mini purify,
qui surcharge malloc/calloc/free, ben, on en utilise...
En effet le discours académique selon lequel il ne faut pas utiliser de
variables globales (quand ce discours n'est pas accompagné d'une aversion
violente contre elles, ahem, visez mon regard) à de quoi surprendre quand
on voit la masse de code professionnel rempli de variables globales.
Ne te contente pas de voir, regarde un peu plus en detail et tu as
l'explication que tu cherches...
A+
--
Jean-Marc
FAQ de fclc: http://www.isty-info.uvsq.fr/~rumeau/fclc
Site de usenet-fr: http://www.usenet-fr.news.eu.org
Tient, on commence l'année en disant qu'il ne faut pas de variable globale, et à la fin de l'année, quand on faut un mini purify, qui surcharge malloc/calloc/free, ben, on en utilise...
En effet le discours académique selon lequel il ne faut pas utiliser de variables globales (quand ce discours n'est pas accompagné d'une aversion violente contre elles, ahem, visez mon regard) à de quoi surprendre quand on voit la masse de code professionnel rempli de variables globales.
Ne te contente pas de voir, regarde un peu plus en detail et tu as l'explication que tu cherches...
A+
-- Jean-Marc FAQ de fclc: http://www.isty-info.uvsq.fr/~rumeau/fclc Site de usenet-fr: http://www.usenet-fr.news.eu.org
Marc Boyer
On 2008-03-11, Marc Espie wrote:
In article <47d6ee00$0$10344$, candide wrote:
En effet le discours académique selon lequel il ne faut pas utiliser de variables globales (quand ce discours n'est pas accompagné d'une aversion violente contre elles, ahem, visez mon regard) à de quoi surprendre quand on voit la masse de code professionnel rempli de variables globales.
Il faut faire de la resistance active contre les variables globales.
Elles foutent tres souvent le bordel, et rendent tres souvent le code illisible.
De mon point de vue une variable globale doit etre pesee, et justifiee. Il faut qu'il y ait de tres tres bonnes raisons (de lisibilite et de performances, le plus souvent) pour avoir des variables globales.
C'était le sens de mon propos: les variables globales ont de nombreux inconvénients, et de rares avantages. Dans certains cas précus, les rares avantages l'emporte.
Ce que je dis parfois, c'est que l'usage d'une variable globale devrait s'accompagner d'une page de justification. Si écrire la page de justification semble trop pénible au programmeur, c'est que l'intéret de la variable globale était trop faible.
Si on remonte un peu, conceptuellement, une variable globale, c'est une implementation tres naive d'un singleton, et en fait il y a pas mal de cas ou ce qu'on prenait pour une instance unique doit etre dedouble quand on perfectionne le code. Et la, plus on attend, plus ca fait mal.
Oui. Mais bon, je préfère expliquer aux étudiants "qu'on ne fait pas de variable globale quand on est débutant" que de devoir expliquer ce qu'est un singleton.
Marc Boyer -- Si tu peux supporter d'entendre tes paroles Travesties par des gueux pour exciter des sots IF -- Rudyard Kipling (Trad. André Maurois)
On 2008-03-11, Marc Espie <espie@lain.home> wrote:
In article <47d6ee00$0$10344$426a34cc@news.free.fr>,
candide <c-candide@wanadoo.fr> wrote:
En effet le discours académique selon lequel il ne faut pas utiliser de
variables globales (quand ce discours n'est pas accompagné d'une
aversion violente contre elles, ahem, visez mon regard) à de quoi
surprendre quand on voit la masse de code professionnel rempli de
variables globales.
Il faut faire de la resistance active contre les variables globales.
Elles foutent tres souvent le bordel, et rendent tres souvent le code
illisible.
De mon point de vue une variable globale doit etre pesee, et justifiee.
Il faut qu'il y ait de tres tres bonnes raisons (de lisibilite et de
performances, le plus souvent) pour avoir des variables globales.
C'était le sens de mon propos: les variables globales ont de
nombreux inconvénients, et de rares avantages. Dans certains
cas précus, les rares avantages l'emporte.
Ce que je dis parfois, c'est que l'usage d'une variable globale
devrait s'accompagner d'une page de justification. Si écrire la
page de justification semble trop pénible au programmeur, c'est
que l'intéret de la variable globale était trop faible.
Si on remonte un peu, conceptuellement, une variable globale, c'est
une implementation tres naive d'un singleton, et en fait il y a pas mal
de cas ou ce qu'on prenait pour une instance unique doit etre dedouble
quand on perfectionne le code. Et la, plus on attend, plus ca fait mal.
Oui.
Mais bon, je préfère expliquer aux étudiants "qu'on ne fait pas de
variable globale quand on est débutant" que de devoir expliquer ce
qu'est un singleton.
Marc Boyer
--
Si tu peux supporter d'entendre tes paroles
Travesties par des gueux pour exciter des sots
IF -- Rudyard Kipling (Trad. André Maurois)
En effet le discours académique selon lequel il ne faut pas utiliser de variables globales (quand ce discours n'est pas accompagné d'une aversion violente contre elles, ahem, visez mon regard) à de quoi surprendre quand on voit la masse de code professionnel rempli de variables globales.
Il faut faire de la resistance active contre les variables globales.
Elles foutent tres souvent le bordel, et rendent tres souvent le code illisible.
De mon point de vue une variable globale doit etre pesee, et justifiee. Il faut qu'il y ait de tres tres bonnes raisons (de lisibilite et de performances, le plus souvent) pour avoir des variables globales.
C'était le sens de mon propos: les variables globales ont de nombreux inconvénients, et de rares avantages. Dans certains cas précus, les rares avantages l'emporte.
Ce que je dis parfois, c'est que l'usage d'une variable globale devrait s'accompagner d'une page de justification. Si écrire la page de justification semble trop pénible au programmeur, c'est que l'intéret de la variable globale était trop faible.
Si on remonte un peu, conceptuellement, une variable globale, c'est une implementation tres naive d'un singleton, et en fait il y a pas mal de cas ou ce qu'on prenait pour une instance unique doit etre dedouble quand on perfectionne le code. Et la, plus on attend, plus ca fait mal.
Oui. Mais bon, je préfère expliquer aux étudiants "qu'on ne fait pas de variable globale quand on est débutant" que de devoir expliquer ce qu'est un singleton.
Marc Boyer -- Si tu peux supporter d'entendre tes paroles Travesties par des gueux pour exciter des sots IF -- Rudyard Kipling (Trad. André Maurois)
Marc Boyer
On 2008-03-11, Marc Espie wrote:
In article , Marc Boyer wrote:
Ou alors, ca me parait plus important d'evoquer les regles d'aliasing de type, qui sont elles *vraiment* tordues.
Peux-tu me rappeller ce que tu appelles "aliasing" ?
En Fortran, il y a un vrai type tableau. Ca permet aux physicien de faire la nique au gens du C avec des optimisations `impossibles' en C, parce qu'on ne sait pas trop si deux pointeurs correspondent a la meme zone memoire ou pas (aliasing).
OK, les problèmes d'aliasing, c'est quand le programmeur et le compilo ne sont pas d'accord sur le "partage" de zone mémoire entre deux pointeurs, c'est ça ?
Typiquement, ca pose des problemes au code qui suppose trop de chose sur la representation memoire des objets, donc a pas mal de mauvais code... et a un peu de code tres bas niveau, de style compilateur lisp ou assimile, qui fait souvent des choses bizarres avec ces donnees.
Oui, et donc du code qui tourne en mode debug (-g) et qui plante dans sa version optimisée.
Si tu veux du mal a quelqu'un, maudis-le a corriger des bugs d'aliasing... c'est un peu comme les volatile manquants, mais en pire. ;-)
J'imagine...
Il y a egalement un 2e mecanisme, __restrict, mais celui-ci est encore plus foireux pour le compilateur (confere de looongues discussions sur la ml gcc sur ce que __restrict signifie), et ne se rencontre guere que dans les protos de fonctions standards, la ou la norme le reclame (et permet, avec son ami const, de finir de casser du code foireux qui redeclare tout seul comme un grand des fonctions de la bibliotheque standard).
Oui, restrict, encore une vraie fausse bonne idée.
Marc Boyer -- Si tu peux supporter d'entendre tes paroles Travesties par des gueux pour exciter des sots IF -- Rudyard Kipling (Trad. André Maurois)
On 2008-03-11, Marc Espie <espie@lain.home> wrote:
In article <slrnftch7o.610.Marc.Boyer@ubu.enseeiht.fr>,
Marc Boyer <Marc.Boyer@enseeiht.yahoo.fr> wrote:
Ou alors, ca me parait plus important d'evoquer les regles d'aliasing
de type, qui sont elles *vraiment* tordues.
Peux-tu me rappeller ce que tu appelles "aliasing" ?
En Fortran, il y a un vrai type tableau. Ca permet aux physicien de faire
la nique au gens du C avec des optimisations `impossibles' en C, parce
qu'on ne sait pas trop si deux pointeurs correspondent a la meme zone
memoire ou pas (aliasing).
OK, les problèmes d'aliasing, c'est quand le programmeur et le compilo
ne sont pas d'accord sur le "partage" de zone mémoire entre deux
pointeurs, c'est ça ?
Typiquement, ca pose des problemes au code qui suppose trop de chose sur
la representation memoire des objets, donc a pas mal de mauvais code...
et a un peu de code tres bas niveau, de style compilateur lisp ou assimile,
qui fait souvent des choses bizarres avec ces donnees.
Oui, et donc du code qui tourne en mode debug (-g) et qui plante dans
sa version optimisée.
Si tu veux du mal a quelqu'un, maudis-le a corriger des bugs d'aliasing...
c'est un peu comme les volatile manquants, mais en pire.
;-)
J'imagine...
Il y a egalement un 2e mecanisme, __restrict, mais celui-ci est encore plus
foireux pour le compilateur (confere de looongues discussions sur la ml
gcc sur ce que __restrict signifie), et ne se rencontre guere que dans
les protos de fonctions standards, la ou la norme le reclame (et permet,
avec son ami const, de finir de casser du code foireux qui redeclare tout
seul comme un grand des fonctions de la bibliotheque standard).
Oui, restrict, encore une vraie fausse bonne idée.
Marc Boyer
--
Si tu peux supporter d'entendre tes paroles
Travesties par des gueux pour exciter des sots
IF -- Rudyard Kipling (Trad. André Maurois)
Ou alors, ca me parait plus important d'evoquer les regles d'aliasing de type, qui sont elles *vraiment* tordues.
Peux-tu me rappeller ce que tu appelles "aliasing" ?
En Fortran, il y a un vrai type tableau. Ca permet aux physicien de faire la nique au gens du C avec des optimisations `impossibles' en C, parce qu'on ne sait pas trop si deux pointeurs correspondent a la meme zone memoire ou pas (aliasing).
OK, les problèmes d'aliasing, c'est quand le programmeur et le compilo ne sont pas d'accord sur le "partage" de zone mémoire entre deux pointeurs, c'est ça ?
Typiquement, ca pose des problemes au code qui suppose trop de chose sur la representation memoire des objets, donc a pas mal de mauvais code... et a un peu de code tres bas niveau, de style compilateur lisp ou assimile, qui fait souvent des choses bizarres avec ces donnees.
Oui, et donc du code qui tourne en mode debug (-g) et qui plante dans sa version optimisée.
Si tu veux du mal a quelqu'un, maudis-le a corriger des bugs d'aliasing... c'est un peu comme les volatile manquants, mais en pire. ;-)
J'imagine...
Il y a egalement un 2e mecanisme, __restrict, mais celui-ci est encore plus foireux pour le compilateur (confere de looongues discussions sur la ml gcc sur ce que __restrict signifie), et ne se rencontre guere que dans les protos de fonctions standards, la ou la norme le reclame (et permet, avec son ami const, de finir de casser du code foireux qui redeclare tout seul comme un grand des fonctions de la bibliotheque standard).
Oui, restrict, encore une vraie fausse bonne idée.
Marc Boyer -- Si tu peux supporter d'entendre tes paroles Travesties par des gueux pour exciter des sots IF -- Rudyard Kipling (Trad. André Maurois)
candide
devoir expliquer ce qu'est un singleton.
Et c'est quoi (j'en suis resté à l'ensemble de cardinal un) en d'autres termes que "instance unique qui ne doit etre dedoublé" (un court exemple sera aussi parlant que 10 lignes d'explication) ?
devoir expliquer ce
qu'est un singleton.
Et c'est quoi (j'en suis resté à l'ensemble de cardinal un) en d'autres
termes que "instance unique qui ne doit etre dedoublé" (un court exemple
sera aussi parlant que 10 lignes d'explication) ?
Et c'est quoi (j'en suis resté à l'ensemble de cardinal un) en d'autres termes que "instance unique qui ne doit etre dedoublé" (un court exemple sera aussi parlant que 10 lignes d'explication) ?
