Operateur new allocation new

Question

Bonjour, je cherche un peu d'aide pour cette modeste class.
Telle quelle est pr&#233;sent&#233; la elle g&#233;n&#232;re une erreur  lors de l'execution (ligne signal&#233;s dans la classe.

class
 CRepertoire 
{ 
public: 
        char * cNomRepertoire;
 //Avec char * cNomRepertoire aucun probl&#232;me (je suprime la ligne new dans le constructeur)
        unsigned long ulNbReps; 
        unsigned long ulNbFichiers; 
        unsigned long ulTailleMo; 
        CRepertoire(char * cRepertoire = "c:"); 
        ~CRepertoire(void); 
        void ScanRep(char *cRepertoire); 
}; 

CRepertoire::CRepertoire(char * cRepertoire) 
{
 
    char * cNomReperoire = new char[strlen(cRepertoire)]; //Ligne qui pose probl&#232;me

    *cNomRepertoire = ""
 
    strcpy(cNomRepertoire, cRepertoire);
 
    ulNbReps = 0;
 
     ulNbFichiers = 0;
 
     ulTailleMo = 0;
 
    ScanRep(cNomRepertoire);
 
} 
Pourquoi cette ecriture n'est pas correcte.
Merci

yserver · Answer

d&#233;sol&#233; pour la mise en forme (probl&#232;me de copier coller)

ekinox17 · Answer

