array vom Typ void

plain C haben nettes feature - void-Typ, Pointer, die verwendet werden kann als Zeiger auf einen beliebigen Datentyp.
Aber, angenommen ich habe folgende struct:


struct token {
    int type;
    void *value;
};

denen Wert-Feld kann die Punkt-zu-char-array, oder int, oder etwas anderes.
Also, wenn die Zuweisung eine neue Instanz von diesem struct brauche ich:

1) Speicher für das struct;
2) Speicher für Wert und weisen Sie es auf dem Wert-Feld.

Meine Frage ist - gibt es Möglichkeiten, um zu erklären, "array vom Typ void", die gegossen werden Sie zu einer anderen Art wie der void-pointer?

Alles was ich will ist die Verwendung von "flexiblen Element Arrays" (siehe 6.7.2.1 der C99-standard) mit der Fähigkeit zum casting zu jedem Typ.

Etwas wie dieses:


struct token {
    int type;
    void value[];
};

struct token *p = malloc(sizeof(struct token) + value_size);
memcpy(p->value, val, value_size);
...
char *ptr = token->value;

Ich nehme an, deklarieren token->Wert als char-oder int-array und Umwandlung in den benötigten Typ später wird diese Arbeit zu tun, aber kann sehr verwirrend für jemanden, der gelesen wird dieser code später.

Doppel-Zeiger?
mit char[] ist in Ordnung imho, da sizeof(char) == 1 und du wirst nie überrascht. Vielleicht möchten Sie erwägen den Makros zum Zugriff p->value mit dem richtigen Typ.

InformationsquelleAutor S.J. | 2011-04-25

arrays c void-pointers

Naja, irgendwie schon, aber es ist wahrscheinlich nicht etwas, was Sie wollen:

struct token {
  //your fields
  size_t item_size;
  size_t length
};

struct token *make_token(/* your arguments */, size_t item_size, size_t length)
{
    struct token *t = malloc(sizeof *t + item_size * length);
    if(t == NULL) return NULL;
    t->item_size = item_size;
    t->length    = length;
    //rest of initialization
}

Das folgende makro kann verwendet werden, um die index-Daten (vorausgesetzt x ist ein struct token *):

#define idx(x, i, t) *(t *)(i < x->length ? sizeof(t) == x->item_size ?
                       (void *)(((char *)x[1]) + x->item_size * i)
                     : NULL : NULL)

Und, wenn Sie möchten, können Sie das folgende makro können wickeln Sie Ihre make_token - Funktion, um es ein wenig intuitiver (oder mehr hackish, wenn Sie darüber nachdenken, es auf diese Weise):

#define make_token(/* args */, t, l) (make_token)(/* args */, sizeof(t), l)

Verwendung:

struct token *p = make_token(/* args */, int, 5); //allocates space for 5 ints
...
idx(p, 2, int) = 10;

InformationsquelleAutor Chris Lutz

1

Ich würde wahrscheinlich tun Sie dies:
```
struct token {
    int type;
    void *value;
};

struct token p;

p.value = malloc(value_size);

p.value[0] = something;
p.value[1] = something;
...
```
Bearbeiten, eigentlich muss man zu festgelegten diejenigen p.Wert[index] = somethings. Und/oder verwenden Sie eine union nicht zu typisieren.

Man müsste cast p.value bevor Sie es verwenden.
p.value[0] = something ergibt einen compile-Zeit-Fehler, sicherlich? Kann man nicht dereferenzieren eine void*.
Das wird nicht mal kompilieren. Einige Compiler können Zeiger-Arithmetik auf void * Zeiger (wie eine Erweiterung), aber alle von Ihnen verbieten dereferenzieren void-Pointer.

InformationsquelleAutor old_timer
1

Können Sie nicht ein array von 'void' - Elemente, aber Sie sollten in der Lage sein, etwas zu tun, was Sie wollen, solange Sie wissen, value_size, wenn Sie das tun malloc. Aber es wird nicht schön werden.
```
struct token {
        int type;
        void *value;       
};    

value_size = sizeof(type)*item_count;
struct token *p = malloc(sizeof(struct token) + value_size);
//can't do memcpy:  memcpy(p->value, val, value_size);  
//do this instead
type* p = (type*)&(p->value);
type* end = p+item_count;
while (p<end) { *p++ = someItem; }
```
Beachten Sie, dass müssen Sie eine zusätzliche Adresse-von-operator, wenn Sie wollen, um den zusätzlichen Speicher.
```
type *ptr = (type*)&(token->value); 
```
Wird dieser "Abfall" sizeof(void*) bytes, und die ursprüngliche Art der value spielt eigentlich keine Rolle, also kann man da auch ein kleineres Element. Ich würde wahrscheinlich typedef char placeholder; und machen value.

InformationsquelleAutor AShelly
1

Erweiterung auf AShelly die Antwort, die Sie dies tun können;
```
/** A buffer structure containing count entries of the given size. */
typedef struct {
    size_t size;
    int count;
    void *buf;
} buffer_t;

/** Allocate a new buffer_t with "count" entries of "size" size. */
buffer_t *buffer_new(size_t size, int count)
{
    buffer_t *p = malloc(offsetof(buffer_t, buf) + count*size);
    if (p) {
        p->size = size;
        p->count = count;
    }
    return p;
}
```
Beachten Sie die Verwendung von "offsetof()" anstelle von "sizeof()" bei der Zuteilung von Arbeitsspeicher zu vermeiden, verschwenden die "void *buf;" Feld Größe. Die Art von "buf" nicht so schlimm, aber mit "void *" bedeutet, es wird ausrichten, dass die "buf" - Feld in der Struktur optimal für einen Zeiger, hinzufügen Polsterung, bevor es, falls erforderlich. Dieser bietet in der Regel bessere Speicher-Ausrichtung für die Einträge, besonders dann, wenn Sie mindestens so groß wie ein pointer.

Zugriff auf die Einträge im buffer sieht wie folgt aus;
```
/** Get a pointer to the i'th entry. */
void *buffer_get(buffer_t *t, int i)
{
    return &t->buf + i * t->size;
}
```
Beachten Sie die zusätzliche Adresse-von-operator, um die Adresse der "buf" - Feld als Ausgangspunkt für die zugewiesenen Eintrag Speicher.

InformationsquelleAutor Donovan Baarda

folgende Struktur kann Ihnen helfen.

struct clib_object_t {
void* raw_data;
size_t size;
};

struct clib_object_t*
new_clib_object(void *inObject, size_t obj_size) {
    struct clib_object_t* tmp = (struct clib_object_t*)malloc(sizeof(struct clib_object_t));   
    if ( ! tmp )
        return (struct clib_object_t*)0;
    tmp->size        = obj_size;
    tmp->raw_data    = (void*)malloc(obj_size);
    if ( !tmp->raw_data ) {
        free ( tmp );
        return (struct clib_object_t*)0;
    }
    memcpy ( tmp->raw_data, inObject, obj_size);
    return tmp;
}

clib_error
get_raw_clib_object ( struct clib_object_t *inObject, void**elem) {
    *elem = (void*)malloc(inObject->size);
    if ( ! *elem )
        return CLIB_ELEMENT_RETURN_ERROR;
    memcpy ( *elem, inObject->raw_data, inObject->size );

    return CLIB_ERROR_SUCCESS;
}

Mehr Details : clibutils

InformationsquelleAutor Avinash

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.