Discussion :

[victor_gasgas]

Bonjour à tous !

Je suis en train de faire une classe template matrice (à la fois le type des valeurs stockées mais aussi la taille sont connus à la compilation), ce qui me donne la classe mat<T, N, M>.

Jusque là tout va bien, les accesseurs fonctionnent.

Maintenant je souhaite pouvoir extraire une sous-matrice. Donc pour rendre le comportement transparent sans changer l'interface ni dupliquer le code je me dis pourquoi pas stocker des std::reference_wrapper ! Problème c'est que mon algo de création de matrice à d'abord besoin d'initialiser une matrice qui sera le result, hors std::refrence_wrapper ne dispose pas de constructeur par défaut :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
// P et Q sont la taille de la sous matrice
// M et N sont la taille de la matrice mère
// sub est le nom de la fonction membre et i et j sont les indices de départs de la sous matrice
template<size_t P, size_t Q>
template<typename T, size_t N, size_t M>
mat<std::reference_wrapper<T>, P, Q>
mat<T, N, M>::sub(size_t i, size_t j)
{
    mat<std::reference_wrapper<T>, P, Q> result; // error du ctr
 
    // some code
}

Avez-vous une idée pour me dépatouiller de cette situation ?

Merci à tous !!

[Trademark]

Salut,

Pour que reference_wrapper ait un constructeur par défaut il faudrait pouvoir assigner une valeur nulle à une référence. Or une référence possédant une valeur nulle est en fait la sémantique du pointeur. Donc tu dois passer par des pointeurs.

Ou je viens de penser, tu pourrais toujours affecter une valeur trivial dans la liste d'initialisation et puis tous changer dans tes calculs. Ainsi la valeur nulle de ta référence devient la valeur nulle de T. C'est vrai que plus agréable de manipuler des références plutôt que des pointeurs. Je suis pas sûre d'être clair alors vite fait un petit exemple pour montrer ce que j'ai en tête :

Code :

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

1
2
3
4
T dummy;
matrice<...> m = {dummy};
 
// Modifier m...

[victor_gasgas]

Merci pour la réponse !

C'est actuellement la solution que j'essaye. Par contre je sais pas comment faire en sorte que le paramètre "dummy" se répète N*M fois

Code :

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

1
2
3
T dummy;
 
matrice<std::reference_wrapper<T>, N, M> m(dummy, dummy, dummy, /*... N*M fois */);

Je pense que c'est possible à base de template mais là je sèche completement.
Peut-être du côté de boost::mpl.

Merci encore !

[Trademark]

Honnêtement j'en sais pas plus que toi à ce niveau là.

Par contre je pense que ta technique n'est pas la meilleur, quoi qu'on en dise tu vas quand même créer N*M pointeurs via les références, ce qui n'est pas super.

Je pense que tu ferais mieux de passer par une classe intermédiaire qui fournit une vue de ta matrice telle que :

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
class matrix_view
{
  matrix& m;
  int i;
  int j;
 
public:
  matrix_view(int i, int j): i(i), j(j){}
 
  // Remapping sur la matrice d'origine.
  T& operator[](int a, int b)
  {
    return m.at(..., ...);
  }
};

(Template et calcul non montré par paresse).

T'auras 2, 3 opérations mathématiques en plus mais au moins tu sauvegarderas de la place vu que tu passes de N*M pointeurs à 1 pointeur vers la matrice d'origine. Et dans ta fonction sub tu retournes cette classe, à toi de te débrouiller pour qu'elle respecte plus ou moins la même interface qu'une matrice.

PS: Je viens d'aller voir dans Boost et c'est comme ça qu'ils font : http://www.boost.org/doc/libs/1_54_0...#61Description
Inspire toi en ou mieux, utilise les si tu peux