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

Langage C++ Discussion :

se passer de new


Sujet :

Langage C++

  1. #1
    Membre régulier
    se passer de new
    bonjour,

    comment se passe-t-on de new?
    par exemple:
    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
    uniLex lexical::obtenirBlanc(){
      uniLex *uniLexTrouve=new BLANC;
      etat=0;
      while(true){
        switch(etat){
        case 0:
          c=scan.carSuiv();
          debutLex++;
          if(c=='\n'){
        ligne++;
        etat=1;
          }
          else if(c=='\r'||c=='\t'||c=' ')
             etat=1;
          else{
        uniLexTrouve->setEchec(true);
        return *uniLexTrouve;
          }
          break;
        case 1:
          c=scan.carSuiv();
          debutLex++;
          if(c=='\n'){
        ligne++;
        etat=1;
          }
          else if(c=='\r'||c=='\t'||c=' ')
        etat=1;
          else
        etat=2;
          break;
        case 2:
          scan.reculer(1);
          uniLexTrouve->setEchec(false);
          return *uniLexTrouve;
        }
      }
    }
     
    uniLex lexical::obtenirCommentaires(){
      uniLex *unilexTrouve=new COMMENTAIRES;
      while(true)
        switch(etat){
        case 0:
          c=scan.carSuiv();
          debutLex++;
          if(c=='|')
        etat=1;
          else{
        uniLexTrouve->setEchec(true);
        return *uniLexTrouve;
          }
          break;
        case 1:
          c=scan.carSuiv();
          debutLex++;
          if(c=='|')
        etat=2;
          else if(c==EOF){
        std::cerr<<"commentaires non terminés"<<std::endl;
        exit(1);
          }
          else if(c=='\n'){
        ligne;++;
        etat=1;
          }
          else
        etat=1;
          break;
        case 2:
          uniLexTrouve->setEchec(false);
          return *uniLexTrouve;
        }
    }
     
    uniLex lexical::obtenirId(){
      uniLex *unilexTrouve=new ID;
      std::string lexeme="";
      while(true)
        switch(etat){
        case 0:
          c=scan.carSuiv();
          debutLex++;
          if(c=='_'){
        lexeme+=c;
        etat=0;
          }
          else if(c>='a'&&c<='z'||c>='A'&&c<='Z'){
        lexeme+=c;
        etat=1;
          }
          else{
        uniLexTrouve->setEchec(true);
        return *uniLexTrouve;
          }
          break;
        case 1:
          c=scan.carSuiv();
          debutLex++;
          if(c>='a'&&c<='z'||c>='A'&&c<='Z'||c>='0'&&c<='9'||c=='_'){
        lexeme+=c;
        etat=1;
          }
          else
        etat=2;
          break;
        case 2:
          uniLexTrouve->setEchec(false);
          uniLexTrouve->setLex(ULEX::ID);
          uniLexTrouve->setLexeme(lexeme);
          return *uniLexTrouve;
        }
    }

  2. #2
    Membre régulier
    On peut s'en passer tout simplement en ne l'appelant pas.

    D'ailleurs, dans le code fourni, en dehors des manques qui font que ne comprend pas les définitions : uniLex *uniLexTrouve=new BLANC;. Ce dernier est rempli d'une fuite mémoire pour chaque appel de fonction car la mémoire allouée n'est pas libérée et l'objet est renvoyé par copie.

    La question aurait plus de sens si l'on pouvait préciser entre soit : ne pas écrire explicitement l'opérateur new OU ne pas faire d'allocation dynamique dans le code.

  3. #3
    Membre régulier
    c'était inspiré d'un livre, ils on en effet oublié les fuites de mémoire
    voici comment je suis arrivé à me passer de new:
    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
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    uniLex lexical::obtenirBlanc(){
      BLANC uniLexTrouve;
      while(true){
        switch(etat){
        case 0:
          c=scan.carSuiv();
          debutLex++;
          if(c=='\n'){
    	ligne++;
    	etat=1;
          }
          else if(c=='\r'||c=='\t'||c==' ')
    	etat=1;
          else{
    	uniLexTrouve.setEchec(true);
    	return uniLexTrouve;
          }
          break;
        case 1:
          c=scan.carSuiv();
          debutLex++;
          if(c=='\n'){
    	ligne++;
    	etat=1;
          }
          else if(c=='\r'||c=='\t'||c=' ')
    	etat=1;
          else
    	etat=2;
          break;
        case 2:
          scan.reculer(1);
          uniLexTrouve->setEchec(false);
          return uniLexTrouve;
        }
      }
    }
     
    uniLex lexical::obtenirCommentaires(){
      COMMENTAIRES unilexTrouve;
      while(true)
        switch(etat){
        case 0:
          c=scan.carSuiv();
          debutLex++;
          if(c=='|')
    	etat=1;
          else{
    	uniLexTrouve.setEchec(true);
    	return uniLexTrouve;
          }
          break;
        case 1:
          c=scan.carSuiv();
          debutLex++;
          if(c=='|')
    	etat=2;
          else if(c==EOF){
    	std::cerr<<"commentaires non terminés"<<std::endl;
    	exit(1);
          }
          else if(c=='\n'){
    	ligne;++;
    	etat=1;
          }
          else
    	etat=1;
          break;
        case 2:
          uniLexTrouve.setEchec(false);
          return uniLexTrouve;
        }
    }
     
    uniLex lexical::obtenirId(){
      ID unilexTrouve;
      std::string lexeme="";
      while(true)
        switch(etat){
        case 0:
          c=scan.carSuiv();
          debutLex++;
          if(c=='_'){
    	lexeme+=c;
    	etat=0;
          }
          else if(c>='a'&&c<='z'||c>='A'&&c<='Z'){
    	lexeme+=c;
    	etat=1;
          }
          else{
    	uniLexTrouve.setEchec(true);
    	return uniLexTrouve;
          }
          break;
        case 1:
          c=scan.carSuiv();
          debutLex++;
          if(c>='a'&&c<='z'||c>='A'&&c<='Z'||c>='0'&&c<='9'||c=='_'){
    	lexeme+=c;
    	etat=1;
          }
          else
    	etat=2;
          break;
        case 2:
          uniLexTrouve.setEchec(false);
          uniLexTrouve.setLex(ULEX::ID);
          uniLexTrouve.setLexeme(lexeme);
          return uniLexTrouve;
        }
    }
     
    uniLex lexical::obtenirFin(){
      fin unilexTrouve;
      while(true)
        switch(etat){
        case 0:
          c=scan.carSuiv();
          debutLex++;
          if(c==EOF)
    	etat=1;
          else{
    	uniLexTrouve.setEchec(true);
    	return uniLexTrouve;
          }
          break;
        case 1:
          uniLexTrouve.setLex(ULEX:<img src="images/smilies/icon_biggrin.gif" border="0" alt="" title=":D" class="inlineimg" />OLAR);
          return uniLexTrouve;
        }
    }

###raw>template_hook.ano_emploi###