Donne nous l'appel de ton constructeur car on connait pas la valeur que
tu as donner &#224; cRepertoire en general les erreur a l'execution &#231;a vient
des pointeur NULL (non initialis&#233;)

Verifie que le param&#232;tre de ton constructeur est bien un char* .


C U Later
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1 + 1 = 1, c'est l'harmonie parfaite (citation de J-C Van-Dame)
Vive la logique: 1 ou 1 &#231;a fait bien 1 : pas si fou que &#231;a JC ;)

vecchio56 · Answer

*cNomRepertoire = ""

Ca passe à la compilation ce truc?

yserver · Answer

non pardon cNomRepertoire ="" passe a la compilation mais pas a l'execution c'etait a des fin de test 
Je reformule donc :
class CRepertoire
 
{ 
public: 
   char * cNomRepertoire; //Avec char * cNomRepertoire aucun probl&#232;me (je suprime la ligne new dans le constructeur)

        unsigned long ulNbReps; 
        unsigned long ulNbFichiers; 
        unsigned long ulTailleMo; 
        CRepertoire(char * cRepertoire = "c:"); 
        ~CRepertoire(void); 
        void ScanRep(char *cRepertoire); 
}; 

CRepertoire::CRepertoire(char * cRepertoire) 
{ 
   char * cNomReperoire = new char[strlen(cRepertoire)]; //Ligne qui pose probl&#232;me

   strcpy(cNomRepertoire, cRepertoire); 
   ulNbReps = 0; 
   ulNbFichiers = 0; 
   ulTailleMo = 0; 
   ScanRep(cNomRepertoire); 
} 

Et je l'appel ainsi CRepertoire CRepSource (cFileName);
J'ai control&#232; l'argument cFileName, il est correct puisque avec cette ecriture ca passe : 
char cNomReperoire[512];

luhtor · Answer

Le strlen ne prend pas en compte le caract&#232;re nul, donc faut rajouter une case &#224; ton tableau de caract&#232;re.

new chat[strlen(cRepertoire)+1];



Mais pourquoi se faire.... avec des char* alors que le C++ offre des string ^^

yserver · Answer

J'avais essay&#233; avec new chat[strlen(cRepertoire)+1];
Meme r&#233;sultat. Je vais revoir tout ca. Merci

nightlord666 · Answer

L'erreur vient du fait que tu redeclare ta variable cNomRepertoire. Tu lui dit de créer une variable qui existe deja, donc sa pose probleme... met plutot sa :
this->cNomRepertoire = new char[strlen(cRepertoire) + 1];

Le probleme ne vient donc pas du tout du new...

nightlord666 · Answer

Sa m'etonne d'ailleur que personne n'y ait pensé... Tout le monde regardait l'allocation, mais pas le reste de la ligne...

luhtor · Answer

NightLoad -> ya aucun probl&#232;me de ce cot&#233; la. Ou vois tu une
variable deja d&#233;clar&#233;e ? De toute facon, "this" est facultatif. Perso,
il rend le code plus lisible, mais c'est une question de gout :)



Sinon voila la solution.

char * cNomRepertoire = new char[strlen(cRepertoire)+1]; //Ligne qui pose probl&#232;me

memset(cNomRepertoire, 0, 
strlen(cRepertoire)+1);


 strcpy(cNomRepertoire, cRepertoire);
 





Sinon que fait la fonction scanrep ?

nightlord666 · Answer

Euh oui excuse... il faudra que je re-r&#233;vise mon C++, je suis trop habitu&#233; au C... car dans ta classe il y avais une variable nomm&#233;e cNomRepertoire et tu en redeclare une du m&#234;me nom dans ton constructeur.

Oula, je suis fatigu&#233; moi...

yserver · Answer

Merci pour vos reponse, je relirais tous ca plus tard et vous tiendrais au courrant.

Reponse a vos questions viendron plus tard.
merci a tous

yserver · Answer

J'ai enfin ma classe qui marche parcontre toujours pas avec l'operateur new. 
Voila ce que fait ma class c'est tout bete mais ca me manquait. 
J'ai pas encore eu le temps de recoder tout cela avec l'operateur new. Cependant j'ai une question supplementraie qui merite peut &#234;tre un autre poste :


        Il est plus performant d'utiliser malloc ou new? 


Autre question : 
        Voyez vous un moyen d'optimiser ce code? 


Encore une : 
        Pourquoi dans le constructeur je ne peux pas utiliser free(cNomRepertoire), la compilation est OK, mais a l'execution KO?


C'est pas fini : 
        Telle qu'elle je ne d&#233;saloue pas cNomRepertoire explicitement, mais lors de la d&#233;struction de la classe il est bien d&#233;salou&#233;?


Merci a tous. C'est tout pour l'instant 


class CRepertoire 
{ 
public: 
        char *cNomRepertoire; 
        unsigned long

                                        } 
                                //Si non c'est un fichier 
                                else 
                                        { 
                                        // ce n'est pas un r&#233;p&#232;rtoire donc le fichier est analys&#233; 
                                        strcpy(cChemin, cRepertoire); strcat(cChemin, "\"); strcat(cChemin, wData.cFileName);


                                        ulNbFichiers ++; 
                                        dwTaille = (wData.nFileSizeHigh * (MAXDWORD+1)) + wData.nFileSizeLow; 
                                        ulTailleMo += (int)(dwTaille/1048576); 
                                        } 
                                } 
                        } while ( FindNextFile ( hFind , &wData ) ) ; 
                } 
        FindClose( hFind ); 
}

vecchio56 · Answer

new ou malloc, c'est idem
tu dois toujours libérer. Comment le destructeur pourrait-il sevoir ce qu'il doit libérer?
Pour l'optimisation, oui: tu peux enlever tous les strcat qui reparcourent la chaine en entier, alors que tu l'a déja fait pour la copie
Il te faudrait une fonction strcpy qui renvoie un pointeur su la fin, et non sur le debut. Tu as la fonction de BruNews (bnstrcpy) mais qui ne marche que sous VC++. Sinon tu peux te faire la tienne

vecchio56 · Answer

free(cNomRepertoire) n'a pas de sens dans le constructeur (cNomRepertoire n'est pas initialisé à priori). Pourquoi tu veux faire ca?

yserver · Answer

le free(cNomRepertoire), il est bien entendu que je parle du destructeur.


Je remetrais une le code j'avais pas vu que le copier coller etait pas passe comme il faut.


