Struct avec les membres de la pile en C

Récemment, j'ai revu certains de code C et de trouver quelque chose d'équivalent à celui-ci:

struct foo {
    int some_innocent_variables;
    double some_big_array[VERY_LARGE_NUMBER];
}

Presque, mais pas tout à fait, presque entièrement un débutant en C, je suis en droit de penser que cette structure est terriblement inefficace dans son utilisation de l'espace en raison du membre du groupe? Ce qui se passe lorsque cette structure est passée comme argument à une fonction? Est-il copié dans son intégralité sur la pile, y compris la gamme complète?

Serait-il préférable dans la plupart des cas d'avoir un double *some_pointer à la place?

L'inefficacité dans l'utilisation de l'espace dépend de si oui ou non vous utilisez l'espace alloué. Si l'ensemble du tableau est toujours utilisée alors un pointeur ajoutera quelques octets d'espace perdu pour stocker le pointeur lui-même (même si négligeable pour les grands réseaux).

OriginalL'auteur lindelof | 2010-09-13

  1. 7

    Si vous passez par la valeur oui, il va faire une copie de tout.
    Mais c'est pourquoi les pointeurs existent.

    //Just the address is passed 
void doSomething(struct foo *myFoo)
{

}
    Rester près de passage par valeur possible tout en bénéficiant encore du passage par référence en efficacité, vous pouvez utiliser struct foo const * const myFoo. Ce sera de dire au compilateur pour vous avertir accidentellement lorsque vous essayez de modifier le pointeur ou pointu de valeur.

    OriginalL'auteur Brian R. Bondy

  2. 2

    Être passé comme argument, il sera copié ce qui est très moyen inefficace de passage de structures, en particulier de gros. Cependant, fondamentalement, les structures sont passés aux fonctions par pointeur.

    Le choix entre

    double some_big_array[VERY_LARGE_NUMBER];

    et 

    double *some_pointer

    ne dépend que de la conception du programme et la façon dont ce champ/structure sera utilisé. Ce dernier permet à l'aide de la variable de taille de stockage, cependant, peuvent avoir besoin d'allocation dynamique.

    +1, en raison des démotivé downvote

    OriginalL'auteur pmod

  3. 1

    Comme d'autres l'ont dit, les objets de ce type sont généralement passés avec des pointeurs (toujours sizeof (struct foo) octets, souvent de 4 octets).

    Vous pouvez également voir les "struct hack" (également passés avec les pointeurs):

    struct foo {
    int some_innocent_variables;
    double some_array[]; /* C99 flexible array member */
    /* double some_array[1]; ** the real C89 "struck hack" */
}

    Cette "struct hack" obtient un tableau de taille par le malloc appel.

    /* allocate an object of struct foo type with an array with 42 elements */
struct foo *myfoo = malloc(sizeof *myfoo + 42 * sizeof *myfoo->some_array);
/* some memory may be wasted when using C89 and
   the "struct hack" and this allocation method */

    OriginalL'auteur pmg

  4. 0

    Oui, en C, vous aurait généralement de passer un pointeur vers la structure due à des raisons d'efficacité.

    OriginalL'auteur Jim Brissom

  5. 0

    Il ya beaucoup de raisons pour utiliser des tableaux dans des structures. Parmi eux est le fait que les structures sont passés aux fonctions par valeur, tandis que les tableaux sont passés par référence. Cela dit, cette structure est probablement transmise à des fonctions avec des pointeurs.

    OriginalL'auteur nmichaels

  6. 0

    EDIT: Cette structure est très bien aussi longtemps que vous le passer par référence (à l'aide d'un pointeur).

    Offtopic:
    Méfiez-vous de la structure hack, c'est pas strictement conforme à la norme; il ignore le remplissage automatique. Les IPC Unix files d'attente de messages de l'utiliser (voir struct msgbuf), même si, et il est presque certainement de travailler avec n'importe quel compilateur.

    Cela dit, les fonctions qui utilisent cette structure peut utiliser des pointeurs au lieu d'utiliser une copie.

    OriginalL'auteur Pablo Alejandro Costesich