Discussion :

[simac]

Bonjour!
Dans une classe template possédant un std::bitset, j'essaie de surcharger l'opérateur [] afin de modifier la valeur du bitset. C'est-à-dire de pouvoir faire:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
MyClass<8> foo;
foo[7]=0;

ce qui aura pour effet de modifier la 7ème valeur du bitset.

L'opérateur[] de bitset renvoi un std::bitset::reference, et j'aimerai pouvoir le renvoyer aussi.

Je me demande donc si il est possible de faire un truc du genre:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
template <size_t n>
bitset::reference MyClass<n>::operator[] (size_t i)
{
    if(i<n && i>=0)
    {
        return m_content[i];
    }
    else
    {
        return NULL;
    }
}

ou si la classe reference ne peut être utilisée.

Merci pour vos lumières!

cordialement,

Simac

[Daïmanu]

Bonjour.

Je pense que la façon la plus propre quand tu accèdes à des cases en dehors du tableau, est de lancer une exception de type std::out_of_range.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdexcept>
template <size_t n>
bitset::reference MyClass<n>::operator[] (size_t i)
{
    if(i<n && i>=0)
    {
        return m_content[i];
    }
    else
    {
        throw std::out_of_range("Message d'erreur");
    }
}

[Bousk]

Btw, size_t est unsigned donc la moitié du test est inutile (un warning devrait te le signaler selon tes options de compilation)

[simac]

Je pense que la façon la plus propre quand tu accèdes à des cases en dehors du tableau, est de lancer une exception de type std::out_of_range.

Effectivement, c'est plus sécurisé. Mais une exception n'est-elle pas sensée provoquer la fin de l'exécution du programme si elle n'est pas interceptée ? Cela signifierai qu'il faudrait un bloc try{} catch{} pour chaque appels de l'opérateur [] ?

Btw, size_t est unsigned donc la moitié du test est inutile (un warning devrait te le signaler selon tes options de compilation)

Rien à redire ^^

Bien que vos réponses me soient utiles, ma question portait sur l'utilisation du type std::bitset::reference comme type de retour.
En essayant de compiler, gcc me dit :

`template<unsigned int _Nb> class std::bitset' used without template parameters
ISO C++ forbids declaration of `reference' with no type

pour la pré-déclaration de la surcharge (en public dans ma classe) :
std::bitset::reference operator[] (size_t i);Il reconnait donc std::bitset comme étant le type, et non reference.

Je me demande si une fonction peut retourner le type reference, et si oui, comment.

Merci !

[Ehonn]

Il ne faut pas oublier le <B> à std::bitset<B>.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
template <size_t N>
typename std::bitset<N>::reference MyClass<n>::operator [](size_t const i)

Tu peux ajouter : using reference = typename std::bitset<N>::reference; ou le typedef équivalent pour utiliser directement reference.

PS : Généralement, l'opérateur [i] a un comportement indéfini si i n'est pas valide (pour des questions de performances je pense).
Dans le cas de std::bitset, il n'y a pas de fonction at(i) comme avec std::vector mais il y a la fonction membre test.

Edit : Ajout des typename...

[simac]

En rajoutant le paramètre template à la pré-déclaration dans la classe std::bitset<n>::reference operator[] (size_t const i);, le compilo me dit

