Les tableaux multidimensionnels alloués par calloc

J'ai une question sur la façon dont la mémoire est allouée lorsque je calloc. J'ai eu un coup d'oeil à cette question, mais il ne traite pas de la façon dont la mémoire est allouée dans le cas d'un allouée dynamiquement tableau à deux dimensions.

Je me demandais si il y avait une différence dans la mémoire de représentation entre l'une des trois façons suivantes d'allouer dynamiquement un tableau 2D.

De Type 1:

double  **array1;
int ii;

array1 = calloc(10, sizeof(double *));
for(ii = 0; ii < 10; ii++) { 
   array1[ii] = calloc(10, sizeof(double));
}
//Then access array elements like array1[ii][jj]

De Type 2:

double  **array1;
int ii;

array1 = calloc(10 * 10, sizeof(double *));
//Then access array elements like array1[ii + 10*jj]

Type 3:

double  **array1;
int ii;

array1 = malloc(10 * 10, sizeof(double *));
//Then access array elements like array1[ii + 10*jj]

De ce que je comprends de calloc et malloc, la différence entre les deux derniers, c'est que calloc est mise à zéro de tous les éléments de la matrice, alors que malloc ne sera pas. Mais qui sont les deux premières façons de définir la matrice d'équivalent dans la mémoire?

De Type 2 et de Type 3 sont fondamentalement la même chose, à l'exception de la mémoire sera mis à 0 avec calloc. Ne sais pas si il y a une vraie différence avec le Type 1 bien que.
vraiment juste l'espace supplémentaire pour les pointeurs et le fait que les blocs de 10 doubles, peut-être non contigus
Oh, en fait, ne pense pas de cette. Bon point.
Les cas 2 et 3 ne pas allouer de doubles.
double possible de Comment sont multi-dimensions des tableaux formatés en mémoire?

OriginalL'auteur Kitchi | 2013-05-23

  1. 6

    Sont les deux premières façons de définir la matrice d'équivalent dans la mémoire?

    Pas tout à fait. Dans le second type, ils sont presque certainement contigus, alors que dans le premier type, ce n'est pas sûr.

    De Type 1: représentation en mémoire ressemblera à ceci: 

              +---+---+---+---+---+---+---+---+---+---+
    double| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |   
          +---+---+---+---+---+---+---+---+---+---+ 
            ^
            |------------------------------------                                     
                .   .   .   .   .   .   .   .   |    //ten rows of doubles
                                                -
          +---+---+---+---+---+---+---+---+---+--|+
    double| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0||   
          +---+---+---+---+---+---+---+---+---+--|+
            ^   .   .   .                       -
            |   ^   ^   ^   .   .   .   .   .   |
            |   |   |   |   ^   ^   ^   ^   ^   |
          +- | -+- | -+- | -+- | -+- | -+- | -+- | -+- | -+- | -+- | -+
array1[ii]| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | //each cell points to ten doubles
          +---+---+---+---+---+---+---+---+---+---+
            ^
            |
            |
          +- | -+
    array1| | |
          +---+

    De Type 2: représentation en mémoire ressemblera à ceci:

              +---+---+---+---+---+---+---+---+---+---+     +---+
    double| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 |  
          +---+---+---+---+---+---+---+---+---+---+     +---+
            ^   ^   ^   ^   ^   ^   ^   ^   ^   ^         ^
            |   |   |   |   |   |   |   |   |   |         |
            |   |   |   |   |   |   |   |   |   |         |
          +- | -+- | -+- | -+- | -+- | -+- | -+- | -+- | -+- | -+- | -+     +- | -+
array1[ii]| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | ... |99 | //each cell points to one double
          +---+---+---+---+---+---+---+---+---+---+     +---+
            ^
            |
            |
          +- | -+
    array1| | |
          +---+

    OriginalL'auteur Ziezi

  2. 1

    Exemple Simple 

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

int **d ;
int sum();

