IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

C++ Discussion :

Questions en vrac: librairie std,objet cout.


Sujet :

C++

  1. #21
    Membre émérite
    Avatar de prgasp77
    Homme Profil pro
    Ingénieur en systèmes embarqués
    Inscrit en
    Juin 2004
    Messages
    1 306
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 36
    Localisation : France, Eure (Haute Normandie)

    Informations professionnelles :
    Activité : Ingénieur en systèmes embarqués
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Juin 2004
    Messages : 1 306
    Points : 2 466
    Points
    2 466
    Par défaut
    Voici ma version.
    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
    #include <iostream>
     
    int main()
    {
        int data[6] = {5,18,2,8,3,3};
        const size_t lData = sizeof(data) / sizeof(int);
     
        // Naive insertion sort for data
        for (size_t i = 1 ; i < lData ; ++i) {
            // Here, data[0..i-1] is sorted, we insert data[i] so data[0..i] is sorted.
            size_t inserted_item_index = i;
            while (data[inserted_item_index] < data[inserted_item_index-1] && inserted_item_index > 0) {
                std::swap(data[inserted_item_index], data[inserted_item_index-1]);
                --inserted_item_index;
            }
        }
     
        // Print results
        for (size_t i = 0 ; i < lData ; ++i) {
            std::cout << "data[" << i << "] = " << data[i] << std::endl;
        }
     
        return 0;
    }
    Il est possible d'améliorer cette implémentation en insérant les éléments par dichotomie ; je te propose cette amélioration comme exercice.

    En attendant, quelques remarques / suggestions :
    • Cosmétique
      • Rester cohérent dans tes choix de convention de codage (tu mets des fois un espace avant le ';' final, des foins non) (pareil pour tes '=').
      • Il y a plusieurs façon acceptable de placer ses accolades : en voici deux qui se vallent :
        Code : Sélectionner tout - Visualiser dans une fenêtre à part
        1
        2
        3
        if (condition) {
        	expression;
        }
        Code : Sélectionner tout - Visualiser dans une fenêtre à part
        1
        2
        3
        4
        if (condition)
        {
        	expression;
        }
      • En C++, on se retrouve souvent avec de grands niveaux d'indentation dans les fichiers en-tête (une pour l'espace de nom, une pour la classe, une pour la fonction, une pour une condition, ...) ; il est donc assez commun de définir la largeur d'une tabulation à 4 ou 3 caractères ou d'indenter avec 4 ou 3 espaces. Merci de ne pas s'enflammer avec des tabs/space ici ; n'oubliez pas que l'important ce n'est pas la convention de codage mais son respect par tous les contributeurs.
      • Rester très concis dans ses commentaires. Commenter c'est bien, mais cela doit être limité : un code bien écrit n'a pas besoin d'être commenté ; les commentaires ne servent alors qu'à présenter ce qui va être fait dans le prochain bloc de code/fonction ou pour expliquer un passage particulièrement tricky.
    • Code
      • Par défaut, déclarer tes variables constantes ; si tu as besoin qu'elles varient, enlever le const.
      • Ne pas créer de variable (non constante) inutile. Par exemple cle dans ton code.
      • Ne déclarer une variable qu'au dernier moment : juste avant son utilisation. De préférence, l'initialiser avec une valeur.
      • Préférer les opérateurs préfixe aux postfixe (++i au lieu de i++) (pour savoir pourquoi, intéresse toi à la surcharge de ces opérateurs).
      • Utiliser un maximum les outils proposés par la bibliothèque standard (comme std::swap).
      • Éviter les using namespace, éventuellement un petit using std::cout; dans le corps d'une fonction peut apporter le même confort avec moins de risque et de portée.


    Cordialement,
    -- Yankel Scialom

  2. #22
    Membre régulier
    Homme Profil pro
    Cocher moderne
    Inscrit en
    Septembre 2006
    Messages
    50
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 45
    Localisation : Oman

    Informations professionnelles :
    Activité : Cocher moderne

    Informations forums :
    Inscription : Septembre 2006
    Messages : 50
    Points : 118
    Points
    118
    Par défaut
    Salut,

    Citation Envoyé par dfshr8 Voir le message
    Est ce que la manière dont je code est correcte (indentation,...)
    J'ai envie de dire non. On essaye d'aligner l'accolade fermante avec la boucle/condition qui ouvre le bloc: ça nous donne deux possibilités

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    while(une_condition)
    {
       instruction1;
       instruction2;
       //...
    }
    ou

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    while(une_condition){
       instruction1;
       instruction2;
       //...
    }
    Cela permet de mieux visualiser les blocs de code.

    b) il y a pas mal d'erreurs de compilation mais je ne les voit pas:
    Elles découlent toutes de la première erreur que ton compilateur a trouvé, à la ligne 12 comme il l'indique :
    tri_ins.cpp:12:30: error: expected ‘;’ before ‘)’ token
    Il attend un point virgule. Parce qu'effectivement tu as mis par erreur des virgules dans les paranthèses de ta boucle "for".

    Bonne soirée!

  3. #23
    Membre à l'essai
    Profil pro
    Inscrit en
    Novembre 2011
    Messages
    104
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Novembre 2011
    Messages : 104
    Points : 23
    Points
    23
    Par défaut
    Merci beaucoup et désolé pour la réponse super tardive (je n'avais pas vu qu'il y avait deux pages et je commencais à désespérer de voir une réponse ^^). Du coup j'avais modifié l'ereur dû au point virgule... mais mri pour les corrections!!

    12)Entretemps j'ai une petite question:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    Matrice multiplication(const Matrice& Mat1,const Matrice& Mat2);
    Je ne comprends pas l'interet de déclarer du "const" dans les arguments d'une fonction ?? Qu'est ce que ça fait, quel est l'interêt ?

    13) Pourquoi utiliser && plutôt que le "and" qui est plus facile à se souvenir ? (De même le "or" et "not" dont je ne me rappel même pas les équivalents avec les symboles)

    14) Dans le cours C++ que je suis (inspiré du livre d'exo de Chappelier: "C++ par la pratique" tous les exos onsistent à écrire un main et dans ce même programme/fihier texte définir toutes les fonctions et prototypes. Etant donné que ce sont des exos simples j'imagine que l'auteur préfère éviter les fichier .h et éviter de réer un fichier texte par fonction!! Mais qu'en pensez vous ? Réalisez vous un fichier par fonction, même si celle ci est très simple ?

  4. #24
    Expert éminent sénior
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Février 2005
    Messages
    5 059
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 52
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Conseil

    Informations forums :
    Inscription : Février 2005
    Messages : 5 059
    Points : 12 095
    Points
    12 095
    Par défaut
    12- Le fait de certifier à l'appelant d'une méthode que l'objet que vous passez en paramètre ne sera pas modifier permet de multiple chose.
    Par exemple :
    - si l'appelant a besoin que les valeurs ne changent pas entre 2 points de son code pour qu'il reste correct, avec des méthodes qui certifient cela, il n'aura pas à cloner l'objet pour s'en servir plus tard.
    - du code qui ne veut pas que du code extérieur à une classe puisse modifier un de ses champs peut très bien retourner une référence constante sur son champs interne, mais en le marquant comme const, cela interdit au code récupérant cette référence de la passer en paramètre de méthodes qui ne certifient pas qu'elles ne modifient ce paramètre
    etc...
    En résumé, toujours mettre const, toujours.
    Sauf la sémantique de la méthode implique de modifier l'objet.
    Cette pratique permet d'avoir du code bien plus simple à maintenir car le code capable de rendre un champ invalide devient très petit, quand on cherche a savoir quel bout de code l'a mis à une valeur invalide.

    13- le && est une notation "historique" qui vient du C et qui est commune à quasiment tous les langages qui en découle, donc à plus de 90% du code écrit actuellement.
    historiquement, parser des caractères spéciaux étaient bien plus facile que de détecter un mot clé.
    En ayant une "forme" particulière, les expressions booléens sont très facile à repérer, bien plus qu'avec de and ou des or, qui se noient dans la masse du code.
    Et avec l'habitude, c'est de plus en plus frappant.
    Donc, plus on est expérimenté plus on utilise && et || et moins on utilise les mots clé "and" et "or", qui on été introduit qu'assez récemment, qui ne sont utilisés que par les programmeurs peu expérimentés, ne connaissant que peu d'autres langages et n’ayant pas encore les systèmes de reconnaissances d'expressions booléennes très affutées.
    Cela permet aussi d'avoir une certaine cohérence entre les expressions booléennes et les opérations sur les bits.

    14- Non, il ne faut pas faire un fichier .h par fonction.
    Il faut faire un fichier .h par "module" indépendant.
    Avoir 100 .h et être obligé d'inclure les 100 parce que, pour en utiliser 1, il faut inclure tous les autres, c'est débile.
    Comme le fait de concevoir des modules indépendants est quelque chose de pas simple, je suis plutôt d'accord avec l'approche.

  5. #25
    Expert éminent sénior

    Femme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Juin 2007
    Messages
    5 186
    Détails du profil
    Informations personnelles :
    Sexe : Femme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Juin 2007
    Messages : 5 186
    Points : 17 126
    Points
    17 126
    Par défaut
    12) En C++, parmi nos expressions favorites (au moins ici), il y a référence constante et personnellement, je précise toujours référence modifiante
    Le langage définit const comme s'appliquant au type situé à sa gauche, sauf s'il est écrit complètement à gauche de la déclaration.
    Ainsi, const Matrice & Mat1 signifie la même chose que Matrice const & Mat1.

    Comme de plus, les blancs ne comptent pas si le compilateur n'a pas d'autre choix que de séparer les mots, on peut aussi écrire Matrice const& Mat1.

    Et là, magiquement, le mot référence constante est écrit: const&.

    Aussi, j'aurai personnellement déclaré la fonction autrement:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    Matrice multiplication(Matrice const& Mat1, Matrice const& Mat2);
    L'intérêt est assez mineur dans ce cas, mais imagine plutot les deux écritures suivantes de la même fonction:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    std::vector<std::pair<int, int>> merge(const std::vector<std::pair<int, int>>&, const std::vector<std::pair<int, int>> &);
    std::vector<std::pair<int, int>> merge(std::vector<std::pair<int, int>> const&, std::vector<std::pair<int, int>> const&);
    Laquelle des deux versions te semble plus lisible?


    Il faut aussi comprendre la raison de la référence constante.

    Un objet peut être assez gros, donc long à copier, voire même ne pas être copiable.

    Tout argument d'une fonction est donné par copie.
    En fait, par initialisation d'une variable.

    Et une référence est triviale à initialiser, exactement comme un pointeur. Ca ne coute pas plus cher que d'initialiser un int avec une valeur donnée.

    Ainsi, définir un paramètre de fonction comme référence permet d'éviter le coût du constructeur de copie.
    Mais vient un second soucis, on ne veut pas forcément modifier une variable, et surtout, on veut pouvoir transmettre une constante à une fonction.

    par exemple, une fonction qui prend un complexe et un vecteur et retourne le complexe "au bout" du vecteur serait:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    complexe operator+(complexe c, vecteur v) {return c += v;}
    C'est même la manière canonique d'écrire un tel opérateur (aux références près).
    Sauf que la, il y a deux copie de complexe (une en entrée, et une en sortie), et une du vecteur.

    Si on prend des références modifiantes, on obtient
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    complexe operator+(complexe & c, vecteur & v) {return c += v;}
    Et là, on a certes une copie de complexe en sortie, mais surtout, on modifie c, le complexe en entrée, ce qu'on ne voulait pas.

    Du coup, il faut des références constantes.
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    complexe operator+(complexe const & c, vecteur const& v) {return complexe(c) += v;}
    Ainsi, on n'a plus de copie de vecteur du tout, et plus qu'une seule copie de complexe.
    La seconde copie est en générale supprimée par les compilateurs, car ils créent la copie locale ([c]complexe(c)) directement dans la variable qui recevra la valeur de retour de la fonction. (RVO: return value optimisation)
    Et surtout, tu ne modifies pas les valeurs transmises en arguments

    Les références modifiantes référant toujours sur une variable, l'instruction complexe c = complexe(0,0) + vector(1, 4); n'est pas valide avec la seconde version, car complexe(0,0) et vector(1,4) ne sont pas des variables, mais des valeurs temporaires.
    Avec des références constantes, c'est possible.

    Tu pourrais déclarer la fonction ainsi:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    complexe operator+(complexe const c, vecteur const v) {return complexe(c) += v;}
    .
    Mais comme les arguments sont constant, il faut créer une copie locale (et non constante) de c pour pouvoir appeler +=.
    Et du coup, tu paies trois copie de complexe: une en appelant la fonction, une pour créer la valeur temporaire, et une en sortie (sauf RVO).

    En fait, ce n'est pas const qui nous importe vraiment dans l'argument, mais const&.
    Mes principes de bases du codeur qui veut pouvoir dormir:
    • Une variable de moins est une source d'erreur en moins.
    • Un pointeur de moins est une montagne d'erreurs en moins.
    • Un copier-coller, ça doit se justifier... Deux, c'est un de trop.
    • jamais signifie "sauf si j'ai passé trois jours à prouver que je peux".
    • La plus sotte des questions est celle qu'on ne pose pas.
    Pour faire des graphes, essayez yEd.
    le ter nel est le titre porté par un de mes personnages de jeu de rôle

  6. #26
    Membre chevronné Avatar de Ehonn
    Homme Profil pro
    Étudiant
    Inscrit en
    Février 2012
    Messages
    788
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 34
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Février 2012
    Messages : 788
    Points : 2 160
    Points
    2 160
    Par défaut
    Remarque : l'abus de langage « référence constante » est largement admis, mais un terme plus juste est : référence sur membre constant.

  7. #27
    Expert éminent sénior

    Femme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Juin 2007
    Messages
    5 186
    Détails du profil
    Informations personnelles :
    Sexe : Femme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Juin 2007
    Messages : 5 186
    Points : 17 126
    Points
    17 126
    Par défaut
    Pas forcément un membre, d'ailleurs.
    Une traduction plus exacte de T const& serait plus ou moins "référence vers un T constant", ou "référence vers une constante de type T", à la rigueur.

    Sachant qu'en effet, la référence en elle-même est nécessairement constante, par construction du langage. Il est impossible de modifier la référence pour qu'elle change de référé.
    Mes principes de bases du codeur qui veut pouvoir dormir:
    • Une variable de moins est une source d'erreur en moins.
    • Un pointeur de moins est une montagne d'erreurs en moins.
    • Un copier-coller, ça doit se justifier... Deux, c'est un de trop.
    • jamais signifie "sauf si j'ai passé trois jours à prouver que je peux".
    • La plus sotte des questions est celle qu'on ne pose pas.
    Pour faire des graphes, essayez yEd.
    le ter nel est le titre porté par un de mes personnages de jeu de rôle

  8. #28
    Membre à l'essai
    Profil pro
    Inscrit en
    Novembre 2011
    Messages
    104
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Novembre 2011
    Messages : 104
    Points : 23
    Points
    23
    Par défaut
    Merci pour toutes ces réponses (décidément on apprend mieux sur un forum que pendant un cours magistral!). Bon par contre je suis un peu perdu avec ces références constantes (je vais le relire une deuxième fois) mais si j'ai bien compris:
    - le passage par référence dans une fonction permet de modifier cette variable. Du coup si je ne compte pas modifier cette variable au travers de la fonction, le plus simple c'est de faire un passage par variable (et non par référence, donc sans le &...)! Cependant pour éviter une copuie d'un objet/variable/type (désolé je ne manie pas très bien le vocabulaire) très lourd une alternative peut être d'utiliser une référence constante (qui elle est assez light car c'est juste un entier qui désigne l' adresse mémoire de la variable que l'on ne veut pas miodifier!

    @l'eternel: Merci beaucoup pour tes réponses très détaillés! As tu des suggestions de lectures pour progresser ? (j'ai l'impression de puiser un peu partout mais j'ai un peu peur de m'égarer sans savoir programmer correctement.

  9. #29
    Expert éminent sénior
    Avatar de koala01
    Homme Profil pro
    aucun
    Inscrit en
    Octobre 2004
    Messages
    11 612
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 52
    Localisation : Belgique

    Informations professionnelles :
    Activité : aucun

    Informations forums :
    Inscription : Octobre 2004
    Messages : 11 612
    Points : 30 611
    Points
    30 611
    Par défaut
    Oui, le principe est là...

    Mais, de manière générale, on peut aussi dire qu'il est d'office préférable de transmettre tous les types définis (*) par l'utilisateur par référence et de les transmettre par référence constante si la fonction appelée n'est pas destinée à modifier l'objet reçu en paramètre.

    (*) on devrait en réalité préciser "tout type défini par l'utilisateur dont la taille est plus grande qu'un size_t"
    A méditer: La solution la plus simple est toujours la moins compliquée
    Ce qui se conçoit bien s'énonce clairement, et les mots pour le dire vous viennent aisément. Nicolas Boileau
    Compiler Gcc sous windows avec MinGW
    Coder efficacement en C++ : dans les bacs le 17 février 2014
    mon tout nouveau blog

  10. #30
    Expert éminent sénior

    Femme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Juin 2007
    Messages
    5 186
    Détails du profil
    Informations personnelles :
    Sexe : Femme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Juin 2007
    Messages : 5 186
    Points : 17 126
    Points
    17 126
    Par défaut
    Citation Envoyé par dfshr8 Voir le message
    Merci pour toutes ces réponses (décidément on apprend mieux sur un forum que pendant un cours magistral!). Bon par contre je suis un peu perdu avec ces références constantes (je vais le relire une deuxième fois) mais si j'ai bien compris:
    - le passage par référence dans une fonction permet de modifier cette variable. Du coup si je ne compte pas modifier cette variable au travers de la fonction, le plus simple c'est de faire un passage par variable (et non par référence, donc sans le &...)! Cependant pour éviter une copuie d'un objet/variable/type (désolé je ne manie pas très bien le vocabulaire) très lourd une alternative peut être d'utiliser une référence constante (qui elle est assez light car c'est juste un entier qui désigne l' adresse mémoire de la variable que l'on ne veut pas miodifier!
    C'est plutot l'idée.
    Si tu as le courage de regarder la norme, ce qui est un très bon moyen de découvrir où sont les détails, tu rencontreras l'expression "class type", c'est à dire tout type déclaré par class, struct ou union, ou par un typedef sur un tel type.
    Chaque objet d'un tel type a intérêt à être pris en référence.

    La constance est un des grands moyens de garantir des choses dans le code, notamment sa sûreté.
    C'est pour cela qu'apparaissent les fonctions membres constantes (telles que size_type std::vector::size() const;). Ces fonctions sont les seules membres qui puissent être appelées sur un objet constant.

    Citation Envoyé par dfshr8 Voir le message
    @l'eternel: Merci beaucoup pour tes réponses très détaillés! As tu des suggestions de lectures pour progresser ? (j'ai l'impression de puiser un peu partout mais j'ai un peu peur de m'égarer sans savoir programmer correctement.
    Je n'ai lu que quatre sources d'informations:
    • notre forum, la faq et les cours.
    • une vieille édition du livre de Stroustrup, l'auteur du C++
    • la dernière norme en date. Pour l'instant, j'utilise le pdf de la C++11.
    • cppreference.com


    Pour moi qui n'aime pas les livres de langage (car ils périment), celui de Stroustrup présente un intérêt majeur: la moitié de ce qui est écrit ne concerne pas la syntaxe, mais la raison pour laquelle il a choisit telle fonctionnalité ou telle syntaxe plutot qu'une autre.
    J'aime beaucoup le paragraphe où il déplore que this soit un pointeur. S'il avait créé les références plus tôt, c'est ce qu'il aurait choisit.

    Pour progresser, il n'y a qu'une manière de faire:
    demander des avis sur du code que tu as fait.

    Cela supposes que tu codes.

    un grand conseil?
    Boileau disait "Ce qui se conçoit bien s'énonce clairement, et les mots pour le dire viennent aisément".
    La version code serait "Ce qui se comprends bien s'explique clairement, et le code pour le dire vient aisément".
    Mes principes de bases du codeur qui veut pouvoir dormir:
    • Une variable de moins est une source d'erreur en moins.
    • Un pointeur de moins est une montagne d'erreurs en moins.
    • Un copier-coller, ça doit se justifier... Deux, c'est un de trop.
    • jamais signifie "sauf si j'ai passé trois jours à prouver que je peux".
    • La plus sotte des questions est celle qu'on ne pose pas.
    Pour faire des graphes, essayez yEd.
    le ter nel est le titre porté par un de mes personnages de jeu de rôle

  11. #31
    Membre à l'essai
    Profil pro
    Inscrit en
    Novembre 2011
    Messages
    104
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Novembre 2011
    Messages : 104
    Points : 23
    Points
    23
    Par défaut
    Merci!

    13) Petite question qui sort un peu du topic:
    - Pour le moment je code sous gedit
    - mes fichiers sont sous dropbox pour y avoir accès plus tard quand j' en aurais besoin (en fait j' ai une sorte de Wiki ZIM qui me permet d'expliquer ce que j'apprends au fur et à mesure, ainsi que le ficher des codes sources qui permettent d'illustre le wiki): /home/laurent/Dropbox/Code_C++/Pedagodie_prog/vide.cpp'
    - Je compile à la main

    Du coup ça me prend pas mal de temps
    1) de me placer dans le bon dossier
    Du coup j'ai pensé créer un alias : alias vide='gedit /home/laurent/Dropbox/Code_C++/Pedagodie_prog/vide.cpp' qui me crée un main vide.
    Du coup j'ai modifié le ./bashrc:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    # some more ls aliases
    alias ll='ls -alF'
    alias la='ls -A'
    alias l='ls -CF'
    alias vide='gedit /home/laurent/Dropbox/Code_C++/Pedagodie_prog/vide.cpp'

    Mais quand je tape : vide dans le terminal ca me renvoi:[quote]No command 'vide' found, did you mean:
    [/quote Je ne comprends pas bien...

  12. #32
    Membre émérite
    Avatar de prgasp77
    Homme Profil pro
    Ingénieur en systèmes embarqués
    Inscrit en
    Juin 2004
    Messages
    1 306
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 36
    Localisation : France, Eure (Haute Normandie)

    Informations professionnelles :
    Activité : Ingénieur en systèmes embarqués
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Juin 2004
    Messages : 1 306
    Points : 2 466
    Points
    2 466
    Par défaut
    Citation Envoyé par dfshr8 Voir le message
    1) de me placer dans le bon dossier
    Il y a deux choses que je n'aime pas dans la vie :
    1. Les listes pas terminées


    Sinon pour ton alias, tu dois ressourcer ton fichier : source ~/.bashrc. Mais je ne pense pas que ce soit la meilleure solution cet alias. Intéresse-toi plutôt aux makefiles [ et à cmake [ et aux autotools ] ] : il s'agit de fichiers textes permettant l'automatisation de la compilation. Ainsi, compiler devient :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    $ cd ~/dev/banana
    $ make
    $ ./banana
    -- Yankel Scialom

  13. #33
    Membre à l'essai
    Profil pro
    Inscrit en
    Novembre 2011
    Messages
    104
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Novembre 2011
    Messages : 104
    Points : 23
    Points
    23
    Par défaut
    15) (Facultatif concerne documentation C++ dans e cadre du stage)Autre petite question un peu en marge du post: voici mon sujet e stage stage-description.pdf. Je suis censé débuter la semaine prochaine je vais donc devoir compléter mon apprentissage C++nau ur et à mesure (j' en suis à la partie pointeur sur le cours C++ il me reste donc 3 jours pour visualiser la seconde partie du cours qui concerne l' orienté objet). Mais je ne sais pas comment aborder le problème, comment se servir d'une biblithèque...
    Si vous avez des conseils...

  14. #34
    Expert éminent sénior
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Février 2005
    Messages
    5 059
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 52
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Conseil

    Informations forums :
    Inscription : Février 2005
    Messages : 5 059
    Points : 12 095
    Points
    12 095
    Par défaut
    15) un rapide coup d'oeil sur les exemples montre que c'est une librairie C++ et non C dans son approche et utilisation de Template.
    Il vous faudra donc maitriser un minimum la Programmation Orientée Objet ainsi que les Templates de la STL.

  15. #35
    Membre à l'essai
    Profil pro
    Inscrit en
    Novembre 2011
    Messages
    104
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Novembre 2011
    Messages : 104
    Points : 23
    Points
    23
    Par défaut
    15) Pour les structures, peut on découpler les étapes:
    - de déclaration
    - d'initialisation
    ? Pour le moment je ne sais qu fair les deux simultanément comme suit:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    struct Nom_Structure {
    	type_champ1 Nom_Champ1;
     
    	type_champ2 Nom_Champ2;
    	...
    };
    16) Les structures ressemblent à des objets car on accèd à ses champs par un .
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    Nom_Variable.Nom_Champ;
    Est ce qu'une structure est un objet sans méthodes ?

  16. #36
    Expert éminent sénior
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Février 2005
    Messages
    5 059
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 52
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Conseil

    Informations forums :
    Inscription : Février 2005
    Messages : 5 059
    Points : 12 095
    Points
    12 095
    Par défaut
    En C++ (pas en C), une structure, c'est exactement la même chose qu'une classe, à la visibilité par défaut près.

  17. #37
    Membre à l'essai
    Profil pro
    Inscrit en
    Novembre 2011
    Messages
    104
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Novembre 2011
    Messages : 104
    Points : 23
    Points
    23
    Par défaut
    J'ai voulu me faire un mémo sur la lasse <vector>:
    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
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    #include <iostream>	
    #include<vector>// Pour inlure les tableaux dynamiques
    #include<string>//
    using namespace std;
     
     
     
    int main()
    {
    /* (1) Les tableaux dynamiques, "vector" sont des tableaux dont la taille n' a pas à être connue à la compilation et peut évoluer pendant l' execution du programme. Ceci nous permet: */
     
    	vector<double>tabDynamique1; //(Déclaration d'un tableau dynamique) On a donc pas à spécifier, lors de sa création, sa taille par 
    	int taille=3;
    	vector<string> tabDynamique3(taille);
    	//(Délaration et pré-réservation d'une taille à priori) Si on spécifie la taille, celle-ci peut évoluer
    	vector <char>tabDynamique2={'a','a'};//(Déclaration, pré-reservation d'une taille (sans besin de la spécifier car on initialise après), et initialisation)
     
    	/* (2) Une fois que les déclarations sont faites, le seul moyen de rajouter des éléments où d'agir se fait par les méthodes de la classe vector*/
     
    	cout<<tabDynamique1.size()<<endl;//Retourne la taille du tableaux
     
    	for (size_t i(0);i<10;++i){
    		tabDynamique1.push_back(i);//(Ajouter un élément à la fin du tableau (en correspondane avec son type): la mémoire réalloue de l' espacepour rajouter des éléments dans le tableau
    	}
     
    	for (size_t i(0);i<10;++i){
    		cout<<tabDynamique1[i]<<endl;//(Le moyen d'afficher les éléments du tableau)
    	}
     
     
    	//tabDynamique1.pop_back();// (Supprime le dernier élément)
     
     
     
    	return 0;
    }
    Et voici ce qu'il me retourne en console:


    Ma console m' affiche celà:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    laurent@Ellington:~/Dropbox/Code_C++/Pedagodie_prog$ 
    laurent@Ellington:~/Dropbox/Code_C++/Pedagodie_prog$ g++ vector.cpp -o vector
    vector.cpp: In function ‘int main()’:
    vector.cpp:16:37: error: in C++98 ‘tabDynamique2’ must be initialized by constructor, not by ‘{...}’
      vector <char>tabDynamique2={'a','a'};//(Déclaration, pré-reservation d'une taille (sans besin de la spécifier car on initialise après), et initialisation)
                                         ^
    Du coup j'imagine qu'il faut que je mette à jour c++.
    a)Comment voir la version exacte ?(98 apperement mais j'imagine qu'il y ad autres infos que je peux choper.

    Apperement en console j' obtiens(ce qui me fait penser que j'ai déjà une version c++11 avec les nouvelles snormes):
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    laurent@Ellington:~/Dropbox/Code_C++/Pedagodie_prog$ g++ --version
    g++ (Ubuntu 4.8.2-19ubuntu1) 4.8.2
    Copyright (C) 2013 Free Software Foundation, Inc.
    This is free software; see the source for copying conditions.  There is NO
    warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
    b) Puis je mettre à jour c++ diretement en mode console ?
    (dans le as ou il faut faire le telechargement puis l' installation quelle est la commande linux qui permet de faire un téléchargement depuis la console ?)

    Merci

  18. #38
    Rédacteur/Modérateur
    Avatar de JolyLoic
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Août 2004
    Messages
    5 463
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 49
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Août 2004
    Messages : 5 463
    Points : 16 213
    Points
    16 213
    Par défaut
    Citation Envoyé par leternel Voir le message
    Pas forcément un membre, d'ailleurs.
    Une traduction plus exacte de T const& serait plus ou moins "référence vers un T constant", ou "référence vers une constante de type T", à la rigueur.
    Même si référence constante est un raccourci, je le trouve préférable à cette traduction, qui laisse croire que c'est une référence à un objet constant, ce qui n'est pas le cas :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    int i = 2; // Pas constant pour 2 sous
    int const &j = i; // Référence constante
    Comme dénomination non raccourcie, j'utiliserais une expression comme "référence permettant un accès en lecture seule à".
    Ma session aux Microsoft TechDays 2013 : Développer en natif avec C++11.
    Celle des Microsoft TechDays 2014 : Bonnes pratiques pour apprivoiser le C++11 avec Visual C++
    Et celle des Microsoft TechDays 2015 : Visual C++ 2015 : voyage à la découverte d'un nouveau monde
    Je donne des formations au C++ en entreprise, n'hésitez pas à me contacter.

  19. #39
    Rédacteur/Modérateur
    Avatar de JolyLoic
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Août 2004
    Messages
    5 463
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 49
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Août 2004
    Messages : 5 463
    Points : 16 213
    Points
    16 213
    Par défaut
    Citation Envoyé par dfshr8 Voir le message
    Ma console m' affiche celà:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    laurent@Ellington:~/Dropbox/Code_C++/Pedagodie_prog$ 
    laurent@Ellington:~/Dropbox/Code_C++/Pedagodie_prog$ g++ vector.cpp -o vector
    vector.cpp: In function ‘int main()’:
    vector.cpp:16:37: error: in C++98 ‘tabDynamique2’ must be initialized by constructor, not by ‘{...}’
      vector <char>tabDynamique2={'a','a'};//(Déclaration, pré-reservation d'une taille (sans besin de la spécifier car on initialise après), et initialisation)
                                         ^
    Et si tu ajoutes -std=c++11 en option de ligne de commande de ton compilateur ?
    Ma session aux Microsoft TechDays 2013 : Développer en natif avec C++11.
    Celle des Microsoft TechDays 2014 : Bonnes pratiques pour apprivoiser le C++11 avec Visual C++
    Et celle des Microsoft TechDays 2015 : Visual C++ 2015 : voyage à la découverte d'un nouveau monde
    Je donne des formations au C++ en entreprise, n'hésitez pas à me contacter.

  20. #40
    Membre à l'essai
    Profil pro
    Inscrit en
    Novembre 2011
    Messages
    104
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Novembre 2011
    Messages : 104
    Points : 23
    Points
    23
    Par défaut
    @Loic: j' ai trouvé ceci sur le net g++ -W -Wall -Wextra -pedantic -O3 -march=native -std=c++0x -o vector vector.cpp
    Je ne sais pas s'il ya une différence entre ce que tu proposes et -std=c++0x. Sinon j'avoue ne pas bien comprendre les options que l'on donne au compilateur, mais c'est assez long à taper (même si une fois taper on peut revenir en arrière en ligne de commande).... Comment faie vous ? (un make, un alias , ..?)

    16) Le mot vctor en C++ designe :
    -un objet
    - une classe
    - un type
    ?

Discussions similaires

  1. [VBA-E] Questions en Vrac...
    Par Pouic dans le forum Macros et VBA Excel
    Réponses: 6
    Dernier message: 08/02/2006, 14h50
  2. [FLASH 8] Question sur la portée des objets.
    Par i_shinji dans le forum Flash
    Réponses: 1
    Dernier message: 02/11/2005, 18h18
  3. Question sur les librairies .lib
    Par elvivo dans le forum Autres éditeurs
    Réponses: 5
    Dernier message: 05/10/2005, 21h06
  4. Réponses: 3
    Dernier message: 13/08/2004, 19h52
  5. question de débutant sur les objets
    Par boucher_emilie dans le forum ASP
    Réponses: 3
    Dernier message: 06/08/2004, 11h51

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo