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 confirmé 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
    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
    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 confirmé 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
    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
    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 confirmé 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
    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
    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 confirmé 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
    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 Expert
    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 : 45
    Localisation : France, Essonne (Île de France)

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

    Informations forums :
    Inscription : Septembre 2002
    Messages : 918
    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 Expert
    Avatar de Goten
    Profil pro
    Inscrit en
    Juillet 2008
    Messages
    1 580
    Détails du profil
    Informations personnelles :
    Âge : 34
    Localisation : France

    Informations forums :
    Inscription : Juillet 2008
    Messages : 1 580
    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?

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