Allocation dynamique de char* ....

Bonjour à tous....

Avant d'acheter un flingue pour de bon, je me suis dit qu'il pourrait etre judicieux de demander de l'aide quelque part... voila, je vais vous exposer le problême. Voici tout d'abord le fragment de code correspondant :

/* Constructeur qui marche bien :) */
String::String(char* chaine) {
                                      
  sz = new char[lstrlen(chaine) + 1];
  lstrcpy(sz, chaine);                                  
 }

/* LE problême vient d'ici !!*/
String DLLEXPORT String::operator=(char* chaine) {
 
  Alloc_Buffer(this->sz, lstrlen(chaine) + 1);
  lstrcpy(this->sz, chaine);
 
  return *this;     
 }

/* Peut-etre ce code vous serez utile... */
void String::Alloc_Buffer(char* szBuffer, UINT uSize) {
 
  char* chaine = new char[lstrlen(szBuffer) + 1];
  lstrcpy(chaine, szBuffer);
 
  delete szBuffer;
 
  szBuffer = new char[uSize];
  lstrcpy(szBuffer, chaine);
 
  delete chaine;                
 }

>Voila, donc j'explique maintenant le souci...alors quand j'instancie mon objet de type String avec un char* (fonction 1), et que je l'affiche genre avec cout, tout marche nikel..mais quand je déclare d'abord la variable à blanc (j'ai un constructeur aussi pour ça) puis je lui affecte le char*, ça affiche NADA...

code de traduction :

/* Marche */
String x = "loll";

cout << x.sz << endl;


/* Marche pas!! */
String x;

x = "looll";
cout << x.sz << endl;


voila, merci d'avance...soit de m'aider, soit de confirmer la necessité du flingue -_-"

Bonjour,

void String::Alloc_Buffer(char** szBuffer, UINT uSize) {
 
  char* chaine = new char[lstrlen(*szBuffer) + 1];
  lstrcpy(chaine, *szBuffer);
 
  delete [] *szBuffer;
 
  *szBuffer = new char[uSize];
  lstrcpy(*szBuffer, chaine);
 
  delete chaine;                
 }

Bon j'ai pas le temps de compiler pour vérifier, mais un truc dans ce genre devrais aller mieux.

Cordialement

Fred Cailleau-Lepetit ( [ Lien ])

désolé d'etre nul mais...interet d'avoir un char** plutot qu'un char* ?? je ne calle pas...qu'est-ce qui était faux dans mon code et que tu semblerais avoir rectifié ? Explique moi je suis nul....

Parce que tu modifies la valeur du pointeur, tu ne peux donc pas le passer par valeur

Jcroyais qu'un passage de char* se faisait toujours par référence et de manière automatique... jvais méditer la dessus...merci...

Bon pour que tu comprennes oubli que c'est un pointeur imagine que c'est un entier int

tu as ta fonction
void mafonction(int mavaleur)
{
mavaleur = 3;
}

si tu fait
a = 2;
mafonction(a);
cout << a ;

cela affichera 2, car la modification de mavaleur n'as pas dépassé la porté de la fonction.

si tu as

void mafonction(int* mavaleur)
{
*mavaleur = 3;
}

l'appel de mafonction(&a); modifiera la valeur de a;

maintenant si tu remplace int par char* tu obtiens void mafonction(char** mavaleur)

et donc tu pourras modifier l'adresse contenue dans le pointeur (et aussi ce qui se trouve à l'adresse indiqué par le pointeur)

J'espère avoir été clair, la notion de pointeur est toujours assez difficile à comprendre au début. Mais avec un peu de persévérence tu finiras par comprendre.

Cordialement

Fred Cailleau-Lepetit ( [ Lien ])

Tu n'a qu'a prendre un exemple simple: void f(int* x) { // x est une variable locale x = 0; } int main() { int* x = new int; f(x); // ici tu vois bien que x ne vaut pas 0 }

Bonsoir

Je vous remercie pour ces explications! fredcl, merci, ton code marche et a résolu le problême! Par contre, je ne pensais pas être débutant avec les pointeurs...je connaissais le systeme d'appel par valeur et par référence avec des types... mais je ne savais pas avec char*... merci à vous deux en tout cas :)

/* LE problême vient d'ici !!*/
String DLLEXPORT String::operator=(char* chaine) {
 
  Alloc_Buffer(this->sz, lstrlen(chaine) + 1);
  lstrcpy(this->sz, chaine);
 
  return *this;     
 }

...

String & DLLEXPORT String::operator = (const char * chaine)
{
  ...
  return *this;
}

avec ton « String DLLEXPORT ... » et ton « return *this » tu vas causer
une copie de ta String, retourne une référence, pas une copie, parce que
tu dois retourner « *this » et non une copie de « *this » ...

tu devrais aussi te faire des méthodes privées pour manager ton buffer
et non l'envoyer un peu n'importe où pour le manager ...

String & DLLEXPORT String::operator = ( const char * la_chaine )
{
  size_t len = strlen( la_chaine );

  if ( this->_grow( len ) )
  {
    // copie « la_chaine » dans ton « this->sz » ...
  }
  return *this;
}

String & DLLEXPORT String::operator = ( const String & str )
{
  if ( this->_grow( str.Length() ) )
  {
    // copie « str » dans ton « this->sz » ...
  }
  return *this;
}
//...

bool DLLEXPORT String::_grow( size_t new_size )
{
  if ( new_size >= this->current_size ) // this->current_size représente l'espace mémoire occupé par this->sz
  {
    char * new_buff = new char[new_size + EXTRA_SIZE]; // disont que EXTRA_SIZE vaut 8

    if ( this->current_size > 0 )
    {
      if ( this->taille_de_sz > 0 ) // this->taille_de_sz représente le nombre de caractère dans this->sz
      {
        memcpy(new_buff, this->sz, taille_de_sz);
      }
      delete [] this->sz;
    }
    this->sz = new_buff;
    this->current_size = new_size;
  }
  return true;
}


ce n'est qu'un exemple, faut pas faire de copy/paste ...
et n'utilise pas les attributes de ta classe directement!

class String
{
public:
  String();
  ~String();
  // ...
  const char * getBuffer() const
  {
    return m_buffer;
  }
  size_t getLength() const
  {
    return m_length;
  }
  // ...
private:
  char * m_buffer;
  size_t m_length;
  // ...
};


~(.:: NitRic ::.)~