Discussion :

[deubelte]

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
class Matrice
{
Matrice(int largeur, int hauteur);
public:
Matrice():maLargeur(0),maHauteur(0){}
int maLargeur;
int maHauteur;
 
};
 
Matrice::Matrice(int largeur, int hauteur):maLargeur(largeur),maHauteur(hauteur){} 
 
int main()
{
 Matrice M;
 M.maHauteur=10;
 M.maLargeur=20;
 
}

J'ai une petite question: quelle est la différence
entre:

Code :

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

Matrice(int largeur, int hauteur);

et

Code :

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

Matrice():maLargeur(0),maHauteur(0){}

Pour moi, c'est le constructeur par défaut, mais pourquoi on ne peut pas
le mettre a l'extérieur du corps de la classe, comme l'autre constructeur?
Merci

[jmv]

hello,
3 remarques sur ta matrice :
Où sont stockées les données ? je suppose que ta classe n'est pas finie.
Ton premier constructeur n'est pas en "public" !!! pourquoi ?
Les attributs sont en "public", c'est à éviter.

Pour répondre à ta question tu peux trés bien définir les 2 constructeurs (ou n'importe quelle autre méthode) à l'intérieure (dans le .h) ou à l'extérieure de la déclaration de la clesse (dans le .cpp).
Pour des méthodes très courtes, on préfère le faire à l'intérieur, ce qui rendra la méthode "inline". Pour les méthodes dont le code est assez long, on préfère le faire à l'extérieur.

[Laurent Gomila]

ce qui rendra la méthode "online"

Pratique, on peut l'appeler depuis internet

[jmv]

oups je corrige

[deubelte]

Pour des méthodes très courtes, on préfère le faire à l'intérieur, ce qui rendra la méthode "inline"

qu'est ce que cela signifie qu'une methode ou fonction soit inline?merci

[Pierre.M]

Salut,

Avec une fonction inline le code de la fonction est directement inséré dans le code principal au moment de l'appel (comme pour la directive #include par exemple). Ca permet un accès direct (sans passer par des branchements) et normalement plus rapide au traitement de la fonction en question.

http://cpp.developpez.com/faq/cpp/?page=inline

[Emmanuel Deloget]

que pensez vous de ma classe Matrice?

Code :

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

1
2
3
4
5
6
7
8
9
class Matrice
{
Matrice(int largeur, int hauteur);
public:
Matrice():maLargeur(0),maHauteur(0){}
int maLargeur;
int maHauteur;
 
};

Sans vouloir être cruel: que du mal. Sans compter que ce n'est qu'une classe vide pour l'instant.
Mais réécrivons le peu qui existe:

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
 
class matrice 
{
// les données sont privée - ce n'est pas une bonne idée de les 
// mettre publiques - n'importe qui pourrait les modifier de l'extérieur.
private:
    // 1) unsigned car les dimensions sont toujours positive
    // autant éviter les problèmes à la source.
    // 2) une matrice est fait de N lignes de P colonnes. 
    // elle n'a pas de hauteur ni de largeur (c'est une vue 
    // de l'esprit). On ne parle jamais de matrice de 
    // largeur L... 
    // m_ pour signifier "membre". C'est facultatif. un prefixe
    // "ma" fonctionne très bien aussi. 
    unsigned int m_colonnes;
    unsigned int m_lignes;
public:
    // les constructeurs sont publics tous les deux
    // vu leur complexité, on préfère les spécifier (=définir)
    // entièrement au moment de leur déclaration. 
    matrice() : m_colonnes(0), m_lignes(0) { }
    matrice(unsigned int cols, unsigned int lignes) : 
        m_colonnes(cols), m_lignes(lignes)
    { }
};

Mais dans l'idée, il est encore mieux de passer par des templates que par une classe dont les arguments sont dynamiques. On peut ainsi vérifier des règles mathématiques complexes au moment de la compilation, et non pas à l'exécution (donc un certain nombre de bugs ne peuvent plus se produire). Cependant, les templates sont peut être un concept un peu trop avancé pour toi pour le moment.

[deubelte]

Merci pour les infos

// les constructeurs sont publics tous les deux
// vu leur complexité, on préfère les spécifier (=définir)
// entièrement au moment de leur déclaration

Qu'est ce que cela change?

Ensuite, voici ce que j'ai fait:

Code :

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

1
2
3
4
 
double &Matrice::operator()(int x, int y)
{  return mesDonnees[x + largeur * y];
}

Apres plusieurs essais, j'ai vu quil fallait mettre un & devant Matrice. Je ne comprends pas pourquoi il faut mettre un &. Cela voudrait dire que quand on fait M(1,1)=2 par exemple, M est un pointeur si je ne m'abuse pas.

[Bakura]

Qu'est ce que cela change?

En déclarant directement le corps des fonctions dans la déclaration de la classe tu as plus de chance qu'elles soient mis en ligne (inline).

Apres plusieurs essais, j'ai vu quil fallait mettre un & devant Matrice. Je ne comprends pas pourquoi il faut mettre un &. Cela voudrait dire que quand on fait M(1,1)=2 par exemple, M est un pointeur si je ne m'abuse pas.

Le & signifie que tu renvois la valeur (un double) en tant que référence. Renvoyer par référence permet (comme avec les pointeurs), d'éviter de copier l'objet. Toutefois, avec des doubles, c'est pas la peine d'utiliser des références, tu peux effectuer directement une copie de l'objet (donc enlever le &). D'ailleurs, tu devrais renvoyer une référence constante. Si je me souviens bien (ça fait longtemps que j'ai pas fait du C++ pur :d), si tu modifies la variable de retour (donc une référence), tu vas également modifier la valeur contenue dans ta classe.

Par exemple, si on utilises ton code, et que tu récupères la valeur comme ceci :

double & val = maMatrice (1, 1); // Ici, val == 1.0 par ex
val = ++val; // val == 2.0

Et bien tu auras implicitement changé la valeur de maMatrice(1,1). Alors que avec la copie, seul val vaudra 2, mais pas la valeur contenue dans la classe.

[stillman]

L'opérateur d'indexation peut/doit aussi permettre de modifier le contenu de la matrice ! Il convient en général d'écrire deux surcharges de l'opérateur d'indexation : un en lecture, qui renvoie par valeur ou par référence constante, et qui est const, et un autre en écriture, qui renvoie une référence. Mais tout ceci est expliqué plus en détail dans la FAQ.