Et sinon, pourquoi les classes (enfin, mon compilo) ne permettent elle pas
de faire
class X {
void foo(); // Déclaration
...
void foo(){...}; // Implementation
}
Et sinon, pourquoi les classes (enfin, mon compilo) ne permettent elle pas
de faire
class X {
void foo(); // Déclaration
...
void foo(){...}; // Implementation
}
Et sinon, pourquoi les classes (enfin, mon compilo) ne permettent elle pas
de faire
class X {
void foo(); // Déclaration
...
void foo(){...}; // Implementation
}
On 15 Nov 2004 10:31:27 GMT, Marc Boyer
:Et sinon, pourquoi les classes (enfin, mon compilo) ne permettent elle pas
de faire
class X {
void foo(); // Déclaration
...
void foo(){...}; // Implementation
}
Quelle pourrait en être l'utilité ?
On 15 Nov 2004 10:31:27 GMT, Marc Boyer
<Marc.Boyer@enseeiht.yahoo.fr.invalid>:
Et sinon, pourquoi les classes (enfin, mon compilo) ne permettent elle pas
de faire
class X {
void foo(); // Déclaration
...
void foo(){...}; // Implementation
}
Quelle pourrait en être l'utilité ?
On 15 Nov 2004 10:31:27 GMT, Marc Boyer
:Et sinon, pourquoi les classes (enfin, mon compilo) ne permettent elle pas
de faire
class X {
void foo(); // Déclaration
...
void foo(){...}; // Implementation
}
Quelle pourrait en être l'utilité ?
Bonjour,
une petite question sur vos pratiques d'édition.
Pour écrire la définition de code de classe template, j'aimerais
bien séparer l'interface de l'implémentation.
Mais ça devient très lourd, du genre
template <class T>
typename X<T>::iterator X<T>::first_with(typename X<T>::cond& c){
....
}
alors que si je laisse dans la déclaration de la classe, ça donne
iterator first_with(cond& c);
Je m'en sort à grands coups de
#define X_TEMPLATE template<class T>
#define X X<T>
#define iterator typename X<T>::iterator
#define cond typename X<T>::cond
mais c'est lourd.
Vous faites comment vous ? Un super éditeur/IDE qui cache tout le sucre ?
Et sinon, pourquoi les classes (enfin, mon compilo) ne permettent elle pas
de faire
class X {
void foo(); // Déclaration
...
void foo(){...}; // Implementation
}
Marc Boyer
Bonjour,
une petite question sur vos pratiques d'édition.
Pour écrire la définition de code de classe template, j'aimerais
bien séparer l'interface de l'implémentation.
Mais ça devient très lourd, du genre
template <class T>
typename X<T>::iterator X<T>::first_with(typename X<T>::cond& c){
....
}
alors que si je laisse dans la déclaration de la classe, ça donne
iterator first_with(cond& c);
Je m'en sort à grands coups de
#define X_TEMPLATE template<class T>
#define X X<T>
#define iterator typename X<T>::iterator
#define cond typename X<T>::cond
mais c'est lourd.
Vous faites comment vous ? Un super éditeur/IDE qui cache tout le sucre ?
Et sinon, pourquoi les classes (enfin, mon compilo) ne permettent elle pas
de faire
class X {
void foo(); // Déclaration
...
void foo(){...}; // Implementation
}
Marc Boyer
Bonjour,
une petite question sur vos pratiques d'édition.
Pour écrire la définition de code de classe template, j'aimerais
bien séparer l'interface de l'implémentation.
Mais ça devient très lourd, du genre
template <class T>
typename X<T>::iterator X<T>::first_with(typename X<T>::cond& c){
....
}
alors que si je laisse dans la déclaration de la classe, ça donne
iterator first_with(cond& c);
Je m'en sort à grands coups de
#define X_TEMPLATE template<class T>
#define X X<T>
#define iterator typename X<T>::iterator
#define cond typename X<T>::cond
mais c'est lourd.
Vous faites comment vous ? Un super éditeur/IDE qui cache tout le sucre ?
Et sinon, pourquoi les classes (enfin, mon compilo) ne permettent elle pas
de faire
class X {
void foo(); // Déclaration
...
void foo(){...}; // Implementation
}
Marc Boyer
tu verras que tout le monde y va à grand coup de #define.
C'est que cette solution ne doit pas être des plus mauvaises...
tu verras que tout le monde y va à grand coup de #define.
C'est que cette solution ne doit pas être des plus mauvaises...
tu verras que tout le monde y va à grand coup de #define.
C'est que cette solution ne doit pas être des plus mauvaises...
Si tu regardes comment bossent les grands groupes d'édition de logiciels
(génère du code natif JNI par exemple ou ouvre le src d'Apache HTTP
Server), tu verras que tout le monde y va à grand coup de #define.
C'est que cette solution ne doit pas être des plus mauvaises...
Si tu regardes comment bossent les grands groupes d'édition de logiciels
(génère du code natif JNI par exemple ou ouvre le src d'Apache HTTP
Server), tu verras que tout le monde y va à grand coup de #define.
C'est que cette solution ne doit pas être des plus mauvaises...
Si tu regardes comment bossent les grands groupes d'édition de logiciels
(génère du code natif JNI par exemple ou ouvre le src d'Apache HTTP
Server), tu verras que tout le monde y va à grand coup de #define.
C'est que cette solution ne doit pas être des plus mauvaises...
une petite question sur vos pratiques d'édition.
Pour écrire la définition de code de classe template, j'aimerais bien
séparer l'interface de l'implémentation.
Mais ça devient très lourd, du genre
template <class T>
typename X<T>::iterator X<T>::first_with(typename X<T>::cond& c){
....
}
alors que si je laisse dans la déclaration de la classe, ça donne
iterator first_with(cond& c);
Je m'en sort à grands coups de
#define X_TEMPLATE template<class T>
#define X X<T>
#define iterator typename X<T>::iterator
#define cond typename X<T>::cond
mais c'est lourd.
Vous faites comment vous ? Un super éditeur/IDE qui cache tout le
sucre ?
Et sinon, pourquoi les classes (enfin, mon compilo) ne permettent elle
pas de faire
class X {
void foo(); // Déclaration
...
void foo(){...}; // Implementation
}
une petite question sur vos pratiques d'édition.
Pour écrire la définition de code de classe template, j'aimerais bien
séparer l'interface de l'implémentation.
Mais ça devient très lourd, du genre
template <class T>
typename X<T>::iterator X<T>::first_with(typename X<T>::cond& c){
....
}
alors que si je laisse dans la déclaration de la classe, ça donne
iterator first_with(cond& c);
Je m'en sort à grands coups de
#define X_TEMPLATE template<class T>
#define X X<T>
#define iterator typename X<T>::iterator
#define cond typename X<T>::cond
mais c'est lourd.
Vous faites comment vous ? Un super éditeur/IDE qui cache tout le
sucre ?
Et sinon, pourquoi les classes (enfin, mon compilo) ne permettent elle
pas de faire
class X {
void foo(); // Déclaration
...
void foo(){...}; // Implementation
}
une petite question sur vos pratiques d'édition.
Pour écrire la définition de code de classe template, j'aimerais bien
séparer l'interface de l'implémentation.
Mais ça devient très lourd, du genre
template <class T>
typename X<T>::iterator X<T>::first_with(typename X<T>::cond& c){
....
}
alors que si je laisse dans la déclaration de la classe, ça donne
iterator first_with(cond& c);
Je m'en sort à grands coups de
#define X_TEMPLATE template<class T>
#define X X<T>
#define iterator typename X<T>::iterator
#define cond typename X<T>::cond
mais c'est lourd.
Vous faites comment vous ? Un super éditeur/IDE qui cache tout le
sucre ?
Et sinon, pourquoi les classes (enfin, mon compilo) ne permettent elle
pas de faire
class X {
void foo(); // Déclaration
...
void foo(){...}; // Implementation
}
Marc Boyer wrote in message
news:<cna0hv$4qo$...une petite question sur vos pratiques d'édition.
Pour écrire la définition de code de classe template, j'aimerais bien
séparer l'interface de l'implémentation.
Mais ça devient très lourd, du genre
template <class T>
typename X<T>::iterator X<T>::first_with(typename X<T>::cond& c){
....
}
C'est lourd. Le C++ exige en effet beaucoup de boilerplate.
Note toutefois qu'un peu de rédondance n'est pas forcement une mauvaise
chose.
alors que si je laisse dans la déclaration de la classe, ça donne
iterator first_with(cond& c);
Ça donne surtout un très fort couplage des fichiers, ce qui devient vite
insoutenable dans les grands projets.
Je m'en sort à grands coups de
#define X_TEMPLATE template<class T>
#define X X<T>
#define iterator typename X<T>::iterator
#define cond typename X<T>::cond
J'espère que non. J'appelle ça l'obfuscation.
mais c'est lourd.
Vous faites comment vous ? Un super éditeur/IDE qui cache tout le
sucre ?
Je ne sais pas si c'est un super éditeur, mais les deux éditeurs dont je
me sers (vim et emacs) ont tous les deux l'achevement automatique des
mots, ce qui réduit de beaucoup le nombre de caractères à entrée. Sinon,
les deux supportent aussi la copier/coller, et l'enregistrement d'un
bout de texte dans un régistre nommé, quand j'ai une suite de fonctions
avec un en-tête en commun.
Et sinon, pourquoi les classes (enfin, mon compilo) ne permettent elle
pas de faire
class X {
void foo(); // Déclaration
...
void foo(){...}; // Implementation
}
Parce que ça n'apportera rien, dans la mésure où le but, c'est que
l'implémentation et la définition de la classe soient dans des fichiers
distincts.
Ce que j'avais suggéré, à une époque, c'est la possibilité de définir
des portées d'implémentations, quelque chose du genre :
implement class X {
// ...
}
où toutes les fonctions définies dans la portée aurait appartenues à
class X. Étendu à ton exemple, ça aurait donné :
implement template< typename T > class X< T >
{
iterator first_with( cond& c ) { ... }
}
(À l'époque où j'y avais pensé, il n'y avait pas encore le typename dans
les templates.)
J'avais pensé aussi qu'il pourrait aussi être intéressant de permettre
la declaration et la définition de nouvelles fonctions privées (non
virtuelles) dans ce contexte.
J'en avais parlé à plusieurs personnes dans une réunion du comité ;
suite à la manque manifeste d'intérêt, j'ai laissé tomber.
Marc Boyer <Marc.Boyer@enseeiht.yahoo.fr.invalid> wrote in message
news:<cna0hv$4qo$2@news.cict.fr>...
une petite question sur vos pratiques d'édition.
Pour écrire la définition de code de classe template, j'aimerais bien
séparer l'interface de l'implémentation.
Mais ça devient très lourd, du genre
template <class T>
typename X<T>::iterator X<T>::first_with(typename X<T>::cond& c){
....
}
C'est lourd. Le C++ exige en effet beaucoup de boilerplate.
Note toutefois qu'un peu de rédondance n'est pas forcement une mauvaise
chose.
alors que si je laisse dans la déclaration de la classe, ça donne
iterator first_with(cond& c);
Ça donne surtout un très fort couplage des fichiers, ce qui devient vite
insoutenable dans les grands projets.
Je m'en sort à grands coups de
#define X_TEMPLATE template<class T>
#define X X<T>
#define iterator typename X<T>::iterator
#define cond typename X<T>::cond
J'espère que non. J'appelle ça l'obfuscation.
mais c'est lourd.
Vous faites comment vous ? Un super éditeur/IDE qui cache tout le
sucre ?
Je ne sais pas si c'est un super éditeur, mais les deux éditeurs dont je
me sers (vim et emacs) ont tous les deux l'achevement automatique des
mots, ce qui réduit de beaucoup le nombre de caractères à entrée. Sinon,
les deux supportent aussi la copier/coller, et l'enregistrement d'un
bout de texte dans un régistre nommé, quand j'ai une suite de fonctions
avec un en-tête en commun.
Et sinon, pourquoi les classes (enfin, mon compilo) ne permettent elle
pas de faire
class X {
void foo(); // Déclaration
...
void foo(){...}; // Implementation
}
Parce que ça n'apportera rien, dans la mésure où le but, c'est que
l'implémentation et la définition de la classe soient dans des fichiers
distincts.
Ce que j'avais suggéré, à une époque, c'est la possibilité de définir
des portées d'implémentations, quelque chose du genre :
implement class X {
// ...
}
où toutes les fonctions définies dans la portée aurait appartenues à
class X. Étendu à ton exemple, ça aurait donné :
implement template< typename T > class X< T >
{
iterator first_with( cond& c ) { ... }
}
(À l'époque où j'y avais pensé, il n'y avait pas encore le typename dans
les templates.)
J'avais pensé aussi qu'il pourrait aussi être intéressant de permettre
la declaration et la définition de nouvelles fonctions privées (non
virtuelles) dans ce contexte.
J'en avais parlé à plusieurs personnes dans une réunion du comité ;
suite à la manque manifeste d'intérêt, j'ai laissé tomber.
Marc Boyer wrote in message
news:<cna0hv$4qo$...une petite question sur vos pratiques d'édition.
Pour écrire la définition de code de classe template, j'aimerais bien
séparer l'interface de l'implémentation.
Mais ça devient très lourd, du genre
template <class T>
typename X<T>::iterator X<T>::first_with(typename X<T>::cond& c){
....
}
C'est lourd. Le C++ exige en effet beaucoup de boilerplate.
Note toutefois qu'un peu de rédondance n'est pas forcement une mauvaise
chose.
alors que si je laisse dans la déclaration de la classe, ça donne
iterator first_with(cond& c);
Ça donne surtout un très fort couplage des fichiers, ce qui devient vite
insoutenable dans les grands projets.
Je m'en sort à grands coups de
#define X_TEMPLATE template<class T>
#define X X<T>
#define iterator typename X<T>::iterator
#define cond typename X<T>::cond
J'espère que non. J'appelle ça l'obfuscation.
mais c'est lourd.
Vous faites comment vous ? Un super éditeur/IDE qui cache tout le
sucre ?
Je ne sais pas si c'est un super éditeur, mais les deux éditeurs dont je
me sers (vim et emacs) ont tous les deux l'achevement automatique des
mots, ce qui réduit de beaucoup le nombre de caractères à entrée. Sinon,
les deux supportent aussi la copier/coller, et l'enregistrement d'un
bout de texte dans un régistre nommé, quand j'ai une suite de fonctions
avec un en-tête en commun.
Et sinon, pourquoi les classes (enfin, mon compilo) ne permettent elle
pas de faire
class X {
void foo(); // Déclaration
...
void foo(){...}; // Implementation
}
Parce que ça n'apportera rien, dans la mésure où le but, c'est que
l'implémentation et la définition de la classe soient dans des fichiers
distincts.
Ce que j'avais suggéré, à une époque, c'est la possibilité de définir
des portées d'implémentations, quelque chose du genre :
implement class X {
// ...
}
où toutes les fonctions définies dans la portée aurait appartenues à
class X. Étendu à ton exemple, ça aurait donné :
implement template< typename T > class X< T >
{
iterator first_with( cond& c ) { ... }
}
(À l'époque où j'y avais pensé, il n'y avait pas encore le typename dans
les templates.)
J'avais pensé aussi qu'il pourrait aussi être intéressant de permettre
la declaration et la définition de nouvelles fonctions privées (non
virtuelles) dans ce contexte.
J'en avais parlé à plusieurs personnes dans une réunion du comité ;
suite à la manque manifeste d'intérêt, j'ai laissé tomber.
Fabien wrote:Si tu regardes comment bossent les grands groupes d'édition de logiciels
(génère du code natif JNI par exemple ou ouvre le src d'Apache HTTP
Server), tu verras que tout le monde y va à grand coup de #define.
OK.C'est que cette solution ne doit pas être des plus mauvaises...
J'avoue qu'en fait, je rève d'un bel IDE qui masque un peut
tout ce sucre: je sélectionne une classe, j'accède à sa définition,
son implémentation, ses spécialisation, tout ça bien rangé...
Je vais tester VC++ un de ces jours pour voir.
Fabien wrote:
Si tu regardes comment bossent les grands groupes d'édition de logiciels
(génère du code natif JNI par exemple ou ouvre le src d'Apache HTTP
Server), tu verras que tout le monde y va à grand coup de #define.
OK.
C'est que cette solution ne doit pas être des plus mauvaises...
J'avoue qu'en fait, je rève d'un bel IDE qui masque un peut
tout ce sucre: je sélectionne une classe, j'accède à sa définition,
son implémentation, ses spécialisation, tout ça bien rangé...
Je vais tester VC++ un de ces jours pour voir.
Fabien wrote:Si tu regardes comment bossent les grands groupes d'édition de logiciels
(génère du code natif JNI par exemple ou ouvre le src d'Apache HTTP
Server), tu verras que tout le monde y va à grand coup de #define.
OK.C'est que cette solution ne doit pas être des plus mauvaises...
J'avoue qu'en fait, je rève d'un bel IDE qui masque un peut
tout ce sucre: je sélectionne une classe, j'accède à sa définition,
son implémentation, ses spécialisation, tout ça bien rangé...
Je vais tester VC++ un de ces jours pour voir.
Je m'en sort à grands coups de
#define X_TEMPLATE template<class T>
#define X X<T>
#define iterator typename X<T>::iterator
#define cond typename X<T>::cond
J'espère que non. J'appelle ça l'obfuscation.
Je m'en sort à grands coups de
#define X_TEMPLATE template<class T>
#define X X<T>
#define iterator typename X<T>::iterator
#define cond typename X<T>::cond
J'espère que non. J'appelle ça l'obfuscation.
Je m'en sort à grands coups de
#define X_TEMPLATE template<class T>
#define X X<T>
#define iterator typename X<T>::iterator
#define cond typename X<T>::cond
J'espère que non. J'appelle ça l'obfuscation.
Je ne sais pas si c'est un super éditeur, mais les deux éditeurs dont je
me sers (vim et emacs) ont tous les deux l'achevement automatique des
mots, ce qui réduit de beaucoup le nombre de caractères à entrée. Sinon,
les deux supportent aussi la copier/coller, et l'enregistrement d'un
bout de texte dans un régistre nommé, quand j'ai une suite de fonctions
avec un en-tête en commun.
Et sinon, pourquoi les classes (enfin, mon compilo) ne permettent elle
pas de faire
class X {
void foo(); // Déclaration
...
void foo(){...}; // Implementation
}
Parce que ça n'apportera rien, dans la mésure où le but, c'est que
l'implémentation et la définition de la classe soient dans des fichiers
distincts.
Ce que j'avais suggéré, à une époque, c'est la possibilité de définir
des portées d'implémentations, quelque chose du genre :
implement class X {
// ...
}
où toutes les fonctions définies dans la portée aurait appartenues à
class X. Étendu à ton exemple, ça aurait donné :
implement template< typename T > class X< T >
{
iterator first_with( cond& c ) { ... }
}
(À l'époque où j'y avais pensé, il n'y avait pas encore le typename dans
les templates.)
J'avais pensé aussi qu'il pourrait aussi être intéressant de permettre
la declaration et la définition de nouvelles fonctions privées (non
virtuelles) dans ce contexte.
J'en avais parlé à plusieurs personnes dans une réunion du comité ;
suite à la manque manifeste d'intérêt, j'ai laissé tomber.
Je ne sais pas si c'est un super éditeur, mais les deux éditeurs dont je
me sers (vim et emacs) ont tous les deux l'achevement automatique des
mots, ce qui réduit de beaucoup le nombre de caractères à entrée. Sinon,
les deux supportent aussi la copier/coller, et l'enregistrement d'un
bout de texte dans un régistre nommé, quand j'ai une suite de fonctions
avec un en-tête en commun.
Et sinon, pourquoi les classes (enfin, mon compilo) ne permettent elle
pas de faire
class X {
void foo(); // Déclaration
...
void foo(){...}; // Implementation
}
Parce que ça n'apportera rien, dans la mésure où le but, c'est que
l'implémentation et la définition de la classe soient dans des fichiers
distincts.
Ce que j'avais suggéré, à une époque, c'est la possibilité de définir
des portées d'implémentations, quelque chose du genre :
implement class X {
// ...
}
où toutes les fonctions définies dans la portée aurait appartenues à
class X. Étendu à ton exemple, ça aurait donné :
implement template< typename T > class X< T >
{
iterator first_with( cond& c ) { ... }
}
(À l'époque où j'y avais pensé, il n'y avait pas encore le typename dans
les templates.)
J'avais pensé aussi qu'il pourrait aussi être intéressant de permettre
la declaration et la définition de nouvelles fonctions privées (non
virtuelles) dans ce contexte.
J'en avais parlé à plusieurs personnes dans une réunion du comité ;
suite à la manque manifeste d'intérêt, j'ai laissé tomber.
Je ne sais pas si c'est un super éditeur, mais les deux éditeurs dont je
me sers (vim et emacs) ont tous les deux l'achevement automatique des
mots, ce qui réduit de beaucoup le nombre de caractères à entrée. Sinon,
les deux supportent aussi la copier/coller, et l'enregistrement d'un
bout de texte dans un régistre nommé, quand j'ai une suite de fonctions
avec un en-tête en commun.
Et sinon, pourquoi les classes (enfin, mon compilo) ne permettent elle
pas de faire
class X {
void foo(); // Déclaration
...
void foo(){...}; // Implementation
}
Parce que ça n'apportera rien, dans la mésure où le but, c'est que
l'implémentation et la définition de la classe soient dans des fichiers
distincts.
Ce que j'avais suggéré, à une époque, c'est la possibilité de définir
des portées d'implémentations, quelque chose du genre :
implement class X {
// ...
}
où toutes les fonctions définies dans la portée aurait appartenues à
class X. Étendu à ton exemple, ça aurait donné :
implement template< typename T > class X< T >
{
iterator first_with( cond& c ) { ... }
}
(À l'époque où j'y avais pensé, il n'y avait pas encore le typename dans
les templates.)
J'avais pensé aussi qu'il pourrait aussi être intéressant de permettre
la declaration et la définition de nouvelles fonctions privées (non
virtuelles) dans ce contexte.
J'en avais parlé à plusieurs personnes dans une réunion du comité ;
suite à la manque manifeste d'intérêt, j'ai laissé tomber.