expected `;' before "operator"

(j'ai mal compris ce que tu voulais dire ?)

Dans la déclaration entière de l'opérateur

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
template <size_t n>
std::bitset<n>::reference MyClass<n>::operator[] (size_t const i)

le compilo retourne aussi une erreur :

expected constructor, destructor, or type conversion before "MyClass"

Tu peux ajouter : using reference = std::bitset<N>::reference;

Il faut donc déclarer le paramètre template N, mais comment ? Ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
template<size_t N>
using reference = std::bitset<N>::reference;

crée

expected unqualified-id before "using"

ou le typedef équivalent

std::bitset étant template, le typedef n'est il pas impossible ? Ou alors je ne saisi pas la FAQ sur les templates...

[dalfab]

Bonjour,

Le type std::bitset<> doit impérativement être défini avant, ensuite

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
template<std::size_t N>
typename std::bitset<N>::reference  MyClass<N>::operator[]( std::size_t const i )  { ... }

devrait fonctionner s'il a bien été déclaré dans MyClass<>.

[simac]

Merci, c'est bien ça, ça marche !
(J'aimerai rajouter quelque chose parce que terminer comme ça c'est un peut fade, mais je trouve pas.) Alors, à nouveau, Merci à vous)

[Ehonn]

Le <N> vient de la classe. Voici la syntaxe (avec différentes possibilités) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
// g++ -Wall -Wextra -Wconversion -Wsign-conversion -Ofast -std=c++11 -pedantic -fopenmp main.cpp -o main && ./main
 
#include <iostream>
#include <bitset>
 
template <size_t N>
class bitset_t
{
public:
 
	using reference = typename std::bitset<N>::reference;
	// NOTE: Avec typedef
	// typedef typename std::bitset<N>::reference reference;
 
private:
 
	std::bitset<N> m_bitset;
 
public:
 
	bitset_t() : m_bitset() { } // ou rien, ou « = default » selon l'initialisation voulue
 
	bool operator [](size_t const i) const { return m_bitset[i]; }
 
	reference operator [](size_t const i) { return m_bitset[i]; }
 
	// NOTE: Si définition séparée de la déclaration
	// reference operator [](size_t const i);
};
 
// NOTE: Si définition séparée de la déclaration
// template <size_t N>
// typename bitset_t<N>::reference bitset_t<N>::operator [](size_t const i) { return m_bitset[i]; }
 
int main()
{
	bitset_t<5> b;
	b[0] = 2;
 
	for (size_t i = 0; i < 5; ++i)
	{
		std::cout << b[i] << std::endl;
	}
 
	return 0;
}

Pour l'histoire du using contre typedef. J'utilise toujours using qui est plus générique et je le trouve plus simple et plus clair (mais il s'agit d'un choix personnel, un choix de coding style).
Seul using permet d'écrire un typedef template. Il s'agit de cela :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
template <class T>
using vector_t = std::vector<T>;

Dans le cas de ton code, le type reference n'est pas template et donc typedef fonctionne aussi.

[simac]

OK, merci pour tes explications

[koala01]

Salut,

Bonjour.

Je pense que la façon la plus propre quand tu accèdes à des cases en dehors du tableau, est de lancer une exception de type std::out_of_range.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdexcept>
template <size_t n>
bitset::reference MyClass<n>::operator[] (size_t i)
{
    if(i<n && i>=0)
    {
        return m_content[i];
    }
    else
    {
        throw std::out_of_range("Message d'erreur");
    }
}

Tu n'as pas tord : un accès en dehors des limites représente effectivement une erreur, et devrait être considéré comme telle.

Seulement, un accès en dehors des limites, c'est aussi (et surtout) une erreur de programmation de la part de celui qui utilise notre classe. C'est, typiquement, le genre d'erreur qui ne devrait pas pouvoir survenir en production, et qui doit être clairement indiquée en période de tests.

Du coup, au lieu de lancer une exception (qui nous fait entrer de plein pieds dans la programmation défensive, ce qui n'est vraiment pas une bonne manière de programmer), il faudrait faire une assertion sur le fait que l'index attendu doit être cohérent par rapport avec la taille du bitset, et pour cela, nous disposons de la macro assert (au travers du fichier d'en-tête <cassert> ), ce qui nous donnerait quelque chose comme

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
template <size_t n>
bitset::reference MyClass<n>::operator[] (size_t i)// le fait d'utiliser un size_t garanti que la valeur de i ne sera jamais négative
{
    assert(i < m_content.size() && "Index out of bound"); // plantera violemment le programme en période de test si l'index est 
                                                          // plus grand ou égal à la taille en bits du bitset
                                                          // mais nous permettra de remonter la pile d'appels en mode debug
        return m_content[i];
}

[Daïmanu]

Bonjour.

En effet, je n'avais pas pensé aux assertions. Mais il n'est pas mieux d'utiliser static_assert du coup, puisqu'il fait partie du langage ?
J'imagine que ce choix dépend de tout à chacun.

[Ehonn]

Mais il n'est pas mieux d'utiliser static_assert du coup, puisqu'il fait partie du langage ?

Le i n'est pas forcément une constante de compilation (constexpr).