Wie kann ich einen Speicherblock von einer Funktion erhalten und in eine Datei schreiben?

Question

Ich möchte die Daten "somebytes" schreiben, die ich von einer Funktion namens NextUnit() in eine Datei namens "output.txt" bekomme, aber der Code, den ich schrieb, funktioniert nicht. Wenn ich die Datei öffne, sieht es nicht wie meine "Somebytes" aus. Hier ist der Code:

#include <stdio.h> 
#include <string.h> 

char* NextUnit() 
{ 
    char Unit[256]; 
    strcpy(Unit,"somebytes"); 
    return &Unit[0]; 
} 

int main() 
{ 
    FILE *ourfile; 
    ourfile=fopen("output.txt","wb"); 
    char* somedata; 
    somedata=NextUnit(); 
    printf("%s\n",somedata); 
    fwrite(somedata,1,strlen(somedata),ourfile); 
    fclose(ourfile); 
} 

Answer 1

Sie die lokale Adresse aus einer Funktion zurückkehrt (aka freigegeben Stapeladresse). Dies wird dann geändert, sobald Sie die nächste Funktion aufrufen.

Äther zurückkehren nur eine globale Konstante

const char* NextUnit() { return "somebytes"; } 

oder es in eine neue Speicherstruktur zu kopieren, die Sie dann später auch kostenlos müssen ...

char* NextUnit() 
{ 
    char* newstr = new char[256]; 
    strcpy(newstr,"somebytes"); 
    return newstr; 
} 

// some code later 
char* tmpstr = NextUnit(); 

// do writing stuff 

// free memory 
delete tmpstr; 

Answer 2

Sie Unit[256] deklariert haben auf dem Stapel in einer Unterprozedur. Aber wenn Ihre NextUnit() zurückgibt, geht die Variable, die darauf beschränkt war, außerhalb des Geltungsbereichs, und Sie zeigen nicht mehr auf gültigen Speicher.

Ziehen Sie in Betracht, den Speicher mit new zuzuweisen und dann im Aufrufer freizugeben oder den Anrufer einen Zeiger auf den zuvor zugewiesenen Speicher übergeben zu lassen.

Answer 3

Sie geben die lokale Adresse eine Funktion zurück. Ether einfach zurück

const char * NextUnit() {zurück "somebytes"; }

so ist es konstant ist, oder in einen neue Speicher stucture zu kopieren, die Sie dann auch später kostenlos müssen ...

ich auf dem zitierten Kommentar nicht genug mojo haben antworte, also muss ich das als eine neue Antwort aussprechen.

Seine Antwort versucht, das Richtige zu sagen, aber es kam falsch.

Ihr Code gibt die Adresse einer lokalen Variablen innerhalb der NextUnit() - Funktion zurück. Tu das nicht. Es ist schlecht. Tu, was er vorgeschlagen hat.

Answer 4

Ich würde es so umschreiben:

char *NextUnit(char *src) 
{ 
    strcpy(src, "somebytes"); 
    return src; 
} 

Auf diese Weise können Sie entscheiden, was mit dem variablen außerhalb die Funktion Implementierung zu tun:

char Unit[256]; 
char *somedata = NextUnit(Unit); 

Answer 5

Wenn Sie C++ verwenden, die Folgendes ist ein viel besserer Weg, dies zu umgehen:

#include <iostream> 
#include <string> 

using namespace std; 

int main(int argc, char ** argv) 
{ 
    ofstream outFile; 

    outFile.open("output.txt"); 
    outFile << "someBytes"; 
    outFile.close(); 

    return 0; 
} 

Und sobald Sie damit vertraut sind, ist das nächste, was Sie über RAII erfahren.

Answer 6

NextUnit gibt die Adresse von Unit zurück, die ein Array lokal für diese Funktion ist. Das bedeutet, dass es auf dem Stapel zugeordnet und "freigegeben" wird, wenn die Funktion zurückkehrt, wodurch der Rückgabewert ungültig wird.

Um dieses Problem zu lösen, können Sie:

• dynamisch eine neue Zeichenfolge jedes Mal zuweisen NextUnit aufgerufen wird. Beachten Sie, dass Sie in diesem Fall den Speicher später löschen müssen.
• Erstellen Sie eine globale Zeichenfolge. Das ist gut für eine kleine "Test" -Anwendung, aber im Allgemeinen wird die Verwendung von globalen Variablen abgeraten.
• Lassen Sie eine Zeichenfolge (entweder dynamisch oder auf dem Stapel) zu, übergeben Sie sie als Parameter an NextUnit, und kopieren Sie NextUnit in diese Zeichenfolge.

Answer 7

Sie haben hier ein paar Probleme. Die wichtigste, glaube ich, ist, dass NextUnit() den Puffer auf dem Stack zuweist und Sie effektiv den Gültigkeitsbereich verlassen, wenn Sie versuchen, die Adresse zurückzugeben.

Sie können dies in einer C-style-Lösung beheben, indem Sie Speicherplatz für den Puffer mallocing und den Zeiger zurückgeben, der malloc zurückgibt.

Ich denke, ein erster Schritt könnte den Code, um etwas mehr wie folgt neu zu schreiben sein:

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

char* NextUnit() 
{ 
    char *Unit = (char *)malloc(256); 
    memset(Unit, 0, sizeof(Unit)); 
    strcpy(Unit,"somebytes"); 
    return Unit; 
} 

int main() 
{ 
    FILE *ourfile; 
    ourfile=fopen("output.txt","wb"); 
    char* somedata; 
    somedata=NextUnit(); 
    printf("%s\n",somedata); 
    //fwrite(somedata,1,strlen(somedata),ourfile); 
    fprintf(ourfile, somedata); 
    free(somedata); 
    fclose(ourfile); 
} 

Answer 8

„Einheit“ als lokale Variable innerhalb NextUnit erklärt, die tatsächlich ein „Stapel“ Variable Bedeutung ist, dass es Lebensdauer ist nur so lange wie NextUnit nicht zurückgegeben wurde.

So, während NextUnit noch nicht zurückgekehrt ist, ist das Kopieren von "somebytes" in es OK, als wird es ausgedruckt. Sobald NextUnit zurückkehrt, wird Unit vom Stack freigegeben und der Zeiger somedata in main wird nicht auf etwas Gültiges zeigen.

Hier ist eine schnelle Lösung. Ich empfehle es immer noch nicht, auf diese Weise Programme zu schreiben, aber es sind die wenigsten Änderungen.

#include <stdio.h> 
#include <string.h> 

char Unit[256]; 

char* NextUnit() 
{ 

    strcpy(Unit,"somebytes"); 
    return &Unit[0]; 
} 

int main() 
{ 
    FILE *ourfile; 
    ourfile=fopen("output.txt","wb"); 
    char* somedata; 
    somedata=NextUnit(); 
    printf("%s\n",somedata); 
    fwrite(somedata,1,strlen(somedata),ourfile); 
    fclose(ourfile); 
} 

Das funktioniert, aber es ist sinnlos, die Adresse der Einheit zurückzugeben, wenn es tatsächlich global ist!

Answer 9

Deklarieren Unit als static:

char* NextUnit() 
{ 
    static char Unit[256]; 
    strcpy(Unit,"somebytes"); 
    return &Unit[0]; 
}

Aber wenn Sie C++ Compiler verwenden, sollten Sie std::string statt char* betrachten verwenden. std::string ist sicherer und erledigt alle Zuweisungs/Freigabe-Jobs für Sie.