Newbies en C++ !

Gabriel Dos Reis

13/08/2004 à 17:50

"Alain Naigeon" writes:

| "Jean-Marc Bourguet" a écrit dans le message news:
|
|
| > Si ta seule raison de commencer par les tableaux, c'est que c'est la
| > base de l'implementation, pourquoi ne pas commencer encore plus bas,
| > avec l'assembleur?
|
| "Commencer", pas forcément.

Effectivement, un débutant débute, il ne commence pas.

| C'est clair que le début d'un cours,
| ou la nécessité d'inventer des exercices de départ, justifie parfaitement
| l'usage de tournures non encore expliquées. Ce que je conteste - sans
| être sûr que ce soit *ta* position - c'est le refus d'expliquer, le moment

Peux-tui citer un seul message dans ce thread qui parle de refus
d'expliquer -- excepter les tiens ? Autrement c'est vent.

-- Gaby

Jean-Marc Bourguet

13/08/2004 à 17:54

Gabriel Dos Reis writes:

Jean-Marc Bourguet writes:
[...]

| Si ta seule raison de commencer par les tableaux, c'est que c'est la
| base de l'implementation, pourquoi ne pas commencer encore plus bas,
| avec l'assembleur?

Tu voulais dire le binaire, je suppose :-)

C'est vrai que je n'ai pas donne celui-la, mais la serie d'autres
niveaux d'abstraction que j'ai donnee ne te suffit pas?

A+

--
Jean-Marc
FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ
C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html
Site de usenet-fr: http://www.usenet-fr.news.eu.org

Gabriel Dos Reis

13/08/2004 à 18:02

"Alain Naigeon" writes:

| a écrit dans le message news:
|
|
| > Si tu vas enseigner comment déclarer un tableau en C++,
| > il n'y a qu'une seule solution : std::vector.
|
| Ok. Donc tu vas aussi enseigner la compréhension des fichiers
| de la STL, je suppose.

Quels fichiers ?

-- Gaby

Gabriel Dos Reis

13/08/2004 à 18:03

"Alain Naigeon" writes:

| "drkm" a écrit dans le message news:
|
|
| > Ce n'est pas parcequ'un auteur sort un livre de qualité pour
| > l'apprentissage du C++ que tout ce qu'il a utilisé de ses lectures sur
| > le sujet était également de qualité, sous prétexte que c'est cela qui
| > a mené à l'écriture de son bouquin.
|
| Je soutiens que s'il a utilisé ne serait-ce qu'une chose de mauvaise
| qualité,
| le résultat ne peut être bon. Tu devrais astiquer ta Boole de cristal.

Je maintiens que la tienne est hors usage.

-- Gaby

drkm

13/08/2004 à 18:06

Laurent Deniau writes:

Donc dans ce cas d'accord, ce qui est effectivement evident. Mais
vois-tu d'autres cas?

À vrai dire, je dirais plutôt que je ne vois pas vraiment de cas où
l'on peut utiliser un entier à la place d'une énumération. Il y a
bien des utilisations où ils sont équivalents, comme lorsqu'ils sont
employés en tant que « integral constant-expression ». Mais je ne
dirais pas que passer de :

class C {
enum { size = 10 } ;
int myArray[ size ] ;
} ;

à :

class C {
static int const size = 10 ;
int myArray[ size ] ;
} ;

revient à utiliser un entier à la place d'une énumération. Dans les
deux cas, on utilise une « integral constant-expression ». Non ?

Je serais plutôt d'accord avec le fait de dire que l'on peut
utiliser une énumération à la place d'un entier, s'il est clair que
l'on veut parler de la conversion implicite. Avec comme conséquence
que l'on sait que l'on ne peut alors faire :

enum E { e = 1 } ;
int const a = 1 ;
E const b = e ;

int const * p = & a ;
int const * q = & b ;

car on ne peut convertir « E const * » vers « int const * ». Mais
alors, c'est un problème de compréhension des mécanismes de conversion
implicite.

L'exemple que tu donnais était donc biaisé, puisque ce n'est pas
d'utiliser une énumération à la place d'un entier qui ne vas pas, mais
l'adresse d'une énumération à la place de l'adresse d'un entier.

De plus, dans ton exemple, tu prenais directement l'adresse de la
valeur d'énumération « e », et non d'une variable de type « E ». Et
« e » n'est pas une lvalue, tu ne peux donc pas en prendre l'adresse.

Au fait, quel est le nom exact pour ce que j'ai appelé ici « valeur
d'énumération » ? Ce qui corresponderait dans l'exemple précédent au
« e ».

--drkm, en recherche d'un stage : http://www.fgeorges.org/ipl/stage.html

Gabriel Dos Reis

13/08/2004 à 18:39

Laurent Deniau writes:

[...]

| >> En C on a le cas trivial:
| >
| >>{ // Ok C++ pas C
| >> const int size = 10;
| >> int array[size];
| >
| >> // ...
| >>}
| > Tu veux dire que ceci n'est pas du C ? J'aurais dit qu'à l'inverse
| > du C++, en C, size peut même n'être pas constant. Cfr. les VLAs.
| > Non ?
|
| Arf, en C99 tout a fait d'accord. Je pense encore trop souvent en C89...

Et même en C99, ce n'est pas valable dans la portée globale.

-- Gaby

drkm

13/08/2004 à 18:44

Gabriel Dos Reis writes:

« D&E, §3.8 Constants »

[...]

Intéressant.

Mais je me pose une question. Lorsque tu nous cites de longues
tirades comme celle-ci, souvent du D&E d'ailleurs, tu en possèdes une
version électronique, tu utilises de l'OCR, ou tu t'échines à recopier
tout le passage pour notre seul plaisir ?

--drkm, en recherche d'un stage : http://www.fgeorges.org/ipl/stage.html

Gabriel Dos Reis

13/08/2004 à 19:03

drkm writes:

| Gabriel Dos Reis writes:
|
| > « D&E, §3.8 Constants »
|
| [...]
|
| Intéressant.
|
| Mais je me pose une question. Lorsque tu nous cites de longues
| tirades comme celle-ci, souvent du D&E d'ailleurs, tu en possèdes une
| version électronique, tu utilises de l'OCR, ou tu t'échines à recopier
| tout le passage pour notre seul plaisir ?

Je crois qu'un analyse rapide des fautes de frappe te donnerait la
réponse :-)

-- Gaby

Laurent Deniau

13/08/2004 à 19:10

drkm wrote:

Laurent Deniau writes:

Donc dans ce cas d'accord, ce qui est effectivement evident. Mais
vois-tu d'autres cas?

À vrai dire, je dirais plutôt que je ne vois pas vraiment de cas où
l'on peut utiliser un entier à la place d'une énumération.

Mon exemple ne t'as pas plu?

Il y a
bien des utilisations où ils sont équivalents, comme lorsqu'ils sont
employés en tant que « integral constant-expression ». Mais je ne

Oui, c'est bien de ca que je parle. Un const int peut ou ne pas etre une
integral *constant* expression tandis qu'un enum l'est necessairement
(apres conversion).

dirais pas que passer de :

class C {
enum { size = 10 } ;
int myArray[ size ] ;
} ;

Touche! Relis la premiere phrase citee que j'avais pris soin de garder
dans mon/mes posts precedents.

à :

class C {
static int const size = 10 ;
int myArray[ size ] ;
} ;

revient à utiliser un entier à la place d'une énumération. Dans les
deux cas, on utilise une « integral constant-expression ». Non ?

oui. Dans une classe il faut les trois, static + const + int (ou un
autre type entier).

Je serais plutôt d'accord avec le fait de dire que l'on peut
utiliser une énumération à la place d'un entier, s'il est clair que

tu parles d'un entier ou d'une variable de type entier?

l'on veut parler de la conversion implicite. Avec comme conséquence
que l'on sait que l'on ne peut alors faire :

