inline en c++

[mimi-mimi1]

Bonjour,
j'ai le programme suivant qui défini une classe de matrice, mais je ne comprend pas l'utilisation de inline. À quoi sert "inline" exactement, et quelle est la syntaxe générale?
Voici le programme en question

#include <vector>
#include <ostream>
#include <iostream>

// Définition d'une matrice
template <typename T>
class matrix_t{
    protected:
        std::size_t nb_ligne;
        std::size_t nb_colonne;
        std::vector<std::vector<T> > data;

    public:
        matrix_t(
            const std::size_t & nb_ligne0 = 1,
            const std::size_t & nb_colonne0 = 1
        ):
            nb_ligne(nb_ligne0),
            nb_colonne(nb_colonne0)
        {
            data.resize(nb_ligne);
            for(std::size_t i=0;i<nb_ligne;++i){
                data[i].resize(nb_colonne);
            }
        }

        inline void set(
            const std::size_t & i,
            const std::size_t & j,
            const T & x
        ){
            if(i >= get_nb_ligne()) throw;
            if(j >= get_nb_colonne()) throw;
            data[i][j] = x;
        }

        inline std::vector<T> & operator[](
            const std::size_t & i
        ){
            return data[i];
        }

        inline const std::vector<T> & operator[](
            const std::size_t & i
        ) const {
            return data[i];
        }

        inline std::size_t get_nb_ligne() const{
            return nb_ligne;
        }

        inline std::size_t get_nb_colonne() const{
            return nb_colonne;
        }
};

// Opérateur d'affichage d'une matrice
template <typename T>
std::ostream & operator<<(std::ostream & out,const matrix_t<T> & m){
    const std::size_t &
        nb_lig = m.get_nb_ligne(),
        nb_col = m.get_nb_colonne();
    for(std::size_t i=0;i<nb_lig;++i){
        for(std::size_t j=0;j<nb_col;++j){
            out << m[i][j] << '\t';
        }
        out << std::endl;
    }
    return out;
}

// L'addition des matrices
template <typename T1,typename T2>
matrix_t<T1> operator+(
    const matrix_t<T1> & m1,
    const matrix_t<T2> & m2
){
    // vérifier que les deux matrices peuvent être sommées
    const std::size_t &
        nb_lig1 = m1.get_nb_ligne(),
        nb_col1 = m1.get_nb_colonne(),
        nb_lig2 = m2.get_nb_ligne(),
        nb_col2 = m2.get_nb_colonne();
    if(nb_lig1 != nb_lig2 || nb_col1 != nb_col2) throw;

    matrix_t<T1> m(nb_lig1,nb_col1);

    // Aij = Bij + Cij
    for(std::size_t i=0;i<nb_lig1;++i){
        for(std::size_t j=0;j<nb_col1;++j){
            m[i][j] = m1[i][j] + m2[i][j];
        }
    }
    return m;
}

// Le produit des matrices
template <typename T1,typename T2>
matrix_t<T1> operator*(
    const matrix_t<T1> & m1,
    const matrix_t<T2> & m2
){
    // vérifier que les deux matrices peuvent être multipliées
    const std::size_t &
        nb_lig1 = m1.get_nb_ligne(),
        nb_col1 = m1.get_nb_colonne(),
        nb_lig2 = m2.get_nb_ligne(),
        nb_col2 = m2.get_nb_colonne();
    if(nb_col1 != nb_lig2) throw;
    matrix_t<T1> m(nb_lig1,nb_col2);

    // Aik = sum_j(Bij * Cjk)
    for(std::size_t i=0;i<nb_lig1;++i){
        for(std::size_t k=0;k<nb_col2;++k){
            for(std::size_t j=0;j<nb_col1;++j){
                m[i][k] += m1[i][j] * m2[j][k];
            }
        }
    }
    return m;
}

Je vous remercie par avance.
-----

[pm42]

Puis je faire remarquer que tu as demandé la différence entre private et protected, à quoi sert inline, static, la signification de chaque message d'erreur dans tes programmes ?

Lire un livre sur le langage, faire des recherches sur le Net serait une bonne idée parfois...

[mimi-mimi1]

Dans le luivre (t&éléchargé sur classroom) ils ne parlent pas de inline, merci de m'expliquer pour qui sait.
Cordialement

[pm42]

Dans le luivre (t&éléchargé sur classroom) ils ne parlent pas de inline, merci de m'expliquer pour qui sait.

