allocation de mémoire double pointeur

Question

J'essaie actuellement d'allouer la même quantité de mémoire pour un double pointeur. Je prends un caractère ** et je veux utiliser un tri à bulles sur ce personnage **. Donc, je crée un temp char ** et maintenant je me demande comment allouer correctement de la mémoire afin que je puisse retourner ce char temp ** à une autre méthode.

Je sais que la façon dont j'alloue en ce moment n'a pas l'air juste et ça ne marche certainement pas ... sinon je ne poserais pas cette question. Si quelqu'un pouvait répondre avec quelques conseils utiles, je l'apprécierais grandement!

char** bubble_sort(char **filenames, int n) 
{ 
    int i; 
    char **new_list; 
    new_list = malloc(sizeof(filenames)); 
    for (i = 0; i < n; i++) 
    { 
     // malloc(file_list.size * sizeof(int)); 
     new_list[i] = filenames[i]; 
    } 
    for (i = 0; i < n; i++) 
    { 
     printf("%d: %s\n", i, new_list[i]); 
    } 

    int x; 
    int y; 
    for(x=0; x<n; x++) 
    { 
      for(y=0; y<n-1; y++) 
      { 
        if(new_list[y]>new_list[y+1]) 
        { 
          char *temp = new_list[y+1]; 
          new_list[y+1] = new_list[y]; 
          new_list[y] = temp; 
        } 
      } 
    } 
    for (i = 0; i < n; i++) 
     { 
      printf("%d: %s\n", i, new_list[i]); 
     } 
    return new_list; 
} 

Answer 1

Voici la copie de travail du programme:

#include <cstdio> 
#include <cstdlib> 
#include <cstring> 

char** bubble_sort(const char **filenames, int n) 
{ 
    int i; 
    char **new_list; 
    new_list = (char**) malloc(sizeof(*new_list) * n); 
    for (i = 0; i < n; i++) 
    { 
     new_list[i] = (char*) filenames[i]; 
    } 

    printf("Initial list:\n"); 
    for (i = 0; i < n; i++) 
    { 
     printf("%d: %s\n", i, new_list[i]); 
    } 

    int x; 
    int y; 

    printf("List is sorted:\n"); 
    for(x=0; x<n; x++) 
    { 
      for(y=0; y<n-1; y++) 
      { 
        if(strcmp(new_list[y],new_list[y+1])>0) 
        { 
          char *temp = new_list[y+1]; 
          new_list[y+1] = new_list[y]; 
          new_list[y] = temp; 
        } 
      } 
    } 
    for (i = 0; i < n; i++) 
     { 
      printf("%d: %s\n", i, new_list[i]); 
     } 
    return new_list; 
} 

int main(){ 
    const char *ar[5]={ 
     "eee", "aaa", "bbb", "ccc", "ddd", 
    }; 
    bubble_sort(ar, 5); 
    return (0); 
} 

encore, gardez à l'esprit que votre style de programmation ressemble plus à C que C++ (qui est pas toujours une mauvaise chose).

Si vous souhaitez allouer de nouvelles chaînes pour vos éléments de tableau, vous devez changer la première pour comme ceci:

for (i = 0; i < n; i++) 
{ 
    //new_list[i] = (char*) filenames[i]; 
    new_list[i] = (char*) malloc(sizeof(**new_list) * (strlen(filenames[i]) + 1)); 
    strcpy(new_list[i], filenames[i]); 
} 

Et ceci est la la version C (première était la version C++). Notez que le tableau de chaînes a tous ses éléments nouvellement alloués, et n'utilise pas les chaînes initiales du paramètre d'entrée .:

#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 

char** bubble_sort(char **filenames, int n) 
{ 
    int i; 
    char **new_list; 
    new_list = malloc(sizeof(*new_list) * n); 
    for (i = 0; i < n; i++) 
    { 
     //new_list[i] = (char*) filenames[i]; 
     new_list[i] = malloc(sizeof(**new_list) * (strlen(filenames[i]) + 1)); 
     strcpy(new_list[i], filenames[i]); 
    } 

    printf("Initial list:\n"); 
    for (i = 0; i < n; i++) 
    { 
     printf("%d: %s\n", i, new_list[i]); 
    } 

    int x; 
    int y; 

    printf("List is sorted:\n"); 
    for(x=0; x<n; x++) 
    { 
      for(y=0; y<n-1; y++) 
      { 
        if(strcmp(new_list[y],new_list[y+1])>0) 
        { 
          char *temp = new_list[y+1]; 
          new_list[y+1] = new_list[y]; 
          new_list[y] = temp; 
        } 
      } 
    } 
    for (i = 0; i < n; i++) 
     { 
      printf("%d: %s\n", i, new_list[i]); 
     } 
    return new_list; 
} 

int main(){ 
    char *ar[5]={ 
     "eee", "aaa", "bbb", "ccc", "ddd", 
    }; 
    bubble_sort(ar, 5); 
    return (0); 
} 

Answer 2

filenames est un pointeur vers pointeur vers un char, donc sur cette ligne ...

new_list = malloc(sizeof(filenames)); 

... vous allouer le montant de la taille du pointeur (à pointeur), ce qui n'est pas ce que tu veux.

Vous voulez probablement malloc(sizeof(filenames) * n); qui vous donnera l'espace pour les pointeurs n.

Answer 3

char** bubble_sort(char **filenames, int n) 
{ 
    int i; 
    char **new_list; 
    new_list = malloc(sizeof(filenames)); 

Ce code alloue assez d'espace pour stocker un seul pointeur (sizeof(filenames) est probablement la plupart du temps 4), et donne l'adresse de ce pointeur vers new_list. Si vous voulez accéder à ce que new_ligne désigne comme un tableau (et je sais que c'est le cas, car vous avez essayé de le faire ci-dessous), vous devrez allouer assez d'espace pour ses éléments.

Answer 4

Ceci est en quelque sorte un doublon. Voir: Creating `char ***data`?

Il y a de sérieux problèmes de performance de mémoire en ce qui concerne l'allocation de char ** pour un tableau 2D. Mieux vaut utiliser un char * et un schéma d'indexation. De cette façon, vous obtenez un morceau de mémoire contigu. Vous pouvez également utiliser un vecteur std :: un avec un tel schéma.

Si vous devez allouer un caractère **, la boucle for est tout ce que vous pouvez faire AFAIK. Mais faites au moins un sous-programme! :)