class CRepertoire 
{ 
public: 
        char *cNomRepertoire; 
        unsigned long

                                        } 
                                //Si non c'est un fichier 
                                else 
                                        { 
                                        // ce n'est pas un r&#233;p&#232;rtoire donc le fichier est analys&#233; 
                                        strcpy(cChemin, cRepertoire); strcat(cChemin, "\"); strcat(cChemin, wData.cFileName);


                                        ulNbFichiers ++; 
                                        dwTaille = (wData.nFileSizeHigh * (MAXDWORD+1)) + wData.nFileSizeLow; 
                                        ulTailleMo += (int)(dwTaille/1048576); 
                                        } 
                                } 
                        } while ( FindNextFile ( hFind , &wData ) ) ; 
                } 
        FindClose( hFind ); 
}

yserver · Answer

Decidement.
class CRepertoire 
{ 
public: 
        char *cNomRepertoire; 
        unsigned long ulNbRep; 
        unsigned long ulNbFichiers; 
        unsigned long ulTailleMo; 


        CRepertoire(char *cRepertoire) 
        { 
                ulNbRep=0; 
                ulNbFichiers=0; 
                ulTailleMo=0; 
                cNomRepertoire = (char*) malloc(strlen(cRepertoire) * sizeof(char)); 
                strcpy(cNomRepertoire, cRepertoire); 
                ScanRep(cNomRepertoire); 
        } 
        ~CRepertoire(void) 
        { 
        } 
private: 
        void ScanRep (char *cRepertoire); 
}; 


void CRepertoire::ScanRep (char *cRepertoire) 
{ 
        //D&#233;claration des variables 
        char cChemin [512]; 
        DWORD dwTaille; 
        WIN32_FIND_DATA wData; 
        HANDLE hFind; 


        //Initialisation des variables 
        //Ajout de \*.* cChemin 
        strcpy(cChemin, cRepertoire); strcat(cChemin, "\*.*"); 
        //Initialisation du Handle de recherche de fichiers 
        hFind = FindFirstFile(cChemin, &wData); 
        //Suppresion de \*.* a cChemin 
        strcpy(cChemin, cRepertoire); 
        
        if (hFind != INVALID_HANDLE_VALUE) 
                { 
                do 
                        { 
                        if(wData.cFileName[0] != '.') 
                                { 
                                //Increment la barre de progression 
        
                                    //Si C'est un r&#233;pertoire 
                                if (wData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) 
                                        { 
        
                                        //puisque c'est un repertoire, on recupere la nouvelle adresse, et on va rentrer dedans...


                                        strcpy(cChemin, cRepertoire); strcat(cChemin, "\"); strcat(cChemin, wData.cFileName);


                                        //On rappelle la fonction pour qu'elle analyse le sous r&#233;pertoire 
                                        ScanRep(cChemin); 
                                        ulNbRep ++; 
                                        // revient un repertoire en arriere 
                                        strcpy(cChemin, cRepertoire); 
                                        } 
                                //Si non c'est un fichier 
                                else 
                                        { 
                                        // ce n'est pas un r&#233;p&#232;rtoire donc le fichier est analys&#233; 
                                        strcpy(cChemin, cRepertoire); strcat(cChemin, "\"); strcat(cChemin, wData.cFileName);


                                        ulNbFichiers ++; 
                                        dwTaille = (wData.nFileSizeHigh * (MAXDWORD+1)) + wData.nFileSizeLow; 
                                        ulTailleMo += (int)(dwTaille/1048576); 
                                        } 
                                } 
                        } while ( FindNextFile ( hFind , &wData ) ) ; 
                } 
        FindClose( hFind ); 
}

yserver · Answer

Pour l'optimisation oui j'avais deja vu la fonction de BruNews . Le gain est vraiment interessant?
Pas d'autre source d'optimisation? Car sur des repertoire de plusieurs Giga et milliers de fichiers.

Merci

vecchio56 · Answer

Le gain est d'autant plus intéressant que la chaine est longue et que le nombre de concaténations est important
De toutes facons, le plus lent seront les accès aux disques (induits par FindNextFile) donc les éventuelles optimisations ne serviron pas vraiment en comparaison

Operateur new allocation new

18 réponses

Votre réponse

Discussions similaires