Il y a un seul livre sur le C++ et quand on tape "c++ inline" dans Google, ça ne répond pas ?
Ils ne parlaient pas non plus de private et protected dans le livre ? Ni de static ?

En fait, c'est un livre de cuisine, pas de programmation en C++ apparemment.

[A voir en vidéo sur Futura]

[mp3dux]

Bonjour,
j'ai le programme suivant qui défini une classe de matrice, mais je ne comprend pas l'utilisation de inline. À quoi sert "inline" exactement, et quelle est la syntaxe générale?

Je vous remercie par avance.

"Quand le compilateur évalue l'appel d'une fonction inline, le code complet de cette fonction est inséré dans le code de l'appelant (c'est le même principe que ce qui se passe avec un #define). Cela peut, parmi beaucoup d'autres choses, améliorer les performances, étant donné que l'optimiseur peut intégrer directement le code appelé, voire optimiser le code appelé en fonction du code appelant."

http://cpp.developpez.com/faq/cpp/?p...nctions-inline

[Jack]

Puis je faire remarquer que tu as demandé la différence entre private et protected, à quoi sert inline, static, la signification de chaque message d'erreur dans tes programmes ?

Lire un livre sur le langage, faire des recherches sur le Net serait une bonne idée parfois...

C'est énervant, hein?
Et pourtant ce n'est pas faute de lui avoir fourni des références pour obtenir des réponses, notamment sur la FAQ de developpez dans ce (très long) fil, alors que mimi-mimi1 s'appelait hinanehinane (ou alors le mimétisme est frappant et les adresses IP aussi):
http://forums.futura-sciences.com/pr...ecteurs-c.html

