Allouer dynamiquement de la structure C?

Dans C:

swc *s = malloc(sizeof *s); //assuming you're creating a single instance of swc
if (s)
{
  s->offset = malloc(sizeof *(s->offset) * number_of_offset_elements);
  s->values = malloc(sizeof *(s->values) * number_of_value_elements);
}

En C++:

try
{
  swc *s = new swc;
  s->offset = new short[number_of_offset_elements];
  s->values = new char[number_of_value_elements];
}
catch(...)
{
   ...
}

Noter qu'en C++, vous pourriez être mieux à l'aide de vecteurs, par opposition à allouée dynamiquement tampons:

struct swc 
{
  std::vector<short> offset;
  std::vector<char> values;
};

swc *a = new swc;

Question: est-valeurs censé être un tableau de caractères individuels ou un tableau de chaînes de caractères? Ça changerait un peu les choses.

MODIFIER

Plus j'y pense, le moins satisfait, je suis avec le C++ réponse; la droit façon de faire ce genre de chose en C++ (en supposant que vous besoin allouée dynamiquement les tampons en opposition à des vecteurs, dont vous n'avez probablement pas) est d'effectuer l'allocation de mémoire pour compenser et de valeurs dans le cadre d'un constructeur à l'intérieur de la structure de type, et ont un destructeur de libérer ces éléments lors de la struct instance est détruite (soit par un delete ou en allant hors de portée).

struct swc
{
  swc(size_t numOffset = SOME_DEFAULT_VALUE, 
      size_t numValues = SOME_OTHER_DEFAULT_VALUE)
  {
    m_offset = new short[numOffset];
    m_values = new char[numValues];
  }

  ~swc()
  {
    delete[] m_offset;
    delete[] m_values;
  }

  short *m_offset;
  char  *m_values;
};

void foo(void)
{
  swc *a = new swc(10,20); //m_offset and m_values allocated as 
                           //part of the constructor
  swc b;                   //uses default sizes for m_offset and m_values
  ...
  a->m_offset[0] = 1;
  a->m_values[0] = 'a';
  b.m_offset[0] = 2;
  b.m_values[0] = 'b';
  ...
  delete a; //handles freeing m_offset and m_values
            //b's members are deallocated when it goes out of scope
}

OriginalL'auteur John Bode

Dans C:

typedef struct
{
    short *offset;
    char  *values;
} swc;

///Pre-Condition:  None
///Post-Condition: On failure will return NULL.
///                On Success a valid pointer is returned where
///                offset[0-n) and values[0-n) are legally de-refrancable.
///                Ownership of this memory is returned to the caller who
///                is responsible for destroying it via destroy_swc()
swc *create_swc(unsigned int size)
{
    swc *data    = (swc*)  malloc(sizeof(swc));
    if (data)
    {
        data->offset = (short*)malloc(sizeof(short)*n);
        data->values = (char*) malloc(sizeof(char) *n);
    }
    if ((data != NULL) && (size != 0) && ((data->offset == NULL) || (data->values == NULL)))
    {
        //Partially created object is dangerous and of no use.
        destroy_swc(data);
        data = NULL;
    }
    return data;
}
void destroy_swc(swc* data)
{
    free(data->offset);
    free(data->values);
    free(data);
}

En C++

struct swc
{
    std::vector<short>   offset;
    std::vector<char>    values;
    swc(unsigned int size)
        :offset(size)
        ,values(size)
    {}
};

OriginalL'auteur Martin York

Une chose à ajouter pour le nombre de bonnes réponses ici: vous peut malloc un cours de taille de structure pour accueillir un tableau de taille variable dans le dernier membre.

struct foo {
   short* offset;
   char values[0]
};

et plus tard

struct *foo foo1 = malloc(sizeof(struct foo)+30); //takes advantage of sizeof(char)==1

pour obtenir de la place pour 30 objets dans le values tableau. Vous auriez encore besoin de faire

foo1->offsets = malloc(30*sizeof(short));

si vous souhaitez utiliser les mêmes matrices de taille.

En général, je ne le fait pas en fait (entretien cauchemar si la structure a jamais besoin de se développer), mais c'est un outil dans le kit.

[code ici dans c. Vous aurez besoin de lancer le malloc(ou de mieux utiliser new RAII et locutions) en c++]

OriginalL'auteur dmckee

Utiliser la fonction de malloc ou calloc pour allouer de la mémoire dynamiquement .
et il recherche sur google pour obtenir des exemples.

The calloc function initializes allocated memory to zero.

OriginalL'auteur Ashish

La plupart des réponses sont correctes. Je voudrais ajouter quelque chose que vous n'avez pas explicitement demandé, mais peut également être important.

C /C++ tableaux ne pas stocker leur taille en mémoire. Donc, sauf si vous voulez offset et values avoir au moment de la compilation les valeurs définies (et, dans ce cas, il est préférable d'utiliser de taille fixe tableaux), vous pourriez vouloir stocker les tailles des deux tableaux dans le struct.

typedef struct tagswc {
    short  *offset;
    char   *values;
    //EDIT: Changed int to size_t, thanks Chris Lutz!
    size_t offset_count;
    size_t values_count; //You don't need this one if values is a C string.
} swc;

AVERTISSEMENT: j'ai peut-être tort. Par exemple, si tous les offsets de tous les swc instances ont la même taille, il serait préférable de les stocker offset_count mondiale en tant que membre, et non en tant que membre de la struct. La même chose peut être dit à propos de values et values_count. Aussi, si values est une chaîne C, vous n'avez pas besoin de stocker sa taille, mais méfiez-vous de Schlemiel le peintreproblèmes similaires.

OriginalL'auteur pyon

En plus de ce qui précède, je voudrais ajouter de libérer la mémoire allouée comme ci-dessous.,

    typedef struct { 
    short *offset; 
    char *values; 
} swc;

swc* createStructure(int Count1, int Count2) { 
  swc *s1 = new swc(); 
  s1->offset = new short[Count1]; 
  s1->values = new char[Count2]; 
  return s1; 
} 

int _tmain(int argc, _TCHAR* argv[])
{
    swc *mystruct;
    mystruct = createStructure(11, 11);

    delete[] mystruct->offset;
    delete[] mystruct->values;
     delete mystruct;
    return 0;
}

OriginalL'auteur Red