Attribuées de manière dynamique à 2 dimensions de la matrice de

Je suis en train de construire tableau à deux dimensions en allouant dynamiquement. Ma question est ce que c'est possible que sa première dimension permettrait de prendre des 100 valeurs, puis la deuxième dimension prendrait montant variable de valeurs en fonction de mon problème? Si c'est possible, alors comment je pourrais y accéder? Comment pourrais-je savoir la deuxième dimension est la limite?

Cela dépend totalement de comment mettre en œuvre le tableau 2D. Est-il un tableau de tableaux (par exemple,int matrix[M][N]) ou est-ce une gamme standard, que vous êtes en appliquant deux "logiques" dimensions (par exemple,int matrix[M*N])?

OriginalL'auteur tryu hjkl | 2013-11-12

  1. 5

    (Voir les commentaires dans le code)

    Comme un résultat que vous obtiendrez un tableau comme le suivant:

    Attribuées de manière dynamique à 2 dimensions de la matrice de

    //Create an array that will contain required variables of the required values
//which will help you to make each row of it's own lenght.
arrOfLengthOfRows[NUMBER_OF_ROWS] = {value_1, value_2, ..., value_theLast};

int **array;
array = malloc(N * sizeof(int *));   //`N` is the number of rows, as on the pic.

/*
if(array == NULL) {
    printf("There is not enough memory.\n");
    exit (EXIT_FAILURE);
}
*/

//Here we make each row of it's own, individual length.
for(i = 0; i < N; i++) {
    array[i] = malloc(arrOfLengthOfRows[i] * sizeof(int)); 

/*
if(array[i] == NULL) { 
    printf("There is not enough memory.\n");
    exit (EXIT_FAILURE);        
}
*/
}
    C'est ignorer la question de la demande d'dynamiquement la taille intérieure de tableaux.
    Que voulez-vous dire exactement? (Si j'ai compris correctement la question, je vais supprimer cette réponse)
    <pedenatic>Votre code ne compile pas. Je voudrais supprimer la #include, ou enveloppez-le reste du code dans une fonction. Y compris la #include ligne un peu implique que c'est un compilable exemple.
    À partir de la question: "puis deuxième dimension prendrait montant variable de valeurs en fonction de mon problème". Vous êtes à l'attribution d'un nombre fixe d'éléments.
    Beau travail. +1 pour l'image, et l'idée de suivi des longueurs dans un tableau séparé.

    OriginalL'auteur yulian

  2. 2

    Vous pouvez utiliser le tableau de 100 pointeurs:

    int *arr[100];

    ensuite, vous pouvez allouer dynamiquement de la mémoire pour chacun des 100 pointeurs séparément de la taille que vous voulez, mais vous devez vous rappeler de combien de mémoire (pour chaque pointeur) vous avez alloué, vous ne pouvez pas attendre compilateur C pour le retenir ou le dire à vous, c'est à dire sizeof ne fonctionnera pas ici.

    Pour accéder à tout (autorisé, dans les limites) de l'emplacement, vous pouvez simplement utiliser 2D matrice de notation par exemple, pour accéder à 5th emplacement de mémoire allouée à 20th pointeur vous pouvez utiliser arr[20][5] ou *(arr[20] + 5).

    Pour garder une trace du nombre d'éléments dans chaque intérieur matrice, envelopper les tableaux dans une structure qui stocke la taille, ou la modifier à int **arr[100] et l'utilisation "de fin null" sur les valeurs.

    OriginalL'auteur Don't You Worry Child

  3. 1

    Je crois que l'OP veut un morceau unique de la mémoire pour le tableau, et est prêt à les réparer l'une des dimensions de l'obtenir. J'ai souvent aimons à le faire lors du codage en C.

    Nous avons tous l'habitude d'être en mesure de faire double x[4][]; et le compilateur sait plus quoi faire. Mais quelqu'un a apparemment foiré que peut-être même pour une bonne raison.

    Suivantes toutefois fonctionne toujours et permet d'utiliser de grands morceaux de mémoire au lieu d'avoir à faire beaucoup de pointeur de gestion.

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

//double x[4][];

struct foo {
    double y[4];
} * x;

void
main(int ac, char * av[])
{
    double * dp;
    int max_x = 10;
    int i;

    x = calloc(max_x, sizeof(struct foo));
    x[0].y[0] = 0.23;
    x[0].y[1] = 0.45;
    x[9].y[0] = 1.23;
    x[9].y[1] = 1.45;

    dp = x[9].y;
    for (i = 0; i < 4; i++)
        if (dp[i] > 0)
            printf("%f\n", dp[i]);
}

    Le truc, c'est de déclarer la dimension fixe dans une struct. Mais gardez à l'esprit que la première dimension est la dimension dynamique et la "deuxième" est fixe. Et c'est le contraire de l'ancienne ...

    Vous aurez pour suivre la taille de votre dimension dynamique sur votre propre - sizeof ne peux pas vous aider avec ça.

    Utilisation anonyme des bidules, vous pourriez même être en mesure de git débarrasser de 'y'.

    OriginalL'auteur duanev

  4. 1

    À l'aide d'un seul pointeur:

    int *arr = (int *)malloc(r * c * sizeof(int));

    /* comment accéder aux éléments du tableau */

    for (i = 0; i <  r; i++)
  for (j = 0; j < c; j++)
     *(arr + i*c + j) = ++count;  //count initialized as, int count=0;

    À l'aide du pointeur vers un pointeur:

    int **arr = (int **)malloc(r * sizeof(int *));
for (i=0; i<r; i++)
     arr[i] = (int *)malloc(c * sizeof(int));

    Dans ce cas, vous pouvez accéder aux éléments du tableau comme vous l'accès allouée statiquement tableau.

    OriginalL'auteur Aashish