operator[]

Fabien LE LEZ

13/01/2005 à 00:23

On 13 Jan 2005 00:17:26 +0100, Gabriel Dos Reis
:

Mais aime-t-il quelqu'un ?

En tout cas il doit détester tous les contributeurs de fclc++, sinon
il irait troller ailleurs.

--
;-)

drkm

13/01/2005 à 01:06

"Christophe Lephay" writes:

"drkm" a écrit dans le message de news:

"M. B." writes:

"Fabien LE LEZ" a écrit dans le message de
news:

Evite de citer 50 lignes juste pour rajouter une ligne :-(
http://www.giromini.org/usenet-fr/repondre.html

Evite de repondre a une question qui n'etait pas posee.

Où vois-tu une réponse à quelque question ?

Sans compter que discuter des usages n'a rien d'hors charte...

Mais bon, c'est MB et on sait qu'il aime Fabien de longue date même s'il n'a
jamais osé l'avouer jusque là, et qu'il aimerait que ce groupe soit plus
régie par la conception qu'il en a que par sa charte :)

Yep.

Mais, ... je n'avais pas remarqué, ... il a répondu à l'endroit ...
Fantastique !

--drkm

M. B.

13/01/2005 à 04:21

"Fabien LE LEZ" a écrit dans le message de
news:

On 13 Jan 2005 00:17:26 +0100, Gabriel Dos Reis
:

Mais aime-t-il quelqu'un ?

En tout cas il doit détester tous les contributeurs de fclc++, sinon
il irait troller ailleurs.

Non, je vais rester un peu. Les petits roquets qui
aboient, c'est un spectacle plaisant.

MB

Gabriel Dos Reis

13/01/2005 à 05:33

Fabien LE LEZ writes:

| On Wed, 12 Jan 2005 20:02:00 +0100, "M. B." :
|
| Tu peux t'arrêter de poster ici, on vient d'hériter d'un autre troll.

Je crois que C++ autorise l'héritage multiple :-)

-- Gaby

kanze

13/01/2005 à 12:13

Fabien LE LEZ wrote:

On Wed, 12 Jan 2005 18:19:56 +0100, David Hauweele
:

J'ai une classe CChecksum avec un md5_byte_t digest[16]; en
membre privé. Je voudrais mettre un operator[] pour récupérer
ou changer ce membre...

Tu es libre d'utiliser des char[] -- c'est tes oignons,
puisqu'il s'agit d'un membre privé.

Dans le cas précis de MD5, c'est peut-être la meilleur
solution@; tout dépend de l'intérface. Je m'en sers dans mon
implémentation (enfin, des uint8_t[]), ainsi que des uint32_t[].
Parce que j'ai conçu la classe comme un accumulateur pour
std::accumulate, et donc reduire le coût d'une copie est assez
important. (N'oublie pas qu'accumulate fait accu = accu + *iter,
et non accu += *iter. D'où un nombre important de copies. Et
donc le désir de ne pas avoir à me payer des allocations
dynamiques à chaque copie.)

Par contre, évite les
"magic values", écris plutôt :

static size_t TAILLE_DIGEST= 16;
md5_byte_t digest[TAILLE_DIGEST];

Ce qui fait penser que md5_byte_t est plutôt un uint32_t, et non
un char.

Toutefois, pour l'interface publique, ça ne me paraît pas
adapté. Mieux vaut utiliser std::string :

Ça dépend ce qu'il révèle dans l'interface publique. J'avoue que
mon implémentation n'a pas d'opérateur [] ni connaît std::string
que pour lire le résultat. Pour la petite histoire, le début de
ma classe :

class GB_MD5
{
typedef GB_uint8_t Byte ;
typedef GB_uint32_t Word ;

enum {
blockLength = 16,
stateLength = 4,
bytesInWord = 4,
bytesInBlock = blockLength * bytesInWord
} ;
typedef Word Block [ blockLength ] ;
typedef Word State [ stateLength ] ;
typedef GB_uint8_t Buffer[ bytesInBlock ] ;

friend class GB_MD5Ops ;

public:
GB_MD5() ;
void reset() ;

GB_MD5& operator+=( char ch ) ;
GB_MD5& operator+=( GB_uint8_t ch ) ;
GB_MD5& operator+=( signed char ch ) ;
GB_MD5& operator+=( int ch ) ;

std::string value() const ;
operator std::string() const ;

template< typename FwdIter >
void append( FwdIter begin, FwdIter end ) ;

// resultsTo :
// -----------
//
// L'itérateur doit être capable d'absorber resultLength
// octets. Typiquement, c'est back_inserter, mais c'est
aussi
// intéressant parfois de donner le nom d'un tableau de
type
// C ; dans ce cas-là, il faudrait le déclarer avec
une
// taille de resultLength.
//
-------------------------------------------------------------------
enum { resultLength = stateLength * bytesInWord } ;
template< typename OutIter >
void resultsTo( OutIter dest ) const ;

private:
Word myByteCount ;
State myState ;
Buffer myBuffer ;

// ...
} ;

Il en manque évidemment encore pas mal de documentation. Comme
par exemple le fait que value() ou la conversion en chaîne donne
le resultat converti en chaîne de caractères hexadécimal, tandis
que resultsTo() copie réelement des octets binaires.

L'utilisation typique en est assez évidente :

std::string
appendMD5( std::string const& source )
{
return source
+ std::accumulate( source.begin(), source.end(), GB_MD5() )
;
}

Mais rien empèche par exemple de accumuler la somme sur
plusieurs chaînes.

Pour aller plus vite (parce qu'il évite les copies), on pourrait
toujours faire :

std::string
appendMD5( std::string const& source )
{
return source + MD5().append( source.begin(), source.end() ) ;
}

Mais il existe une bibliothèque standard, autant s'en servir.

Deux questions pour les spécialistes de la norme :

-- Est-ce qu'il serait légal d'ajouter un surcharge de
std::accumulate, avec comme troisième parameter un GB_MD5
non templaté ? (Je ne crois pas, a priori, mais je ne suis
pas sûr. Peut-être l'intention était que ceci soit compris
dans la liberté de définir des spécialisations sur ses
propres classes.)

-- Pourquoi est-ce que std::accumulate utilise l'opérateur +,
et non += ? Est-ce que c'est seulement pour éviter
d'introduire un nouveau concepte uniquement pour le
surcharge à quatre paramètres (un AssignmentBinaryOp) ? Ou
est-ce qu'il y a d'autres raisons fondamentales ?

--
James Kanze GABI Software http://www.gabi-soft.fr
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34

Fabien LE LEZ wrote:

On Wed, 12 Jan 2005 18:19:56 +0100, David Hauweele
<eagle94.nospam@free.fr.nospam>:

J'ai une classe CChecksum avec un md5_byte_t digest[16]; en
membre privé. Je voudrais mettre un operator[] pour récupérer
ou changer ce membre...

Tu es libre d'utiliser des char[] -- c'est tes oignons,
puisqu'il s'agit d'un membre privé.

Dans le cas précis de MD5, c'est peut-être la meilleur
solution@; tout dépend de l'intérface. Je m'en sers dans mon
implémentation (enfin, des uint8_t[]), ainsi que des uint32_t[].
Parce que j'ai conçu la classe comme un accumulateur pour
std::accumulate, et donc reduire le coût d'une copie est assez
important. (N'oublie pas qu'accumulate fait accu = accu + *iter,
et non accu += *iter. D'où un nombre important de copies. Et
donc le désir de ne pas avoir à me payer des allocations
dynamiques à chaque copie.)

Par contre, évite les
"magic values", écris plutôt :

static size_t TAILLE_DIGEST= 16;
md5_byte_t digest[TAILLE_DIGEST];

Ce qui fait penser que md5_byte_t est plutôt un uint32_t, et non
un char.

Toutefois, pour l'interface publique, ça ne me paraît pas
adapté. Mieux vaut utiliser std::string :

Ça dépend ce qu'il révèle dans l'interface publique. J'avoue que
mon implémentation n'a pas d'opérateur [] ni connaît std::string
que pour lire le résultat. Pour la petite histoire, le début de
ma classe :

class GB_MD5
{
typedef GB_uint8_t Byte ;
typedef GB_uint32_t Word ;

enum {
blockLength = 16,
stateLength = 4,
bytesInWord = 4,
bytesInBlock = blockLength * bytesInWord
} ;
typedef Word Block [ blockLength ] ;
typedef Word State [ stateLength ] ;
typedef GB_uint8_t Buffer[ bytesInBlock ] ;

friend class GB_MD5Ops ;

public:
GB_MD5() ;
void reset() ;

GB_MD5& operator+=( char ch ) ;
GB_MD5& operator+=( GB_uint8_t ch ) ;
GB_MD5& operator+=( signed char ch ) ;
GB_MD5& operator+=( int ch ) ;

std::string value() const ;
operator std::string() const ;

template< typename FwdIter >
void append( FwdIter begin, FwdIter end ) ;

// resultsTo :
// -----------
//
// L'itérateur doit être capable d'absorber resultLength
// octets. Typiquement, c'est back_inserter, mais c'est
aussi
// intéressant parfois de donner le nom d'un tableau de
type
// C ; dans ce cas-là, il faudrait le déclarer avec
une
// taille de resultLength.
//
-------------------------------------------------------------------
enum { resultLength = stateLength * bytesInWord } ;
template< typename OutIter >
void resultsTo( OutIter dest ) const ;

private:
Word myByteCount ;
State myState ;
Buffer myBuffer ;

// ...
} ;

Il en manque évidemment encore pas mal de documentation. Comme
par exemple le fait que value() ou la conversion en chaîne donne
le resultat converti en chaîne de caractères hexadécimal, tandis
que resultsTo() copie réelement des octets binaires.

L'utilisation typique en est assez évidente :

std::string
appendMD5( std::string const& source )
{
return source
+ std::accumulate( source.begin(), source.end(), GB_MD5() )
;
}

Mais rien empèche par exemple de accumuler la somme sur
plusieurs chaînes.

Pour aller plus vite (parce qu'il évite les copies), on pourrait
toujours faire :

std::string
appendMD5( std::string const& source )
{
return source + MD5().append( source.begin(), source.end() ) ;
}

Mais il existe une bibliothèque standard, autant s'en servir.

Deux questions pour les spécialistes de la norme :

-- Est-ce qu'il serait légal d'ajouter un surcharge de
std::accumulate, avec comme troisième parameter un GB_MD5
non templaté ? (Je ne crois pas, a priori, mais je ne suis
pas sûr. Peut-être l'intention était que ceci soit compris
dans la liberté de définir des spécialisations sur ses
propres classes.)

-- Pourquoi est-ce que std::accumulate utilise l'opérateur +,
et non += ? Est-ce que c'est seulement pour éviter
d'introduire un nouveau concepte uniquement pour le
surcharge à quatre paramètres (un AssignmentBinaryOp) ? Ou
est-ce qu'il y a d'autres raisons fondamentales ?

--
James Kanze GABI Software http://www.gabi-soft.fr
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34

Vous avez filtré cet utilisateur ! Consultez son message

Fabien LE LEZ wrote:

On Wed, 12 Jan 2005 18:19:56 +0100, David Hauweele
:

J'ai une classe CChecksum avec un md5_byte_t digest[16]; en
membre privé. Je voudrais mettre un operator[] pour récupérer
ou changer ce membre...

Tu es libre d'utiliser des char[] -- c'est tes oignons,
puisqu'il s'agit d'un membre privé.

Dans le cas précis de MD5, c'est peut-être la meilleur
solution@; tout dépend de l'intérface. Je m'en sers dans mon
implémentation (enfin, des uint8_t[]), ainsi que des uint32_t[].
Parce que j'ai conçu la classe comme un accumulateur pour
std::accumulate, et donc reduire le coût d'une copie est assez
important. (N'oublie pas qu'accumulate fait accu = accu + *iter,
et non accu += *iter. D'où un nombre important de copies. Et
donc le désir de ne pas avoir à me payer des allocations
dynamiques à chaque copie.)

Par contre, évite les
"magic values", écris plutôt :

static size_t TAILLE_DIGEST= 16;
md5_byte_t digest[TAILLE_DIGEST];

Ce qui fait penser que md5_byte_t est plutôt un uint32_t, et non
un char.

Toutefois, pour l'interface publique, ça ne me paraît pas
adapté. Mieux vaut utiliser std::string :

Ça dépend ce qu'il révèle dans l'interface publique. J'avoue que
mon implémentation n'a pas d'opérateur [] ni connaît std::string
que pour lire le résultat. Pour la petite histoire, le début de
ma classe :

class GB_MD5
{
typedef GB_uint8_t Byte ;
typedef GB_uint32_t Word ;

enum {
blockLength = 16,
stateLength = 4,
bytesInWord = 4,
bytesInBlock = blockLength * bytesInWord
} ;
typedef Word Block [ blockLength ] ;
typedef Word State [ stateLength ] ;
typedef GB_uint8_t Buffer[ bytesInBlock ] ;

friend class GB_MD5Ops ;

public:
GB_MD5() ;
void reset() ;

GB_MD5& operator+=( char ch ) ;
GB_MD5& operator+=( GB_uint8_t ch ) ;
GB_MD5& operator+=( signed char ch ) ;
GB_MD5& operator+=( int ch ) ;

std::string value() const ;
operator std::string() const ;

template< typename FwdIter >
void append( FwdIter begin, FwdIter end ) ;

// resultsTo :
// -----------
//
// L'itérateur doit être capable d'absorber resultLength
// octets. Typiquement, c'est back_inserter, mais c'est
aussi
// intéressant parfois de donner le nom d'un tableau de
type
// C ; dans ce cas-là, il faudrait le déclarer avec
une
// taille de resultLength.
//
-------------------------------------------------------------------
enum { resultLength = stateLength * bytesInWord } ;
template< typename OutIter >
void resultsTo( OutIter dest ) const ;

private:
Word myByteCount ;
State myState ;
Buffer myBuffer ;

// ...
} ;

Il en manque évidemment encore pas mal de documentation. Comme
par exemple le fait que value() ou la conversion en chaîne donne
le resultat converti en chaîne de caractères hexadécimal, tandis
que resultsTo() copie réelement des octets binaires.

L'utilisation typique en est assez évidente :

std::string
appendMD5( std::string const& source )
{
return source
+ std::accumulate( source.begin(), source.end(), GB_MD5() )
;
}

Mais rien empèche par exemple de accumuler la somme sur
plusieurs chaînes.

Pour aller plus vite (parce qu'il évite les copies), on pourrait
toujours faire :

std::string
appendMD5( std::string const& source )
{
return source + MD5().append( source.begin(), source.end() ) ;
}

Mais il existe une bibliothèque standard, autant s'en servir.

Deux questions pour les spécialistes de la norme :

-- Est-ce qu'il serait légal d'ajouter un surcharge de
std::accumulate, avec comme troisième parameter un GB_MD5
non templaté ? (Je ne crois pas, a priori, mais je ne suis
pas sûr. Peut-être l'intention était que ceci soit compris
dans la liberté de définir des spécialisations sur ses
propres classes.)

-- Pourquoi est-ce que std::accumulate utilise l'opérateur +,
et non += ? Est-ce que c'est seulement pour éviter
d'introduire un nouveau concepte uniquement pour le
surcharge à quatre paramètres (un AssignmentBinaryOp) ? Ou
est-ce qu'il y a d'autres raisons fondamentales ?

--
James Kanze GABI Software http://www.gabi-soft.fr
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34

Michael

13/01/2005 à 12:57

Gabriel Dos Reis wrote in
news::

Fabien LE LEZ writes:

| On Wed, 12 Jan 2005 20:02:00 +0100, "M. B." :
|
| Tu peux t'arrêter de poster ici, on vient d'hériter d'un autre troll.

Je crois que C++ autorise l'héritage multiple :-)

:-D Excellent

operator[]

6 réponses

Veuillez sélectionner un problème