Erstellen Sie eine struct auf dem heap?

Ja, Sie haben ein struct auf dem heap. Sie haben nicht aufgefüllt, es richtig, und du wirst Probleme haben ihn zu löschen - ich bin mir nicht sicher, ob die Hausaufgaben abgedeckt ist oder nicht. So wie es da steht, du bist mehr wahrscheinlich, um Speicherbeschädigung oder, wenn Sie Glück haben, ein Speicher-Leck, als Sie zu release einen dieser strings.

Code, der funktioniert mit standard C89 und C99

Dein code, etwas nach oben korrigiert...

typedef 
struct String {
    int length;
    int capacity;
    char *ptr;
} String;

char* modelstrdup(char* src){
    int length = strlen(src);
    char *space = malloc(sizeof(String) + length + 1);
    //String *string = space;  //Original code - compilers are not keen on it
    String *string = (String *)space;
    assert(space != 0);
    string->ptr = space + sizeof(String);  //or sizeof(*string)
    string->length = length;
    string->capacity = length + 1;
    strcpy(string->ptr, src);
    return string->ptr;
}

Dieser code funktioniert in C89 sowie C99 - (außer für die C99/C++ - Kommentare). Sie können wahrscheinlich optimieren Sie die Arbeit mit der Struktur 'struct hack' (speichert einen Zeiger in der Struktur - aber nur, wenn Sie einen C99-compiler). Die Geltendmachung sub-optimale Fehlerbehandlung. Den code nicht, sich selbst zu verteidigen gegen einen null-Zeiger für die Eingabe. In diesem Kontext weder die Länge noch die Kapazität bietet jeder nutzen - muss es andere Funktionen in der suite, wird in der Lage sein, um machen Sie Gebrauch von dieser information.

Wie bereits angedeutet, wirst du Probleme haben, löschen Sie die Zeichenfolge-Struktur, wenn der Wert, der zurückgegeben wird, nicht ein Zeiger auf die Zeichenfolge. Sie haben eine filigrane Zeiger Anpassungen zu machen.

Code, der funktioniert mit den standard C99 nur

In C99", Abschnitt 6.7.2.1 Absatz 16 beschrieben, "flexible array members":

Als ein besonderer Fall, wird das Letzte element einer Struktur mit mehr als einem benannten Mitglied kann
haben einen unvollständigen array-Typ; dies wird als eine flexible array-member. Mit zwei
Ausnahmen, die flexible array-member wird ignoriert. Zunächst wird die Größe der Struktur ist
gleich dem offset des letzten Elements einer ansonsten identischen Struktur, ersetzt die
flexible array-member mit einem array von unbekannter Länge.¹⁰⁶⁾ Second, wenn ein . (oder ->)
Betreiber hat einen linken Operanden ist (ein Zeiger auf) eine Struktur mit einem flexible array-member
und der Rechte operand Namen, Mitglied, es verhält sich so, als wenn das Mitglied ersetzt wurden
mit dem längsten array (mit den gleichen element-Typ) , würde nicht die Struktur
größer als das Objekt ist, auf die zugegriffen wird; der offset des Arrays bleiben, dass der
flexible array-member, auch wenn diese sich unterscheiden würden, dass von den Ersatz-array. Wenn diese
Arrays haben keine Elemente, es verhält sich so, als hätte es ein element, aber das Verhalten ist
undefined, wenn irgendein Versuch gemacht wird, den Zugriff auf dieses element, oder generieren Sie einen Zeiger eine Vergangenheit
es.

¹⁰⁶ Die Länge ist nicht angegeben, damit für die Tatsache, dass Implementierungen geben, kann die array-Mitglieder, die verschiedenen
Ausrichtungen nach Ihrer Länge.

Ist mit einem "flexible array member", Ihr code könnte:

typedef 
struct String {
    int length;
    int capacity;
    char ptr[];
} String;

char* modelstrdup(char* src){
    int length = strlen(src);
    String *string = malloc(sizeof(String) + length + 1);
    assert(string != 0);
    string->length = length;
    string->capacity = length + 1;
    strcpy(string->ptr, src);
    return string->ptr;
}

Dieser code wurde angenommen, da Sie sauber von GCC 4.0.1 abgesehen von einer Erklärung für die Funktion (Optionen -Wall -Wextra). Der Vorherige code muss ein cast auf "String *string = (String *)Raum:" sagen Sie dem compiler, den ich meinte, was ich sagte; ich habe jetzt behoben, und einen Kommentar hinterlassen, um zu zeigen das original.

Mit der Verwendung von 'struct hack'

Bevor C99, die Menschen oft verwendet die 'struct hack' um dies zu umgehen. Es ist sehr ähnlich wie der code in der Frage, außer die dimension des Arrays ist 1, nicht 0. Standard-C nicht erlaubt array-Abmessungen die Größe null hat.

typedef struct String {
    size_t length;
    size_t capacity;
    char ptr[1];
} String;

char* modelstrdup(char* src)
{
    size_t length = strlen(src);
    String *string = malloc(sizeof(String) + length + 1);
    assert(string != 0);
    string->length = length;
    string->capacity = length + 1;
    strcpy(string->ptr, src);
    return string->ptr;
}

- Code, verwendet GCC nicht-standard-Erweiterung zu C89 und C99

Die zero-size array-Schreibweise akzeptiert, GCC, es sei denn, Sie stecken es schwer - geben Sie den ISO C standard und Anforderung pedantische Genauigkeit. Dieser code, deshalb kompiliert OK, es sei denn, Sie verwenden gcc -Wall -Wextra -std=c99 -pedantic:

#include <assert.h>
#include <stdlib.h>
#include <string.h>

typedef
struct String {
    int length;
    int capacity;
    char ptr[0];
} String;

char* modelstrdup(char* src){
    int length = strlen(src);
    String *string = malloc(sizeof(String) + length + 1);
    assert(string != 0);
    string->length = length;
    string->capacity = length + 1;
    strcpy(string->ptr, src);
    return string->ptr;
}

Sollten Sie jedoch nicht ausgebildet, die in nicht-standard-Erweiterungen der C-Sprache, bevor Sie ein gründliches Verständnis der Grundlagen von standard-C. Das ist einfach unfair für Sie; Sie können nicht sagen, ob das, was Sie wird gesagt, zu tun, ist sinnvoll, aber Ihre Tutoren sollten nicht irreführend Sie, indem Sie zu zwingen, zu nutzen nicht-standard-Sachen. Auch wenn Sie alarmiert Sie der Tatsache, dass es ist nicht-standard, es ist nicht fair zu Ihnen. C ist schon schwer genug zu lernen, ohne lernen tricksy Zeug, das ist etwas compiler-spezifisch.

InformationsquelleAutor Jonathan Leffler

Haben Sie. Malloc, new, etc. alle verwenden den heap.

InformationsquelleAutor popester