0
votes

Comment allouer une gamme 3D de pointeurs de caractère?

J'ai une gamme 3D de Pointers de Char: Char *** Semicols . Et je veux que les valeurs soient quelque chose dans le sens de xxx

et ainsi de suite. J'ai un Char ** args dans lequel j'ai été aussi stocké et je connais également le nombre de points-virgules dans ce tableau. Je souhaite créer plus petit char ** args qui ont la structure mentionnée ci-dessus, donc semicol [0] = {"ls", "~"} . Mais je ne connais pas le nombre de chaînes pour chaque argument de point-virgule à l'avance à l'avance, je ne peux donc pas en faire un statique * semicols [] [] . Alors, comment suis-je raisonnablement malloc pour un tableau 3D, ou y a-t-il une meilleure façon de faire ce que je tente de faire?


5 commentaires

Char *** Semicols n'est pas un tableau, mais un pointeur sur un pointeur sur un pointeur de char . Idem pour char ** args , juste une indirection moins.


Ah oui, désolé, je travaille avec eux comme si elles étaient des matrices, même si ce n'est pas un terme correct à utiliser.


Vous essayez donc de construire une gamme de lignes de commande à passer à Execvp ?


Oui, exactement! J'essaie de mettre en œuvre l'utilisation de; signe spécial


Rappelez-vous juste que vous devez allouer Pointeurs pour chaque niveau d'indirection sauf le dernier - que vous devez allouer suffisamment de stockage pour tout ce qui sera stocké là-bas. Donc, pour Char *** Semicols , vous devez allouer x nombre de pointeurs pour les lignes de commande, y nombre de pointeurs à pointer sur chaque chaîne Chaque commande, puis stockage pour chacune des pièces de commande que vous attribuez à chacun des pointeurs y . (Notez également - devenir un programmeur 3 étoiles n'est généralement pas un complément :)


3 Réponses :


0
votes

Voici ce que j'ai utilisé pour la matrice 3D une fois.

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

int main(){
    int n = 3, m = 3;
    char ***a;

    // Malloc and store.
    a = (char***)malloc(sizeof(char**) * n);
    for(int i = 0; i <n; ++i){
        a[i] = (char**)malloc(sizeof(char*) * m);
        for(int j = 0; j < m; ++j){
            a[i][j] = "abc"; // <-- you can put your string here in place of "abc".
        }
    }

    // Print or process your array or whatever serves your purpose.
    for(int i = 0; i < n; ++i){
        for(int j = 0; j < m; ++j){
            printf("%s\n", a[i][j]);
        }
    }

    return 0;
}


3 commentaires

Il n'est pas nécessaire de lancer le retour du MALLOC , il est inutile. Voir: Dois-je le résultat de Malloc?


Ouais bien. Juste une vieille habitude de la mienne. Vous pouvez laisser la distribution.


Oui, pas de têtes, c ++ l'exige, c non. VOID * est assignable à tous les types de pointeur en C sans couler.



-2
votes
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char **argv)
{
    char ***t = malloc(sizeof(char) * 1);           // one pointer
    int i, j;

    char s[1][3][2] = {{"he", "ll", 0}};

    printf("%s\n", s[0][0]);

    for( i = 0; i < 1; ++i )
    {
        t[i] = malloc(sizeof(char) * (argc - 1));       // not including program name
        for( j = 0; j < argc - 1; ++j )
        {
            t[i][j] = calloc(strlen(argv[j + 1]) + 1, sizeof(char));        // +1 for '\0'
        }
    }

    strncpy(t[0][0], argv[1], strlen(argv[1]));
    printf("%s\n", t[0][0]);

    return 0;
}
So i wrote up some code, tested it and it seems to work..i'm not sure if this is what you're looking for

1 commentaires

Plusieurs bugs: malloc (taille de (caractère) * 1); alloue 1 octet unique. Char S [1] [3] [2] = {{"" Il "," ll ", 0}}; ne contient pas de chaînes C appropriées. strncpy (t [0] [0], argv [1], SHLEN (argv [1])); ne fait pas ce que vous pensez: vous devriez 1. lire la documentation pour Strncpy , 2. stop en l'utilisant.



1
votes

Vous n'avez pas besoin de gabler 3D de pointeurs de caractères, mais vous avez besoin d'un tableau 2D de pointeurs de caractères.

de meilleure façon d'allouer la mémoire à un tableau à deux dimensions dans C? , vous pouvez attribuer une gamme 2D de pointeurs de caractères comme ci-dessous. xxx

ou xxx

après une allocation de mémoire réussie, vous pouvez faire semicol [i] [j] = " Texte ";

Vous pouvez libérer la mémoire allouée en appelant gratuit (Semicol);


5 commentaires

Calcul de taille plus simple: Char * (* Semicol) [COL] = MALLOC (Tailleof (* Semicol) * Rangée);


@chqrlie a accepté. Mais je pensais que [rangée] [col] est plus lisible. :)


Oui, les deux sont lisibles dans ce cas, mais le suppléant est plus général et évite une mauvaise table de tailles, en particulier lorsque le type de destination est modifié ultérieurement.


La seule différence ici est que col impose une largeur fixe pour la chaîne finale.


@ Davidc.Rankin non, je suppose. Parce qu'il s'agit d'une graisse 2D de pointeurs. Alors la chaîne ne fait pas partie de ce tableau.