C++ allocation dynamique de la mémoire en fonction des novices de la question

Je recherche d'une fuite de mémoire et de ce que je vois, le problème ressemble à ceci:

int main(){
    char *cp = 0;
    func(cp);
    //code
    delete[] cp;
}

void func(char *cp){
    cp = new char[100];
}

À l' //code commentaire, je m'attendais à cp pour pointer vers la mémoire allouée, mais c'est toujours un pointeur null sens je n'ai jamais effacer la mémoire. Ce que je fais wroing?

Je suppose cbuf était censé être cp?
comment poser un véritable code. À moins que le code est couper et coller, il y a le posability de vous ajout d'erreurs. Cela fait juste thigs plus difficile et nous de la résolution de coupe et de paster d'erreurs comme cbuf -> cp
Désolé, je vais garder cela à l'esprit pour la prochaine fois. Oui cbuf était censé être le cp

OriginalL'auteur | 2009-12-18

  1. 12
    void func(char *cp){
    cp = new char[100];
}

    Dans cette fonction, char *cp est un "pointeur d'être dépassé par copie" ce qui signifie qu'ils pointent vers la même adresse mémoire, mais ils ne sont pas les même pointeur. Lorsque vous modifiez le pointeur à l'intérieur, ce qui rend point à un autre endroit, le pointeur d'origine qui a été adopté conservera pointant vers 0.

    Merci, résolu d'amende. Très explication claire.
    Merci 🙂

    OriginalL'auteur André Pena

  2. 18

    De l'affectation d' cp la valeur de la mémoire allouée. Cependant, c'est une variable sur la pile: une copie de la cp principal! cp est locale à la fonction que vous utilisez.

    Ce que vous voulez, c'est une référence:

    void func(char *& cp)

    Ce sera alias cp être le paramètre transmis.

    OriginalL'auteur GManNickG

  3. 6

    Le paramètre cp est une variable locale de la fonction de changement il ne modifie rien en dehors de la fonction. Une meilleure façon d'écrire la fonction est:

    char * func(){
    return new char[100];
}

    Et de ne pas le faire directement à votre question, mais vous devriez probablement utiliser des std::string et std::vector plutôt que des tableaux alloués dynamiquement.

    Hmm, deux downvotes. Pas que je me soucie en particulier, mais d'autres pourraient l'avantage de savoir quel est le problème avec cette réponse.
    Rien de ce que je peux voir. Si vous allez remarquer quelque chose comme le C++ fonctions que vous avez mentionné, je pense que c'est probablement une bonne chose d'ajouter aussi une partie de ne pas coder en dur la taille de la matrice. En outre, si vous allez utiliser ces fonctionnalités, vous avez probablement envie de passer un pointeur vers un en référence à la créer, ou bien passer un déjà créé un par référence afin d'éviter le constructeur de copie de pénalité... mais il n'y a vraiment rien de MAL avec cette réponse.
    Les pointeurs n'ont pas un constructeur de copie.
    Je faisais allusion à std::String et std::vector en parlant "du c++ fonctions que vous avez mentionné." Je ne déforme ma réponse, désolé pour la confusion. Pour ce que vous avez, je voudrais ajouter "ne pas coder en dur...". le reste est en se référant à la "fonctionnalités c++."

    OriginalL'auteur

  4. 1

    Vous êtes de passage dans cbuf, pas cp.

    même si il était de passage *cp, il resterait pointant vers 0 après //code
    Ce n'est pas grave, parce que vous êtes également le passage par valeur.

    OriginalL'auteur Skilldrick

  5. 1

    La fonction est seulement la modification d'une COPIE de cp. Utiliser une référence à la place.

    OriginalL'auteur Jesse Emond

  6. 1

    Bien que les références sont merveilleux en offrant une interface intuitive de l'abstraction, renforcée par le C++11 références rvalue pour fonction de permettre le chaînage (et d'autres ésotérique de codage), il est permis de penser qu'ils fournissent toute sécurité (à savoir pourquoi est-ce une référence considéré comme plus sûr que d'un pointeur)
    Il y a des cas où il est préférable de régler le dessus avec un pointeur de pointeur de fonction en argument.
    En particulier lorsqu'il est nécessaire de maintenir un code ansi c et c++. 

    #include <iostream>

using namespace std;

void func(char ** cp) {
    *cp = new char[100];
    //do something useful
    (*cp)[0] = 'A';
}

void func(char *& cp) {
    cp = new char[100];
    //do something useful
    cp[0] = 'B';
}

int main(int argc, char** argv) {
    char * cp;
    //pointer to pointer
    func(&cp);
    cout << "Index 0 : " << cp[0] << '\n' << flush;
    delete[] cp; //remember to delete!!
    //pointer to ref
    func(cp);
    cout << "Index 0: " << cp[0] << '\n' << flush;
    delete[] cp;
    return 0;
}

    Bien sûr la disposition de ressources de la mémoire hors de la portée de la instatiating fonction désobéit RAII.

    OriginalL'auteur claydonkey

  7. 0

    Comme GMan et Neil dit, pour le travail, vous aurez à changer func:

    char* func();

    ou void func(char*& p);

    qui permettra de résoudre votre problème immédiat.

    Il est, cependant, un problème de maintenance. Dans les deux cas, la fonction retourne un pointeur. Ce n'est pas précisé à l'utilisateur du func est que le pointeur retourné devra être supprimé. Pour cette raison, généralement éviter cette construction à moins de 100% est nécessaire. Plutôt:

    1. Aider l'utilisateur à allouer la bonne quantité de mémoire qui peut ensuite être transmis à la touche func
    2. Utiliser un objet pour stocker la mémoire allouée. L'objet peut alors supprimer le tableau de caractères lorsqu'elle est détruite.

    Donc pour le code C++, je vous recommande:

    
class CBuf
{
public
    CBuf() 
    {
        iBuf = new char[100];
    }
    ~CBuf
    {
        delete[] iBuf;
    }
    char* func()
    {
        //do stuff;
        return iBuf;
    }
private:
    char* iBuf;
};

int main()
    {
    CBuf cb;
    char* mychar = cb.func();
    //do stuff with character array

    //destructor gets called here because cb goes out of scope
    }

    Cependant, dans la programmation en C en particulier, il pourrait être de 100% nécessaires pour avoir une sorte de fonction pour créer le tableau. Par conséquent, dans la programmation en C, vous pouvez remplacer le destructeur avec un CreateCBuf et DestroyCBuf fonction. De cette manière l'utilisateur de votre bibliothèque sait que la mémoire tampon est retourné doit être détruit.

    Puis-je vous demander quel est le problème avec std::vector?
    std:vecteur est fine. Il gère l'ensemble de la gestion de la mémoire pour vous. Le problème dans OPs par exemple, que la propriété est très incertaine.

    OriginalL'auteur doron