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 :

Problème avec std::string


Sujet :

C++

  1. #1
    Membre du Club Avatar de Gobelins
    Homme Profil pro
    Enseignant Chercheur
    Inscrit en
    Décembre 2007
    Messages
    171
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Enseignant Chercheur

    Informations forums :
    Inscription : Décembre 2007
    Messages : 171
    Points : 60
    Points
    60
    Par défaut Problème avec std::string
    Bonsoir,

    J'ai écris un programme en C++ sur Visual Studio C++ Express 2010. Lors de la génération, ça m'affiche les erreurs suivantes:

    error C2678: '==' binaire*: aucun opérateur trouvé qui accepte un opérande de partie gauche de type 'std::string' (ou il n'existe pas de conversion acceptable)

    i:\program files\microsoft visual studio 10.0\vc\include\exception(470): peut être 'bool std::operator ==(const std::_Exception_ptr &,const std::_Exception_ptr &)'
    i:\program files\microsoft visual studio 10.0\vc\include\exception(475): ou 'bool std::operator ==(std::_Null_type,const std::_Exception_ptr &)'
    i:\program files\microsoft visual studio 10.0\vc\include\exception(481): ou 'bool std::operator ==(const std::_Exception_ptr &,std::_Null_type)'
    i:\program files\microsoft visual studio 10.0\vc\include\system_error(408): ou 'bool std::operator ==(const std::error_code &,const std::error_condition &)'
    i:\program files\microsoft visual studio 10.0\vc\include\system_error(416): ou 'bool std::operator ==(const std::error_condition &,const std::error_code &)'
    lors de la tentative de mise en correspondance de la liste des arguments '(std::string, std::string)'

    Voici le code de la classe textures.cpp:
    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
    37
    38
    #include <fstream>
    #include <GL/glu.h>
     
    #include "..\Headers\templates.h"
    #include "..\Headers\textures.h"
     
    using namespace std;
     
    CTextures::CTextures(){                                                         // Constructeur d'un ensemble de textures
        this->textures=new unsigned int[100];                                       // 100 textures au maximum
        glGenTextures(100, textures);
        this->Charger();
    }
     
    CTextures::~CTextures(){
        glDeleteTextures(nbTextures, textures);
        delete [] textures;
        delete [] texturesParDossier;
    }
     
    GLuint CTextures::Texture(char* dossier, const num){
        string dos(dossier);
        bool arret=false;
        int numDossier=0;
        while(!arret&&numDossier<nbDossiers){
            string nomDos(nomDossier[numDossier]);
            if(dos==nomDos){
                numDossier-=1;
                arret=true;
            }
            numDossier+=1;
        }
        int nbText=0;
        for (int i=0; i<numDossier; i++){
            nbText+=texturesParDossier[i];
        }
        return textures[nbText+num];
    }
    L'erreur se produit au niveau cette ligne:
    if(dos==nomDos)

    Error:aucun opérateur "==" ne correspond à ces opérandes

    Voici le code source de la classe textures.h:
    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
    class CTextures : public CSingleton<CTextures>{
        friend class CSingleton<CTextures>;
     
        private:
            int nbDossiers;                                                         // Nombre de dossier de texture
            char nomDossier[10][10];                                                // Noms des dossiers
            int* texturesParDossier;                                                // Nombre de textures par dossier
            int nbTextures;                                                         // Nombre total de textures
            unsigned int* textures;
     
            CTextures();
            ~CTextures();    
     
        public:                                              
            unsigned int Texture( char*,  int);
     
        private: 
            void Charger();   
            void ChargerTGA(const char*, unsigned int*);                              
    };
    J'ai essayé de résoudre ce problème lors de la compilation, mais je ne me suis pas parvenu. J'attends vos réponses. Merci de votre aide.

  2. #2
    Rédacteur
    Avatar de 3DArchi
    Profil pro
    Inscrit en
    Juin 2008
    Messages
    7 634
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Juin 2008
    Messages : 7 634
    Points : 13 017
    Points
    13 017
    Par défaut
    Salut,
    Il manque #include <string>.


    Pourquoi utiliser de l'allocation dynamique plutôt que std::vector ? Si je comprend bien le code que tu montres, ton objectif n'est pas de faire un exercice sur la gestion mémoire. Donc autant utiliser un std::vector qui t'éviteras les erreurs liées à cette gestion.

  3. #3
    Membre du Club Avatar de Gobelins
    Homme Profil pro
    Enseignant Chercheur
    Inscrit en
    Décembre 2007
    Messages
    171
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Enseignant Chercheur

    Informations forums :
    Inscription : Décembre 2007
    Messages : 171
    Points : 60
    Points
    60
    Par défaut
    Quand j'ai ajouté ce qu'il manquait (#include <string>, l'erreur a disparu. Pourquoi l'erreur a disparu? Ce n'est pas un simple exercie de gestion mémoire,c'est plutot un projet rédigé en C++ (OpenGL).

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    Donc autant utiliser un std::vector qui t'éviteras les erreurs liées à cette gestion.
    Comment puis-je utiliser std::vector?

    Par ailleurs, j'ai écris beaucoup de fichiers en C++ (plus d'une dizaine) et j'ai d'autres erreurs (plus d'une centaine) à corriger et je ne sais pas comment m'y prendre. Je pense que le compilateur de Visual Studio C++ n'apprécie pas
    ce que j'ai écris. Il n'est pas du tout content. Pourtant, ça me semble correcte ce que j'ai écris.

    error C2057: expression constante attendue
    error C2466: impossible d'allouer un tableau de taille constante 0
    error C2133: 'vertices'*: taille inconnue

    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
    #include <fstream>
    #include <GL/glu.h>
    #include <cmath>
     
    #include "..\Headers\templates.h"
    #include "..\Headers\textures.h"
    #include "..\Headers\math3D.h"
    #include "..\Headers\menu.h"
    #include "..\Headers\eclairage.h"
    #include "..\Headers\objets.h"
    #include "..\Headers\particules.h"
    #include "..\Headers\terrain.h"
    #include "..\Headers\vbo.h
     
    void CTerrain::GenererTerrain(unsigned int buffer_[], int longueur, int largeur, float hauteurs[], bool grillage_){
        float vertices[3*(longueur+1)*(largeur+1)];
        float textCord[2*(longueur+1)*(largeur+1)];
        float textGril[2*(longueur+1)*(largeur+1)];
        float normales[3*(longueur+1)*(largeur+1)];
        unsigned int faces[6*longueur*largeur];
    L'erreur se produit au niveau (longueur et largeur)

    Error: l'expression doit avoir une valeur constante

    terrain.h

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    void CTerrain::GenererTerrain(unsigned int buffer_[], int longueur, int largeur, float hauteurs[], bool grillage_){
        float vertices[3*(longueur+1)*(largeur+1)];
        float textCord[2*(longueur+1)*(largeur+1)];
        float textGril[2*(longueur+1)*(largeur+1)];
        float normales[3*(longueur+1)*(largeur+1)];
        unsigned int faces[6*longueur*largeur];
    Je n'ai pas compris d'ou viennent ces erreurs?

  4. #4
    Rédacteur
    Avatar de 3DArchi
    Profil pro
    Inscrit en
    Juin 2008
    Messages
    7 634
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Juin 2008
    Messages : 7 634
    Points : 13 017
    Points
    13 017
    Par défaut
    Salut,
    Citation Envoyé par Gobelins Voir le message
    Quand j'ai ajouté ce qu'il manquait (#include <string>, l'erreur a disparu. Pourquoi l'erreur a disparu?
    Parce que les différentes surcharges de l'opérateur '==' avec une ou des std::string comme opérande sont déclarées dans l'en-tête <string>.

    Citation Envoyé par Gobelins Voir le message
    Comment puis-je utiliser std::vector?
    Assez simplement :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    #include <vector>
    #include <string>
     
    class CTextures : public CSingleton<CTextures>{
       friend class CSingleton<CTextures>;
     
       private:
          int nbDossiers;                                                         // Nombre de dossier de texture
          std::vector<std::string> nomDossier;                                                // Noms des dossiers
          std::vector<int> texturesParDossier;                                                // Nombre de textures par dossier
          int nbTextures;                                                         // Nombre total de textures
          std::vector<int> textures;
    // etc...
    Puis :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    Textures::CTextures()
       :textures(100) // construit un vecteur de 100 éléments
    {                                                         // Constructeur d'un ensemble de textures
        glGenTextures(100, &textures[0]);
    Cf La bibliothèque C++ STL par Bruno Garcia et autres tutos C++.

    Citation Envoyé par Gobelins Voir le message
    Pourtant, ça me semble correcte ce que j'ai écris.
    Faut croire que non puisqu'il râle. D'ailleurs, c'est le rôle d'un (bon) compilateur : râler là où ton code est erroné.

    Citation Envoyé par Gobelins Voir le message
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    void CTerrain::GenererTerrain(unsigned int buffer_[], int longueur, int largeur, float hauteurs[], bool grillage_){
        float vertices[3*(longueur+1)*(largeur+1)];
        float textCord[2*(longueur+1)*(largeur+1)];
        float textGril[2*(longueur+1)*(largeur+1)];
        float normales[3*(longueur+1)*(largeur+1)];
        unsigned int faces[6*longueur*largeur];
    En C++, la taille des tableaux statiques doit être connue à la compilation. Si certains compilateurs tolèrent des déclarations comme la tienne, il s'agit d'un écart à la norme. D'où l'intérêt de passer par un std::vector :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    void CTerrain::GenererTerrain(std::vector<unsigned int> const &buffer_, int longueur, int largeur, std::vector<float> const& hauteurs, bool grillage_)
    {
        std::vector<float> vertices(3*(longueur+1)*(largeur+1));
        std::vector<float> textCord(2*(longueur+1)*(largeur+1));
        std::vector<float> textGril(2*(longueur+1)*(largeur+1));
        std::vector<float> normales(3*(longueur+1)*(largeur+1));
        std::vector<unsigned int> faces(6*longueur*largeur);

  5. #5
    Membre du Club Avatar de Gobelins
    Homme Profil pro
    Enseignant Chercheur
    Inscrit en
    Décembre 2007
    Messages
    171
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Enseignant Chercheur

    Informations forums :
    Inscription : Décembre 2007
    Messages : 171
    Points : 60
    Points
    60
    Par défaut
    J'ai modifié mon code d'après ce que vous m'avez écris et j'ai ajouté #include<vector> et #include<string>, mais les erreurs précédentes au niveau (longueur et largeur) n'ont pas disparu, voire, j'ai d'autres erreurs sur buffer et hauteurs.

    Dans le fichier terrain.h, j'avais écris cette ligne avant modification:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    static void GenererTerrain(unsigned int buffer_[], int longueur, int largeur, float hauteurs[], bool grillage_);
    Je l'ai modifiée suite aux modifications que j'ai effectuées dans le fichier terrain.cpp car le compilateur a râlé sur cette ligne avant modification.

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    static void GenererTerrain(std::vector<unsigned> const &buffer, int longueur, int largeur, std::vector<float> const &hauteurs, bool grillage_);
    Les deux nouvelles erreurs après modifications sont apparues sur cette ligne (buffer et hauteurs)
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
      this->GenererTerrain(buffer, longueur, largeur, hauteurs, true);
    error C2664: 'CTerrain::GenererTerrain'*: impossible de convertir le paramètre 1 de 'unsigned int [5]' en 'const std::vector<_Ty> &'
    with
    [
    _Ty=unsigned int
    ]
    Raison*: impossible de convertir de 'unsigned int [5]' en 'const std::vector<_Ty>'
    with
    [
    _Ty=unsigned int ]
    Aucun constructeur n'a pu prendre le type de source, ou la résolution de la surcharge du constructeur était ambiguë


    Au niveau du buffer:

    unsigned int CTerrain::buffer[5]
    Error:il n'existe aucun constructeur approprié pour la conversion "unsigned int[5]" en "std::vector<unsigned int, std::allocator<char32_t>>"

    Au niveau de hauteurs:

    float* CTerrain::hauteurs
    Error:il n'existe aucun constructeur approprié pour la conversion "float*" en "std::vector<float, std::allocata<float>>"

    terrain.h
    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
    37
    class CTerrain: public CSingleton<CTerrain>{
        friend class CSingleton<CTerrain>;
     
        private:
            unsigned int buffer[5];                                                 // Buffers du terrain
            unsigned int texTerrain;                                                // Texture composite du terrain
            float reflet;                                                           // Mouvement du reflet
            int* cases;                                                             // Valeurs des cases du terrain
            int largeur;                                                            // Largeur du terrain (nb de cases)
            int longueur;                                                           // Longueur du terrain
            bool grillage;                                                          // Affichage de la grille ?
            float* hauteurs;                                                        // tableau des vertices du terrain
            float* hauteurCases;                                                    // hauteurs des cases du terrain
            CTriangle* triangles;                                                   // Triangles composant le terrain
            CArbre* arbre;
     
            CTerrain(void);
            ~CTerrain(void);
            void GenererTexture(void);                                                 
     
        public:
            int Longueur(void);
            int Largeur(void);
     
            void Charger(int numero);                                               // Chargement de la heigthmap
            void DessinerTerrain(void);                                             // Dessin du terrain
            void DessinerObjets(void);                                              // Dessin des objets
            bool Grillage(void);                                                    // Affichage de la grille activé ?
            void AfficherGrillage(void);                                            // Changer l'affichage de la grille
            void Animer(float deltaTemps);                                          // Animation du terrain
            int Cases(int indice);                                                  // Valeur de la case
            float HauteurCase(int indice);                                          // Hauteur de la case
     
     
            static void GenererTerrain(std::vector<unsigned> const &buffer, int longueur, int largeur, std::vector<float> const &hauteurs, bool grillage_);     
     
    };
    terrain.c
    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
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    CTerrain::CTerrain(void){
        this->grillage=false;
    }
     
    CTerrain::~CTerrain(void){
        delete arbre;
        delete [] cases;
        delete [] hauteurs;
        delete [] hauteurCases;
        glDeleteBuffersARB(5, buffer);
        glDeleteTextures(1, &texTerrain);
    }
     
    void CTerrain::Charger(int numero){
        CMenu* menu=CMenu::GetInstance();
     
        char chemin[50];
        sprintf(chemin, "./Data/Terrains/%d.tga", numero);
     
        menu->BarreChargement("Chargement de la HeightMap");
        CImage* image=new CImage(chemin);
        this->longueur=image->Longueur()-1;
        this->largeur=image->Largeur()-1;
        this->hauteurs=new float[(longueur+1)*(largeur+1)];
        this->hauteurCases=new float[longueur*largeur];
        this->cases=new int[longueur*largeur];
     
        for(int i=0; i<(longueur+1)*(largeur+1); i++){
            this->hauteurs[i]=float(image->Data()[i*image->Bpp()])/50-1;
        }
        for(int i=0; i<longueur*largeur; i++){
            this->hauteurCases[i]=(hauteurs[i+1+i/longueur]+hauteurs[i+1+longueur+i/longueur])/2;
            if(hauteurCases[i]>1) cases[i]=1; else cases[i]=0;
        }
        glGenBuffersARB(5, buffer);
        this->GenererTerrain(buffer, longueur, largeur, hauteurs, true);
     
        menu->BarreChargement("Creation des textures");
        glGenTextures(1, &texTerrain);
        this->GenererTexture();
     
        menu->BarreChargement("Chargement des arbres");
     
        int nbArbres=0;
        for(int i=0; i<(longueur+1)*largeur; i++){
            if((i+1)%(longueur+1)>0&&image->Data()[i*image->Bpp()+1]>100) nbArbres++;
        }
        this->arbre=new CArbre(nbArbres);
        int compteur=-1;
        for(int i=0; i<(longueur+1)*largeur; i++){
            if((i+1)%(longueur+1)>0&&image->Data()[i*image->Bpp()+1]>100){
                compteur++;
                arbre->Positionner(compteur, CVecteur3D(i%(longueur+1)+0.5,i/(longueur+1)+0.5,hauteurCases[i-i/longueur]));
                cases[i-i/longueur]=2;
            }
        }
     
        menu->BarreChargement("Creation du monde");
     
        delete image;
    }
     
    void CTerrain::DessinerTerrain(void){
     
        CTextures* textures=CTextures::GetInstance();
        glBindTexture(GL_TEXTURE_2D, texTerrain);
     
        double equation1[]={0,0,1,0.2};
        glClipPlane(GL_CLIP_PLANE0, equation1);
        glEnable(GL_CLIP_PLANE0);
        glBindBufferARB( GL_ARRAY_BUFFER_ARB, buffer[VERTICES] );
    	glVertexPointer( 3, GL_FLOAT, 0, (char *) NULL );
    	glBindBufferARB( GL_ARRAY_BUFFER_ARB, buffer[TEXTURES] );
    	glTexCoordPointer( 2, GL_FLOAT, 0, (char *) NULL );
    	glBindBufferARB( GL_ARRAY_BUFFER_ARB, buffer[NORMALES] );
    	glNormalPointer( GL_FLOAT, 0, (char *) NULL );
    	glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, buffer[INDICES]);
        glDrawElements(GL_TRIANGLES, 6*longueur*largeur, GL_UNSIGNED_INT, 0);
     
        if(this->grillage){
            glPushMatrix();
            glEnable(GL_BLEND);
            glClipPlane(GL_CLIP_PLANE0, equation1);
            glTranslatef(0,0,0.01);
            glBindTexture(GL_TEXTURE_2D, textures->Texture("Terrain", 1));
        	glBindBufferARB( GL_ARRAY_BUFFER_ARB, buffer[TEXTURES2] );
        	glTexCoordPointer( 2, GL_FLOAT, 0, (char *) NULL );
            glDrawElements(GL_TRIANGLES, 6*longueur*largeur, GL_UNSIGNED_INT, 0);
            glDisable(GL_BLEND);
            glPopMatrix();
        }
     
        glDisable(GL_CLIP_PLANE0);
     
        glDisable(GL_CULL_FACE);
        glPushMatrix();
        double equation2[]={0,0,-1,-0.1};
        glClipPlane(GL_CLIP_PLANE1, equation2);
        glEnable(GL_CLIP_PLANE1);
        glScalef(1.0, 1.0, abs(cos(this->reflet*20))/15-2.0);
     
        glDrawElements(GL_TRIANGLES, 6*longueur*largeur, GL_UNSIGNED_INT, 0);
        glDisable(GL_CLIP_PLANE1);
        glEnable(GL_CULL_FACE);
        glPopMatrix();
    }
     
    void CTerrain::DessinerObjets(void){
        this->arbre->Dessiner();
    }
     
    void CTerrain::GenererTerrain(std::vector<unsigned int> const &buffer_, int longueur, int largeur, std::vector<float> const &hauteurs, bool grillage_){
        std::vector<float> vertices[3*(longueur+1)*(largeur+1)];
        std::vector<float> textCord[2*(longueur+1)*(largeur+1)];
        std::vector<float> textGril[2*(longueur+1)*(largeur+1)];
        std::vector<float> normales[3*(longueur+1)*(largeur+1)];
        std::vector<unsigned int> faces[6*longueur*largeur];
    Je n'ai pas compris ce qu'il veut ce compilateur malgré les modifications.

  6. #6
    Rédacteur
    Avatar de 3DArchi
    Profil pro
    Inscrit en
    Juin 2008
    Messages
    7 634
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Juin 2008
    Messages : 7 634
    Points : 13 017
    Points
    13 017
    Par défaut
    Salut,
    Là, je pense qu'il va falloir que tu y mettes un peu du tien. Le compilateur est assez clair. Et en mettant en œuvre des vecteurs, il n'est pas inutile de commencer à se renseigner dessus. Tu peux donc consulter les cours et tutoriels.

  7. #7
    Membre du Club Avatar de Gobelins
    Homme Profil pro
    Enseignant Chercheur
    Inscrit en
    Décembre 2007
    Messages
    171
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Enseignant Chercheur

    Informations forums :
    Inscription : Décembre 2007
    Messages : 171
    Points : 60
    Points
    60
    Par défaut
    Bonsoir,

    J'ai réussi à résoudre le problème en faisant les modificaions suivantes:

    Je suis parti de cet exemple: int *tableau= new int [uneVariableNonConstante]

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    double *vertices=new double[3*(longueur+1)*(largeur+1)];
        float *textCord=new float[2*(longueur+1)*(largeur+1)];
        float *textGril=new float[2*(longueur+1)*(largeur+1)];
        float *normales=new float[3*(longueur+1)*(largeur+1)];
        unsigned int *faces=new unsigned int[6*longueur*largeur];

  8. #8
    Membre chevronné
    Avatar de Joel F
    Homme Profil pro
    Chercheur en informatique
    Inscrit en
    Septembre 2002
    Messages
    918
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Chercheur en informatique
    Secteur : Service public

    Informations forums :
    Inscription : Septembre 2002
    Messages : 918
    Points : 1 921
    Points
    1 921
    Par défaut
    non, on te dit d'utiliser std::vector. utilisez new alors que tu ne maitrises pas le concept d'allocation memoire et de construction, c'est aller au tas.

  9. #9
    Membre chevronné
    Avatar de Goten
    Profil pro
    Inscrit en
    Juillet 2008
    Messages
    1 580
    Détails du profil
    Informations personnelles :
    Âge : 33
    Localisation : France

    Informations forums :
    Inscription : Juillet 2008
    Messages : 1 580
    Points : 2 205
    Points
    2 205
    Par défaut
    Citation Envoyé par Joel F Voir le message
    non, on te dit d'utiliser std::vector. utilisez new alors que tu ne maitrises pas le concept d'allocation memoire et de construction, c'est aller au tas.
    La blague était intentionnelle?
    "Hardcoded types are to generic code what magic constants are to regular code." --A. Alexandrescu

Discussions similaires

  1. problème avec std::string
    Par haraelendil dans le forum Langage
    Réponses: 10
    Dernier message: 25/06/2010, 18h56
  2. problème avec std::string:find()
    Par Spidyy dans le forum SL & STL
    Réponses: 8
    Dernier message: 03/09/2009, 01h25
  3. Problème avec std::string
    Par Laughing Man dans le forum C++
    Réponses: 18
    Dernier message: 07/02/2008, 19h04
  4. Sale problème avec les strings et les fichiers
    Par acieroid dans le forum C++
    Réponses: 18
    Dernier message: 26/04/2006, 09h47
  5. Problème avec std::Vector
    Par mister3957 dans le forum SL & STL
    Réponses: 8
    Dernier message: 16/02/2006, 10h18

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