Problème héritage pour les attributs

Version imprimable

Voir 40 message(s) de cette discussion en une page

Bonjour

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
class Matrice
{
    protected:
 
        typedef float *ligne;
        ligne *matrice; // données de la matrice
        int nbLig; // Nombre de lignes de la matrice
        int nbCol; // Nombre de colonnes de la matrice
...
}
 
class Vecteur : public Matrice
{
...
}
 
Vecteur Vecteur::operator*(const Matrice &mat)
{
    Vecteur ret;
 
    ret.x = mat.matrice[0][0]*x + mat.matrice[0][1]*y + mat.matrice[0][2]*z + mat.matrice[0][3];
    ret.y = mat.matrice[1][0]*x + mat.matrice[1][1]*y + mat.matrice[1][2]*z + mat.matrice[1][3];
    ret.z = mat.matrice[2][0]*x + mat.matrice[2][1]*y + mat.matrice[2][2]*z + mat.matrice[2][3];
 
    return ret;
}

Le compilateur me dit que je ne peux pas accéder à l'attribut matrice (qui correspond aux éléments de ma matrice) alors que je l'ai mis en protected et que j'ai fait un héritage..
Je ne comprends pas le problème, merci de bien vouloir m'aider.

06/04/2011, 10h16
Flo.

Salut,

Dans ta fonction

Code:

Vecteur Vecteur::operator*(const Matrice &mat)

mat est marquée comme const. Tu ne peux donc pas accéder à ses attributs comme tu le fais excepté si tu les rends "mutable" ou si tu supprimes le const de l'argument de ta fonction

Code:

mutable ligne *matrice;

ou

Code:

Vecteur Vecteur::operator*(Matrice &mat)

Flo.
06/04/2011, 11h35
fab87

Merci çà fonctionne!!
Mais je viens de remarquer que ma fonction va retourner une matrice! =)

Attention, parce que mes 2 solutions ne sont peut-être pas bonnes d'un point de vue philosophie. Effectivement dans ta fonction, il est logique de mettre mat en const puisqu'elle n'est pas modifiée. Et mettre ses attributs en mutable n'est pas également une solution.

La bonne (et troisième) solution à mon avis serait de proposer une fonction
Code:

1 2 3 4 const double Matrice::get(const unsigned int & i, const unsigned int & j) const { return matrice[i][j]; }
que tu pourrais utiliser comme ceci
Code:

1 2 3 4 5 6 7 8 9 10 Vecteur Vecteur::operator*(const Matrice &mat) { Vecteur ret; ret.x = mat.get(0,0)*x + mat.get(0,1)*y + mat.get(0,2)*z + mat.get(0,3); ret.y = mat.get(1,0)*x + mat.get(1,1)*y + mat.get(1,2)*z + mat.get(1,3); ret.z = mat.get(2,0)*x + mat.get(2,1)*y + mat.get(2,2)*z + mat.get(2,3); return ret; }
Flo.

06/04/2011, 12h00
fab87

Merci!
En effet je pense que c'est plus correcte.
Néanmoins j'ai toujours deux erreurs :

- pour cette ligne : Vecteur operator*(const Matrice &);

ISO C++ forbids declaration of `Matrice' with no type

expected ',' or '...' before '&' token
06/04/2011, 13h50
fab87

En fait, je suis dans la classe vecteur et le produit d'un vecteur par une matrice me retourne une matrice normalement donc çà va pas.

Comment puis-je faire pour implémenter une méthode permettant de multiplier une matrice par un vecteur dans ma classe Vecteur?
Je suis obligé de mettre deux paramètres nan? Mais pour une surcharge il ne faut pas même je crois qu'on ne peut pas..

Merci de bien m'aider

Vecteur Vecteur::operator*(const Vecteur &vect, const Matrice &mat) serait une idiotie je crois mais je ne vois pas comment faire..

Tu définis une fonction libre, c'est à dire non membre de Matrice ou de Vecteur :
Code:

1 2 3 4 5 6 7 8 9 10 11 class Matrice { }; class Vecteur : public Matrice { }; Matrice operator * (const Vecteur & vect, const Matrice & mat) { }
Flo.

06/04/2011, 14h06
fab87

D'accord merci =)
Mais je définis cette fonction dans une classe qui hérite de Matrice et Vecteur?
06/04/2011, 14h13
fab87

Ta fonction ne va pas plutôt faire la multiplication d'une matrice par un vecteur et par une autre matrice?

La fonction suivante par exemple :
Code:

1 2 3 4 5 6 7 8 Vecteur operator * (const Matrice & mat, const Vecteur & vect) { const double x = mat.get(0,0)*vect.getX() + mat.get(0,1)*vect.getY() + mat.get(0,2)*vect.getZ() + mat.get(0,3); const double y = mat.get(1,0)*vect.getX() + mat.get(1,1)*vect.getY() + mat.get(1,2)*vect.getZ() + mat.get(1,3); const double z = mat.get(2,0)*vect.getX() + mat.get(2,1)*vect.getY() + mat.get(2,2)*vect.getZ() + mat.get(2,3); return Vecteur(x, y, z); }
(en supposant que la classe Vecteur possède un constructeur qui initialize x, y, et z possède également des accesseurs getX, getY et getZ qui retournent x, y et z)

s'utilise de la manière suivante :
Code:

1 2 3 4 Matrice matrice; Vecteur vecteur; Vecteur vecteur_resultat = matrice * vecteur;
Elle est déclarée et définie en dehors d'une quelconque classe. Le mieux est quand même de la définir dans un namespace.

Flo.

06/04/2011, 14h38
fab87

Très bien je vous remercie beaucoup, donc je peux la déclarer dans une classe quelconque c'est bien cela?

Le hic est que le compilateur me dit que la fonction ne peut avoir que 0 ou 1 argument... C'est logique vu que c'est une fonction de surcharge d'opérateur.
C'était à mon soucis :/
06/04/2011, 14h53
Flo.
Non !

La fonction dont je te parle dans mon précédent post est une fonction libre. Tu la déclares comme une fonction libre, n'appartenant à aucune classe. Elle flotte dans l'air tel un papillon virevoltant dans les airs.

Comme dans mon exemple précédent :
Code:

1 2 3 4 5 6 7 8 9 10 11 class Matrice { }; class Vecteur : public Matrice { }; Matrice operator * (const Vecteur & vect, const Matrice & mat) { }
http://en.wikipedia.org/wiki/Operators_in_C_and_C%2B%2B

Flo.
06/04/2011, 14h54
fab87

Oui mais concrètement je la déclare où?!
06/04/2011, 14h59
fab87

Vecteur vecteur_resultat = matrice * vecteur;

Le compilateur me dit aussi qu'il faut que je surcharge l'opérateur '='
06/04/2011, 15h09
fab87

De plus je ne sais pas comment on définit une fonction dans un namespace.
Please!!

Je dois mal m'exprimer. Ou alors je suis à côté de la plaque.

Par exemple

Matrice.h

Code:

1
2
3
4
5
6
7
8
9
10
11
#ifndef MATRICE_H
#define MATRICE_H
 
namespace MySpace
{
     class Matrice
     {
     };
}
 
#endif // MATRICE_H

Vecteur.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
#ifndef VECTEUR_H
#define VECTEUR_H
 
#include "Matrice.h"
 
namespace MySpace
{
     class Vecteur : public Matrice
     {
     };
}
 
#endif // VECTEUR_H

Operations.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#ifndef OPERATIONS_H
#define OPERATIONS_H
 
#include "Matrice.h"
#include "Vecteur.h"
 
namespace MySpace
{
     Matrice operator * (const Vecteur & vect, const Matrice & mat)
     {
     }
}
 
#endif // OPERATIONS_H

main.cpp

Code:

1
2
3
4
5
6
7
8
9
10
#include "Matrice.h"
#include "Vecteur.h"
#include "Operations.h"
 
int main()
{
     MySpace::Matrice matrice;
     MySpace::Vecteur vecteur;
     MySpace::Vecteur vecteur_resultat = matrice * vecteur;
}

Flo.

06/04/2011, 15h45
fab87

Très bizarre cette implémentation.
N'y a t-il pas une autre solution?
06/04/2011, 20h50
gl

Citation:

Envoyé par fab87

Très bizarre cette implémentation.

Pourquoi ?
07/04/2011, 10h43
fab87

Parce qu'on est obligé de mettre myspace à chaque fois... c'est redondant.

Si ce n'est que ça, tu peux faire comme ça :

Code:

1
2
3
4
5
6
7
8
9
10
11
#include "Matrice.h"
#include "Vecteur.h"
#include "Operations.h"
 
int main()
{
     using namespace MySpace;
     Matrice matrice;
     Vecteur vecteur;
     Vecteur vecteur_resultat = matrice * vecteur;
}

Flo.

Voir 40 message(s) de cette discussion en une page