Non respect de la charte (que j'ai signalé aux responsables du site en passant), prise des participants du forum pour des poires, ma blacklist a été incrémentée d'une unité.

[pm42]

C'est énervant, hein?

Grand moment de fainéantise et de refus d'apprendre en tout cas. J'ai beaucoup aimé le "ce n'est pas dans mon livre" à l'époque d'Internet.

[mimi-mimi1]

pardon mais je ne suis pas hinanehinane, peut être que cet utilisateur a utilisé le même poste que moi. Je n'ai pris personne pour une poire et je demande au modérateur de supprimer mon poste puisqu'il gêne autant de monde.

[Jack]

pardon mais je ne suis pas hinanehinane, peut être que cet utilisateur a utilisé le même poste que moi.

Admettons.

Je reste toutefois extrêmement surpris par des questions demandant d'expliquer à quoi correspond "inline" par exemple, puisque n'importe quel document un peu sérieux sur C++en donne la signification en tapant deux mots clé tels que "C++ inline".
Le premier lien proposé par mon google par exemple pointe d'ailleurs sur la faq de developpez dont j'ai parlé dans mon message précédent:
http://cpp.developpez.com/faq/cpp/?p...nctions-inline

[mimi-mimi1]

ma question vient du fait qu'ils utilisent lesinline pour définir les constructeurs d'une matrices, or que je n'ai pas l'habitude de les utiliser pour ca. Quand je lis la doc, je trouve des fonctions inline, mais la syntaxe générale pour les utiliser afin de définir des constructeur pour une matrice, non, surtout qu'ils mettent en avant la relation avec definie, et je ne l'utilise même pas lui aussi pour définir un constructeur. D'où la question que j'avais posé à mon premier post. Peut être que c'est de ma faute que je me suis mal exprimée.

[pm42]

ma question vient du fait qu'ils utilisent lesinline pour définir les constructeurs d'une matrices, or que je n'ai pas l'habitude de les utiliser pour ca..

Ah bon ? Où ça ? J'ai vu un seul constructeur et il n'est pas inline...

[Jack]

Quand je lis la doc, je trouve des fonctions inline, mais la syntaxe générale pour les utiliser afin de définir des constructeur pour une matrice, non

Au niveau syntaxique, je ne vois pas trop où est le problème puisqu'il suffit de définir la fonction comme n'importe quelle fonction et d'ajouter inline devant

[mimi-mimi1]

Par exemple, dans

inline void set( const std::size_t & i,  const std::size_t & j, const T & x  )
       {
            if(i >= get_nb_ligne()) throw;
            if(j >= get_nb_colonne()) throw;
            data[i][j] = x;
        }

elle sert à quoi?
2- Il y'a les deux:

inline std::vector<T> & operator[](
            const std::size_t & i
        ){
            return data[i];
        }

et

        inline const std::vector<T> & operator[](
            const std::size_t & i
        ) const {
            return data[i];
        }

ils servent à la même chose: définir l'opérateur [], alors pourquoi on mettre deux? une constante et l'autre pas, et pourquoi mettre std:: devant vector<T>?

3- Quant à ce bout

 matrix_t(
            const std::size_t & nb_ligne0 = 1,
            const std::size_t & nb_colonne0 = 1
        ):
            nb_ligne(nb_ligne0),
            nb_colonne(nb_colonne0)
        {
            data.resize(nb_ligne);
            for(std::size_t i=0;i<nb_ligne;++i){
                data[i].resize(nb_colonne);
            }
        }

Je ne comprend pas à quoi il sert.

[pm42]

Rien de tout cela n'est un constructeur. Dans tout cela, le inline a exactement la fonction décrite plus haut et tu confonds avec const...

Bref, on en revient au même point : lire des choses sur le langage pour apprendre au lieu de poser question après question sans faire le moindre effort ce qui fait que tu n'apprends rien et que tu appelles "constructeur" des "opérateurs" entre autres.

[Jack]

ils servent à la même chose: définir l'opérateur [], alors pourquoi on mettre deux? une constante et l'autre pas

Ca va dépendre de la manière dont tu vas appeler l'opérateur []

et pourquoi mettre std:: devant vector<T>?

Je suis à nouveau étonné que l'on te demande ce genre d'exercice sans connaitre les fondamentaux du C++: la classe vector fait partie de la STL et appartient donc à l'espace de nom std.

[mimi-mimi1]

Jack, donc puisqu'il n'y a pas de constructeur, comment définir une classe sans constructeur? C'est cela qui m'étonne. (pour la std::vector<T>, merci de me le rappeller, on est entrain d'utiliser la classe vector, donc on l'appelle par std:.
2- Peux-tu expliciter "cela dépend de la manière dont tu vas appeller []?)
Merci beaucoup.

[Jack]

Jack, donc puisqu'il n'y a pas de constructeur, comment définir une classe sans constructeur?

Qui a dit qu'il n'y avait pas de constructeur?

(pour la std::vector<T>, merci de me le rappeller, on est entrain d'utiliser la classe vector, donc on l'appelle par std:

Tu as déjà dû utiliser cout pour afficher sur ta console. C'est la même chose, cout s'utilise dans l'espace de nom std, donc std::cout

[mimi-mimi1]

ou, j'ai l'habitude d'utiliser std:: cout<<...., mais quand je met "using namespace std", je n'ai plus besoin de cout.
Bon, jpar contre, je n'arrive vraiment pas à déchiffré ce bout

 matrix_t(
            const std::size_t & nb_ligne0 = 1,
            const std::size_t & nb_colonne0 = 1
        ):
            nb_ligne(nb_ligne0),
            nb_colonne(nb_colonne0)
        {
            data.resize(nb_ligne);
            for(std::size_t i=0;i<nb_ligne;++i){
                data[i].resize(nb_colonne);
            }
        }

ca doit être lui le constructeur, mais comment est-il définie?
Merci beaucoup

[Jack]

ou, j'ai l'habitude d'utiliser std:: cout<<...., mais quand je met "using namespace std", je n'ai plus besoin de cout.

Il faut éviter "using namespace std" dans l'écriture d'une classe afin d'éviter les problème en cas d'utilisation de celle-ci dans un autre espace de nom.

ca doit être lui le constructeur

Par définition, une fonction non typée avec le même nom que celui de la classe est un constructeur.

mais comment est-il définie?

Qu'est-ce que tu ne comprends pas?

[mimi-mimi1]

            const std::size_t & nb_ligne0 = 1,
            const std::size_t & nb_colonne0 = 1

c'est donc pour initialiser le nombre de lignes et le nombre de colonnes à 1, ca c'est argument, mais dans un constructeur, on ne commence pas l'initialisation avec les arguments à l'interieur des parenthèses, non?
en suite, il y'a deux points et

 nb_ligne(nb_ligne0),
 nb_colonne(nb_colonne0)

ca sert à quoi?
puis entre les accolades, il y'a

data.resize(nb_ligne);
 for(std::size_t i=0;i<nb_ligne;++i){
  data[i].resize(nb_colonne);

qui est data et qui est resize et que fait la boucle for?
Merci beaucoup.

[Jack]

c'est donc pour initialiser le nombre de lignes et le nombre de colonnes à 1, ca c'est argument, mais dans un constructeur, on ne commence pas l'initialisation avec les arguments à l'interieur des parenthèses, non?
en suite, il y'a deux points et
Code:

nb_ligne(nb_ligne0), nb_colonne(nb_colonne0)
ca sert à quoi?

C'est une liste d'initialisation (voir FAQ C++)

qui est data

Observe attentivement la déclaration de ta classe.

et qui est resize

Pose-toi la question de l'objet auquel s'applique la méthode resize et tu sauras où chercher.

et que fait la boucle for?

C'est assez trivial, je te laisse un peu chercher.

[Paraboloide_Hyperbolique]

Bonsoir,

mimi-mimi1: je suis très étonné des questions que vous posez. J'ai l'impression que vous essayez de comprendre du code sans avoir les bases nécessaires (est-ce que je me trompe ?)

Vous devriez savoir de quel type est la variable "data". C'est écrit noir sur blanc dans votre code.
Vous devriez savoir aussi savoir ce qu'est un std::vector, quelles sont ses principales fonctions membres et ce qu'elles font (sinon renseignez-vous, la documentation sur la STL est très bien fournie.)

Renseignez-vous aussi sur la manière dont on construit une classe C++ (comment on défini les constructeurs, le destructeur, les variables et fonctions membres).

Une fois tout cela fait, vous pourrez alors revenir et comprendre sereinement votre code.

[pm42]

C'est assez trivial, je te laisse un peu chercher.

Tu pourrais juste faire un copier/coller de cette phrase dans toutes tes réponses tu sais ?

[mimi-mimi1]

et bien je sais construire une classe, il nous faut un constructeur avec argument, et un destructeur, mais là le code utilisé ne m'est pas familié, la façon dont ils ont défini le constructeur ne m'est pas familière, j'essaye donc de comprendre ce qu'ils font.

 matrix_t(const std::size_t & nb_ligne0 = 1,const std::size_t & nb_colonne0 = 1):
            nb_ligne(nb_ligne0),
            nb_colonne(nb_colonne0)

il comment à définir un constructeur avec arguments, ce constructeur à deux paramètres: le nombre de ligne et le nombre de colonnes qu sont initialisés à 1 (entre parenthèse),
puis on déclare deux paramètres nb_ligne(nb_ligne0), nb_colonne(nb_colonne0), celà veut dire que la valeur initiale de nb_ligne c'est nb_ligne0,
Après ca, il y'a

 data.resize(nb_ligne);
            for(std::size_t i=0;i<nb_ligne;++i)
              {
                data[i].resize(nb_colonne);
              }

data est un vecteur de la classe vector, pour data.resize(nb_ligne) il n'y a pas son type. La boucle for me fait penser à un constructeur de copie, mais cette syntaxe ne me dit rien, je n'y comprend rien. ...

[Jack]

pour data.resize(nb_ligne) il n'y a pas son type

???? Je ne comprends pas ce que tu veux dire ...

La boucle for me fait penser à un constructeur de copie, mais cette syntaxe ne me dit rien, je n'y comprend rien. ...

La matrice étant sensée contenir des éléments, le constructeur commence par réserver la place suffisante pour les stocker.

[mimi-mimi1]

c'est l'expression data.resize(nb_ligne); que je ne comprend pas. data est un vecteur oui, mais .resize(nb_ligne); je n'arrive pas à comprendre ce que ca signifie.

[Jack]

RTFM!

http://www.cplusplus.com/reference/vector/vector/resize/

http://fr.cppreference.com/w/cpp/con.../vector/resize

etc, etc, etc.

[mimi-mimi1]

Donc l'expression que j'essaie d'identifier est le constructeur avec paramètres de la classe. Ma question est: pourquoi il n'y a pas de constructeur de copie et un destructeur?
Merci beaucoup.

[Paraboloide_Hyperbolique]

Bonjour,

Il sont bien présents, mais implicitement. S'ils ne sont pas codés explicitement, le compilateur les génère implicitement.

[mimi-mimi1]

D'accord, alors ce n'est pas vrai, il n'est pas obligatoire de toujours définir les constructeurs de copie et le destructeur, le compilateur peut les générer lu même? Par exemple, dès que l'on fait une somme, il fait appel tout seul à un constructeur de copie, et dès qu'il fini de créer une variable, il libère l'espace alloué tout seul, sans qu'on le lui indique? C'est ca?