enum E { e = 1 } ;
int const a = 1 ;
E const b = e ;

int const * p = & a ;
int const * q = & b ;

car on ne peut convertir « E const * » vers « int const * ». Mais
alors, c'est un problème de compréhension des mécanismes de conversion
implicite.

non, c'est normal, c'est ce que je voulais montrer. Un enum n'a pas
d'adresse. Une variable enum en a une, mais c'est pas ce dont je parlais.

L'exemple que tu donnais était donc biaisé, puisque ce n'est pas
d'utiliser une énumération à la place d'un entier qui ne vas pas, mais
l'adresse d'une énumération à la place de l'adresse d'un entier.

De plus, dans ton exemple, tu prenais directement l'adresse de la
valeur d'énumération « e », et non d'une variable de type « E ». Et
« e » n'est pas une lvalue, tu ne peux donc pas en prendre l'adresse.

eh eh. Je voulais justement monter l'action de const sur la creation
d'un temporaire, ca marche sur un const int et sur un enum:

{
enum E { e = 1 } ;
int const a = 1 ;

const int &p = e; // creation de temporaire
const int &q = 1; // creation de temporaire
const int &r = a; // ok
const E &s = e; // creation de temporaire
const E &t = 1; // boum
const E &u = a; // boum
}

Au fait, quel est le nom exact pour ce que j'ai appelé ici « valeur
d'énumération » ? Ce qui corresponderait dans l'exemple précédent au
« e ».

un identifier.

a+, ld.

drkm wrote:

Laurent Deniau <Laurent.Deniau@cern.ch> writes:

Donc dans ce cas d'accord, ce qui est effectivement evident. Mais
vois-tu d'autres cas?

À vrai dire, je dirais plutôt que je ne vois pas vraiment de cas où
l'on peut utiliser un entier à la place d'une énumération.

Mon exemple ne t'as pas plu?

Il y a
bien des utilisations où ils sont équivalents, comme lorsqu'ils sont
employés en tant que « integral constant-expression ». Mais je ne

Oui, c'est bien de ca que je parle. Un const int peut ou ne pas etre une
integral *constant* expression tandis qu'un enum l'est necessairement
(apres conversion).

dirais pas que passer de :

class C {
enum { size = 10 } ;
int myArray[ size ] ;
} ;

Touche! Relis la premiere phrase citee que j'avais pris soin de garder
dans mon/mes posts precedents.

à :

class C {
static int const size = 10 ;
int myArray[ size ] ;
} ;

revient à utiliser un entier à la place d'une énumération. Dans les
deux cas, on utilise une « integral constant-expression ». Non ?

oui. Dans une classe il faut les trois, static + const + int (ou un
autre type entier).

Je serais plutôt d'accord avec le fait de dire que l'on peut
utiliser une énumération à la place d'un entier, s'il est clair que

tu parles d'un entier ou d'une variable de type entier?

l'on veut parler de la conversion implicite. Avec comme conséquence
que l'on sait que l'on ne peut alors faire :

enum E { e = 1 } ;
int const a = 1 ;
E const b = e ;

int const * p = & a ;
int const * q = & b ;

car on ne peut convertir « E const * » vers « int const * ». Mais
alors, c'est un problème de compréhension des mécanismes de conversion
implicite.

non, c'est normal, c'est ce que je voulais montrer. Un enum n'a pas
d'adresse. Une variable enum en a une, mais c'est pas ce dont je parlais.

L'exemple que tu donnais était donc biaisé, puisque ce n'est pas
d'utiliser une énumération à la place d'un entier qui ne vas pas, mais
l'adresse d'une énumération à la place de l'adresse d'un entier.

De plus, dans ton exemple, tu prenais directement l'adresse de la
valeur d'énumération « e », et non d'une variable de type « E ». Et
« e » n'est pas une lvalue, tu ne peux donc pas en prendre l'adresse.

