Votre IDE préféré ?

Patrice Karatchentzeff

02/09/2004 à 23:23

Emmanuel Florac writes:

Le Thu, 02 Sep 2004 00:17:30 +0200, Patrice Karatchentzeff a écrit :

Le machin directement inspiré de chez tupperware ?

Pas compris...

Tu n'as jamais vu la photo d'un Mac et d'un fer à repasser
côte-à-côte ? Elle a trainé partout au moment où ils ont sorti le
modèle plastic transparent...

PK

--
      |      _,,,---,,_       Patrice KARATCHENTZEFF
ZZZzz /,`.-'`'    -.  ;-;;,_   mailto:
     |,4-  ) )-,_. , (  `'-'  http://p.karatchentzeff.free.fr
    '---''(_/--'  `-'_)

Miod Vallat

02/09/2004 à 23:34

Le machin directement inspiré de chez tupperware ?

Pas compris...

Tu n'as jamais vu la photo d'un Mac et d'un fer à repasser
côte-à-côte ? Elle a trainé partout au moment où ils ont sorti le
modèle plastic transparent...

Oui, mais il s'agissait d'un fer Rowenta. Tolowerware ne fait pas de
fers à repasser, pour autant que je sache...

Emmanuel Florac

03/09/2004 à 10:40

Le Thu, 02 Sep 2004 23:23:02 +0200, Patrice Karatchentzeff a écrit :

Tu n'as jamais vu la photo d'un Mac et d'un fer à repasser
côte-à-côte ? Elle a trainé partout au moment où ils ont sorti le
modèle plastic transparent...

Tu n'as pas vu le dernier iMac.

--
entia non sont multiplicanda praeter necessitatem.
Guillaume d'Ockham.

Patrice Karatchentzeff

04/09/2004 à 19:38

Miod Vallat writes:

Le machin directement inspiré de chez tupperware ?

Pas compris...

Tu n'as jamais vu la photo d'un Mac et d'un fer à repasser
côte-à-côte ? Elle a trainé partout au moment où ils ont sorti le
modèle plastic transparent...

Oui, mais il s'agissait d'un fer Rowenta. Tolowerware ne fait pas de
fers à repasser, pour autant que je sache...

OK... cela ne change pas le fond...

PK

--
      |      _,,,---,,_       Patrice KARATCHENTZEFF
ZZZzz /,`.-'`'    -.  ;-;;,_   mailto:
     |,4-  ) )-,_. , (  `'-'  http://p.karatchentzeff.free.fr
    '---''(_/--'  `-'_)

Luc Hermitte

25/10/2004 à 18:06

Salut,

Je déterre un fil pour y apporter quelques petites précisions, sur une
question qui m'a semblée en suspent.

"Manuel Leclerc" wrote in news:41370b36
@neottia.net:

[...]
Question de pratique je pense. J'ai eu des profs qui faisaient la
confusion C/C++ et j'utilisais systématiquement new et delete. Et
puis le jour où j'ai eu une connexion internet, je me suis fait
corrigé sur les forums (parfois assez vertement d'ailleurs.) La
période de transition a été douloureuse.
Maintenant ça vient tout seul.

Maintenant, au lieu de faire systématiquement new/delete, tu fais
systématiquement autre chose. Je te rappelle quand même que ce
sont des mots clés C++, pas C. Je serais curieux de lire une
référence expliquant pourquoi le C++ "bien compris" devrait
éviter l'utilisation des pointeurs.

En fait, c'est la manipulation de toute ressource brute (=> non
enveloppée) qui est déconseillée. Pas seulement les pointeurs.

new est bien évidemment toujours utilisé, ne serait-ce que pour les
données qui ont une sémantique de référence (par opposition à la
sémantique de valeur).

delete en revanche ... Il est plus rare (dans un code "conseillé") que
l'on en fasse des appels explicites. Pourquoi parce lorsque l'on le
manipule directement, avoir un code correct nous oblige à faire des
accrobaties à coups de try-catch (ce qui semble être connu dans les
autres langages sous l'appelation /dispose-pattern/). Il est bien plus
simple en C++ d'obtenir un code clair et simple à maintenir en profitant
de l'idiome RAII.

Ainsi les pointeurs seront enveloppés dans des smart-pointeurs (à
comptage de référence, ou ayant une sémantique de déplacement, ou limités
à la portée), ...
Les autres ressources (fichiers, sockets, pots de peintures, ...) étant
enveloppés dans des scope-guards, ou des trucs qui s'apparentent à des
smart-pointers si ils doivent voyager.

Des références ?
En vrac :
- Le 4e chapitre de C++ in Action (écrit par un qualiticien)
http://www.relisoft.com/book/tech/index.htm
- Un article d'Andrei Alexandrescu, disponible dans le forum experts du
C/C++ Users Journal (CUJ), sur l'écriture de code exception-safe
http://www.cuj.com/documents/s00/cujcexp1812alexandr/alexandr.htm
- Peut-être avant, les items sur l'exception-safety qui sont traités dans
sur GOTW (puis publiés dans /Exceptional C++/, chez Addisson Wesley)
http://www.gotw.ca/gotw/
- Sur ACCU, il y a les transparents d'un exposé d'Herb Sutter, qui bosse
depuis quelques années chez Microsoft, au sujet du C++/CLI.
La seconde partie qui compare l'idiome RAII au dispose-pattern est
toujours dans cette continuité de "comment il est bon de faire en
C++" ;
soit -> profiter du RAII pour ceux qui ont suivit.
<http://www.accu.org/conference/presentations/Sutter_-
_Is_C++_Relevant_on_Modern_Environments_(keynote).pdf>
(je crains que l'URL soit coupée en deux)
- usenet ... -> clc++m, fclc++

[...]

Certes, mais si on combine les deux, on obtient :

list <Maclasse> MaListe;
MaClasse MonObjet= MaClasse();

MaClasse MonObjet; // suffit

MonObjet.foo( bar );
MaListe.push_back(MonObjet);

Autrement dit, construction dans la pile, ajout par copie
puis destruction de l'original. Il y a quelque chose qui
me choque :-)

C'est vrai. On n'a pas encore de move-semantics :(
Il me semble que des propositions en ce sens ont été faites au commité de
normalisation pour les prochaines moutures du C++.

En attendant, concernant les objets qui ont une sémantique de valeur, si
ils ne sont pas trop gros ou si ils supportent le Copy-On-Write, on fait
avec eux. Sinon, il peut être intéressant de les envelopper dans des
pointeurs intelligents.

--
Luc Hermitte

Salut,

Je déterre un fil pour y apporter quelques petites précisions, sur une
question qui m'a semblée en suspent.

"Manuel Leclerc" <manuel.leclerc@alussinan.org> wrote in news:41370b36
@neottia.net:

[...]
Question de pratique je pense. J'ai eu des profs qui faisaient la
confusion C/C++ et j'utilisais systématiquement new et delete. Et
puis le jour où j'ai eu une connexion internet, je me suis fait
corrigé sur les forums (parfois assez vertement d'ailleurs.) La
période de transition a été douloureuse.
Maintenant ça vient tout seul.

Maintenant, au lieu de faire systématiquement new/delete, tu fais
systématiquement autre chose. Je te rappelle quand même que ce
sont des mots clés C++, pas C. Je serais curieux de lire une
référence expliquant pourquoi le C++ "bien compris" devrait
éviter l'utilisation des pointeurs.

En fait, c'est la manipulation de toute ressource brute (=> non
enveloppée) qui est déconseillée. Pas seulement les pointeurs.

new est bien évidemment toujours utilisé, ne serait-ce que pour les
données qui ont une sémantique de référence (par opposition à la
sémantique de valeur).

delete en revanche ... Il est plus rare (dans un code "conseillé") que
l'on en fasse des appels explicites. Pourquoi parce lorsque l'on le
manipule directement, avoir un code correct nous oblige à faire des
accrobaties à coups de try-catch (ce qui semble être connu dans les
autres langages sous l'appelation /dispose-pattern/). Il est bien plus
simple en C++ d'obtenir un code clair et simple à maintenir en profitant
de l'idiome RAII.

Ainsi les pointeurs seront enveloppés dans des smart-pointeurs (à
comptage de référence, ou ayant une sémantique de déplacement, ou limités
à la portée), ...
Les autres ressources (fichiers, sockets, pots de peintures, ...) étant
enveloppés dans des scope-guards, ou des trucs qui s'apparentent à des
smart-pointers si ils doivent voyager.

Des références ?
En vrac :
- Le 4e chapitre de C++ in Action (écrit par un qualiticien)
http://www.relisoft.com/book/tech/index.htm
- Un article d'Andrei Alexandrescu, disponible dans le forum experts du
C/C++ Users Journal (CUJ), sur l'écriture de code exception-safe
http://www.cuj.com/documents/s00/cujcexp1812alexandr/alexandr.htm
- Peut-être avant, les items sur l'exception-safety qui sont traités dans
sur GOTW (puis publiés dans /Exceptional C++/, chez Addisson Wesley)
http://www.gotw.ca/gotw/
- Sur ACCU, il y a les transparents d'un exposé d'Herb Sutter, qui bosse
depuis quelques années chez Microsoft, au sujet du C++/CLI.
La seconde partie qui compare l'idiome RAII au dispose-pattern est
toujours dans cette continuité de "comment il est bon de faire en
C++" ;
soit -> profiter du RAII pour ceux qui ont suivit.
<http://www.accu.org/conference/presentations/Sutter_-
_Is_C++_Relevant_on_Modern_Environments_(keynote).pdf>
(je crains que l'URL soit coupée en deux)
- usenet ... -> clc++m, fclc++

[...]

Certes, mais si on combine les deux, on obtient :

list <Maclasse> MaListe;
MaClasse MonObjet= MaClasse();

MaClasse MonObjet; // suffit

MonObjet.foo( bar );
MaListe.push_back(MonObjet);

Autrement dit, construction dans la pile, ajout par copie
puis destruction de l'original. Il y a quelque chose qui
me choque :-)

C'est vrai. On n'a pas encore de move-semantics :(
Il me semble que des propositions en ce sens ont été faites au commité de
normalisation pour les prochaines moutures du C++.

En attendant, concernant les objets qui ont une sémantique de valeur, si
ils ne sont pas trop gros ou si ils supportent le Copy-On-Write, on fait
avec eux. Sinon, il peut être intéressant de les envelopper dans des
pointeurs intelligents.

--
Luc Hermitte

Vous avez filtré cet utilisateur ! Consultez son message

Salut,

Je déterre un fil pour y apporter quelques petites précisions, sur une
question qui m'a semblée en suspent.

"Manuel Leclerc" wrote in news:41370b36
@neottia.net:

[...]
Question de pratique je pense. J'ai eu des profs qui faisaient la
confusion C/C++ et j'utilisais systématiquement new et delete. Et
puis le jour où j'ai eu une connexion internet, je me suis fait
corrigé sur les forums (parfois assez vertement d'ailleurs.) La
période de transition a été douloureuse.
Maintenant ça vient tout seul.

Maintenant, au lieu de faire systématiquement new/delete, tu fais
systématiquement autre chose. Je te rappelle quand même que ce
sont des mots clés C++, pas C. Je serais curieux de lire une
référence expliquant pourquoi le C++ "bien compris" devrait
éviter l'utilisation des pointeurs.

En fait, c'est la manipulation de toute ressource brute (=> non
enveloppée) qui est déconseillée. Pas seulement les pointeurs.

new est bien évidemment toujours utilisé, ne serait-ce que pour les
données qui ont une sémantique de référence (par opposition à la
sémantique de valeur).

delete en revanche ... Il est plus rare (dans un code "conseillé") que
l'on en fasse des appels explicites. Pourquoi parce lorsque l'on le
manipule directement, avoir un code correct nous oblige à faire des
accrobaties à coups de try-catch (ce qui semble être connu dans les
autres langages sous l'appelation /dispose-pattern/). Il est bien plus
simple en C++ d'obtenir un code clair et simple à maintenir en profitant
de l'idiome RAII.

Ainsi les pointeurs seront enveloppés dans des smart-pointeurs (à
comptage de référence, ou ayant une sémantique de déplacement, ou limités
à la portée), ...
Les autres ressources (fichiers, sockets, pots de peintures, ...) étant
enveloppés dans des scope-guards, ou des trucs qui s'apparentent à des
smart-pointers si ils doivent voyager.

Des références ?
En vrac :
- Le 4e chapitre de C++ in Action (écrit par un qualiticien)
http://www.relisoft.com/book/tech/index.htm
- Un article d'Andrei Alexandrescu, disponible dans le forum experts du
C/C++ Users Journal (CUJ), sur l'écriture de code exception-safe
http://www.cuj.com/documents/s00/cujcexp1812alexandr/alexandr.htm
- Peut-être avant, les items sur l'exception-safety qui sont traités dans
sur GOTW (puis publiés dans /Exceptional C++/, chez Addisson Wesley)
http://www.gotw.ca/gotw/
- Sur ACCU, il y a les transparents d'un exposé d'Herb Sutter, qui bosse
depuis quelques années chez Microsoft, au sujet du C++/CLI.
La seconde partie qui compare l'idiome RAII au dispose-pattern est
toujours dans cette continuité de "comment il est bon de faire en
C++" ;
soit -> profiter du RAII pour ceux qui ont suivit.
<http://www.accu.org/conference/presentations/Sutter_-
_Is_C++_Relevant_on_Modern_Environments_(keynote).pdf>
(je crains que l'URL soit coupée en deux)
- usenet ... -> clc++m, fclc++

[...]

Certes, mais si on combine les deux, on obtient :

list <Maclasse> MaListe;
MaClasse MonObjet= MaClasse();

MaClasse MonObjet; // suffit

MonObjet.foo( bar );
MaListe.push_back(MonObjet);

Autrement dit, construction dans la pile, ajout par copie
puis destruction de l'original. Il y a quelque chose qui
me choque :-)

C'est vrai. On n'a pas encore de move-semantics :(
Il me semble que des propositions en ce sens ont été faites au commité de
normalisation pour les prochaines moutures du C++.

En attendant, concernant les objets qui ont une sémantique de valeur, si
ils ne sont pas trop gros ou si ils supportent le Copy-On-Write, on fait
avec eux. Sinon, il peut être intéressant de les envelopper dans des
pointeurs intelligents.

--
Luc Hermitte

Votre IDE préféré ?

5 réponses

Veuillez sélectionner un problème