//----------------------------------------------  
int main(){

    d = (int **)calloc(3,sizeof(int*));
    printf("\n%d",sum());     
}

//-----------------------------------------------
int sum(){
int s = 0;
for(int i = 0; i < 3; i++)
    d[i] = (int *) calloc (3,sizeof(int));

for(int i = 0; i < 3; i++){ 
    for(int j = 0; j < 3; j++){
        d[i][j] = i+j;
        s += d[i][j];
        printf("\n array[%d][%d]-> %d",i,j,d[i][j]);
     }
}
return s;
}

    OriginalL'auteur Monis Majeed

  3. -1

    Dans la première méthode, vous allouer 10 pointeurs de double, et 100 à double. Dans le second cas, vous allouer 100 pointeurs à double.L'autre différence est que dans le second cas, vous allouer un gros bloc de mémoire, de sorte que tous les éléments de votre tableau sont dans le même bloc. Dans la première méthode, chaque "ligne" de votre tableau est dans un bloc différent que les autres.
    Bien que, dans le second cas, votre tableau doit être un double* au lieu d'un double**, parce que, dans cette façon de répartir, de votre tableau ne contient que des pointeurs de double de double.

    Tout d'abord deux façons de ne pas utiliser la même quantité de mémoire. La première méthode utilise dix fois la taille d'origine d'un pointeur de plus.
    Première méthode : 10 pointeurs, 100 double, deuxième méthode : 100 pointeurs, pas de double, ouais, pas même montant de mon mauvais. Mais la deuxième méthode n'a pas encore de double alloué.
    Édité pour les corrections.

    OriginalL'auteur Marrow Gnawer

  4. -1

    Sur le cas 1, vous faites: 

    array1[0] -> [memory area of 10]
array1[1] -> [memory area of 10] ...
array1[N] -> [memory area of 10] ...

    Remarque: Vous ne pouvez pas supposer que la zone de mémoire est continue, il existe peut-être des lacunes.

    Sur le cas 2 que vous faites: 

    array1 -> [memory area of 100]

    Le cas 3 est le même que le cas 2, mais ce n'est pas de l'initialisation de la mémoire. La différence entre le cas 1 et 2 & 3, c'est que le premier cas vous avez vraiment 2D structure de la mémoire. Par exemple si vous voulez échanger les lignes 1 et 2, vous pouvez juste changer les pointeurs:

    help      = array1[1] 
array1[1] = array1[2] 
array1[2] = help

    Mais si vous voulez faire la même chose dans les 2&3 cas où vous avez besoin pour faire du vrai memcpy. Ce qu'il faut utiliser? Tout dépend de ce que vous faites.

    La première méthode utilise peu plus de mémoire: si vous avez des tableau de 1000x10 puis la première version de l'utilisation 1000*8 + 1000*10*8 (sur système 64 bits), tandis que les 2&3 utilisera uniquement 1000*10*8.

    Les cas 2 et 3, inférieur ou égal mémoire, puis la première.
    Vous avez absolument raison. C'est ce que j'ai essayé de l'expliquer sur le dernier paragraphe avec les chiffres, mais a 'typo' en disant: "deuxième", comme c'était supposé être "premier". J'ai édité le post pour cela.
    Vous êtes conscient que les cas 2 et 3 ne pas allouer de la double à tous, mais seuls les pointeurs à ceux-ci, êtes-vous?
    Eh bien ils ont tous les deux allouer partie de la mémoire (pas le double de la mémoire ou double* la mémoire, c'est juste de la mémoire!) et avec 64bit machine sizeof(double*) == sizeof(double) == 8 mais sur 32 bits machine sizeof(double*) == 4, alors que sizeof(double) == 8. Donc, oui, vous avez raison, le cas 2&3 sur le code d'exemple deux sont mauvais, ils devraient allouer de la mémoire des éléments de taille double, pas de double*.

    OriginalL'auteur susundberg