Renvoyer un bitset::reference

Version imprimable

04/07/2016, 13h22
simac

Renvoyer un bitset::reference
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:

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:

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

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:

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"); } }

04/07/2016, 15h18
Bousk

Btw, size_t est unsigned donc la moitié du test est inutile (un warning devrait te le signaler selon tes options de compilation)
04/07/2016, 15h51
simac

Citation:

Envoyé par Daïmanu

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 [] ?

Citation:

Envoyé par Bousk

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 :

Citation:

`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 !
04/07/2016, 16h35
Ehonn
Il ne faut pas oublier le <B> à std::bitset<B>.
Code:

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...
04/07/2016, 17h14
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

Citation:

expected `;' before "operator"

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

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

1 2 template <size_t n> std::bitset<n>::reference MyClass<n>::operator[] (size_t const i)
le compilo retourne aussi une erreur :

Citation:

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

Citation:

Envoyé par Ethonn

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

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

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

Citation:

expected unqualified-id before "using"

Citation:

Envoyé par Ethonn

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...
04/07/2016, 18h39
dalfab
Bonjour,

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

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<>.
04/07/2016, 19h06
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)

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

Code:

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:

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.

04/07/2016, 19h50
simac

OK, merci pour tes explications :)

Salut,
Citation:
Envoyé par 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:

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:

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]; }

05/07/2016, 09h44
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.
05/07/2016, 10h11
Ehonn

Citation:

Envoyé par Daïmanu

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).