eh eh. Je voulais justement monter l'action de const sur la creation
d'un temporaire, ca marche sur un const int et sur un enum:

{
enum E { e = 1 } ;
int const a = 1 ;

const int &p = e; // creation de temporaire
const int &q = 1; // creation de temporaire
const int &r = a; // ok
const E &s = e; // creation de temporaire
const E &t = 1; // boum
const E &u = a; // boum
}

Au fait, quel est le nom exact pour ce que j'ai appelé ici « valeur
d'énumération » ? Ce qui corresponderait dans l'exemple précédent au
« e ».

un identifier.

a+, ld.

Vous avez filtré cet utilisateur ! Consultez son message

drkm wrote:

Laurent Deniau writes:

Donc dans ce cas d'accord, ce qui est effectivement evident. Mais
vois-tu d'autres cas?

À vrai dire, je dirais plutôt que je ne vois pas vraiment de cas où
l'on peut utiliser un entier à la place d'une énumération.

Mon exemple ne t'as pas plu?

Il y a
bien des utilisations où ils sont équivalents, comme lorsqu'ils sont
employés en tant que « integral constant-expression ». Mais je ne

Oui, c'est bien de ca que je parle. Un const int peut ou ne pas etre une
integral *constant* expression tandis qu'un enum l'est necessairement
(apres conversion).

dirais pas que passer de :

class C {
enum { size = 10 } ;
int myArray[ size ] ;
} ;

Touche! Relis la premiere phrase citee que j'avais pris soin de garder
dans mon/mes posts precedents.

à :

class C {
static int const size = 10 ;
int myArray[ size ] ;
} ;

revient à utiliser un entier à la place d'une énumération. Dans les
deux cas, on utilise une « integral constant-expression ». Non ?

oui. Dans une classe il faut les trois, static + const + int (ou un
autre type entier).

Je serais plutôt d'accord avec le fait de dire que l'on peut
utiliser une énumération à la place d'un entier, s'il est clair que

tu parles d'un entier ou d'une variable de type entier?

l'on veut parler de la conversion implicite. Avec comme conséquence
que l'on sait que l'on ne peut alors faire :

enum E { e = 1 } ;
int const a = 1 ;
E const b = e ;

int const * p = & a ;
int const * q = & b ;

car on ne peut convertir « E const * » vers « int const * ». Mais
alors, c'est un problème de compréhension des mécanismes de conversion
implicite.

non, c'est normal, c'est ce que je voulais montrer. Un enum n'a pas
d'adresse. Une variable enum en a une, mais c'est pas ce dont je parlais.

L'exemple que tu donnais était donc biaisé, puisque ce n'est pas
d'utiliser une énumération à la place d'un entier qui ne vas pas, mais
l'adresse d'une énumération à la place de l'adresse d'un entier.

De plus, dans ton exemple, tu prenais directement l'adresse de la
valeur d'énumération « e », et non d'une variable de type « E ». Et
« e » n'est pas une lvalue, tu ne peux donc pas en prendre l'adresse.

eh eh. Je voulais justement monter l'action de const sur la creation
d'un temporaire, ca marche sur un const int et sur un enum:

{
enum E { e = 1 } ;
int const a = 1 ;

const int &p = e; // creation de temporaire
const int &q = 1; // creation de temporaire
const int &r = a; // ok
const E &s = e; // creation de temporaire
const E &t = 1; // boum
const E &u = a; // boum
}

Au fait, quel est le nom exact pour ce que j'ai appelé ici « valeur
d'énumération » ? Ce qui corresponderait dans l'exemple précédent au
« e ».

un identifier.

a+, ld.

Fabien LE LEZ

13/08/2004 à 19:49

On 13 Aug 2004 17:32:30 +0200, Gabriel Dos Reis
:

La belle pomme que tu croques aujourd'hui sera la merde que tu
déposeras demain dans le coin idione.

merde qui servira d'engrais pour les pommes de l'an prochain ?

--
;-)

Newbies en C++ !

10 réponses

Veuillez sélectionner un problème