ich habe eine Funktion, die einen char-Pointer zurückgibt. Allerdings möchte ich ein char-Array damit "auffüllen". Wie ist das denn nun möglich?

struct {
    CHR8 * read (const char * pINI,const char * section,const char * key) {
        char * temp;
        GetPrivateProfileString (section,key,NULL,temp,2147483646,pINI);
        return temp;
    };
} INI;
int main () {
    char x [100];
    x = INI.read ("D:\\TEST.ini","Sektion0","Schluessel0");
    cout << x;
}

So funktionierts das schonmal nicht! Übrigens, d ich habe ja glaube ich eine anonyme Struktur erstellt (INI). Was ist der Vor- bzw. Nachteil daran?

Wichtige Info : Es wäre toll, wenn man den Header <string> nicht einsetzen würde. Das hat nichts mit "Programmiermasochismus" (s. meinen letzten Post) zu tun, sondern ich möchte einfach nur wissen, wie das auch ohne string gehen würde.

Danke im Voraus!

MfG

Seikuassi

ich habe eine Funktion, die einen char-Pointer zurückgibt. Allerdings möchte ich ein char-Array damit "auffüllen". Wie ist das denn nun möglich?

Arrays sind nicht kopierbar. (Du kannst die Elemente des Arrays kopieren, nicht aber das Array selbst). Darum kapseln wir rohe Arrays in einer Klasse. Damit werden sie kopierbar.

Seikuassi schrieb:

Übrigens, d ich habe ja glaube ich eine anonyme Struktur erstellt (INI). Was ist der Vor- bzw. Nachteil daran?

Keine Ahnung, hab ich noch nie gebraucht. Ein offensichtlicher Nachteil ist mal, dass die Instanz global ist.

char x[100];
strcpy(x, INI.read("D:\\TEST.ini","Sektion0","Schluessel0"));

Dies würde aber leicht einen BufferOverflow hervorrufen.

Also noch ein wenig verbessern:

char x[100];
strncpy(x, INI.read("D:\\TEST.ini","Sektion0","Schluessel0"), 100);
x[99] = 0; // Nullterminierung erzwingen

P.S. Deine INI.read-Funktion wird dir aber gnadenlos abstürzen, da du nur einen uninitialisierten Zeiger übergibst (und dann auch noch 2 GB als Größe ).

Also mach es gleich richtig und verwende einen std::string:

std::string read (const char * pINI,const char * section,const char * key)
{
    const int Size = 100;
    std::string s(Size);
    GetPrivateProfileString (section, key, NULL, &s[0], Size, pINI);
    return s;
};

CHR8 * read (const char * pINI,const char * section,const char * key) {
        static char temp[1234];
        GetPrivateProfileString (section,key,NULL,temp,1234,pINI);
        return temp;
    };

Erstmal haben wir Speicher wo GetPrivateProfileString was rein schreiben kann. Weiterhin ist temp static, sodass nach dem Funktionsaufruf, wo du den Pointer benutzt, der Speicher noch da ist.

Anonyme structs benutzt man halt, wenn man nur eine kleine Zahl dieser Structs anlegen will und dann nicht mehr. Sowas will man ziemlich selten, außerdem schadet das Festlegen eines Namens auch nicht.

nwp3 schrieb:

Weiterhin ist temp static, sodass nach dem Funktionsaufruf, wo du den Pointer benutzt, der Speicher noch da ist.

Und was ist daran der Vorteil ? Denn die 1234 Bytes sind ja (wenn man die Funktion bereits aufgerufen hat) immer im Speicher (im Stack?). Bei 1234 Bytes ist mir das ja egal, aber was ist (jetzt kommt wieder etwas Übertriebenes, dafür aber Mögliches), wenn ich jetzt mal kurze Zeit 2 GB brauche, die ich aber nach ein paar Codezeilen wieder freigeben möchte?
Was ist jetzt also der Sinn von static in diesem Fall?

MfG

Seikuassi

habe gerade an LoadString das "normale" als auch das statische Array ausprobiert. Bei dem static brauche ich weniger Arbeitsspeicher (jedenfalls zeigt mir der "Resourcemanager" das so in Win 7 an). Warum ist das so?

MfG

Seikuassi

Betreff: Char-Array als Rückgabewert

ich habe eine Funktion, die einen char-Pointer zurückgibt. Allerdings möchte ich ein char-Array damit "auffüllen". Wie ist das denn nun möglich?

std::string deineFunktion();

int main()
{
  std::string wirdAufgefuellt = deineFunktion();
}

Wahlweise auch mit std::vector<char>

Rohe Arrays sind nicht kopierbar und nicht zuweisbar. Versuch nicht auf Biegen und Brechen Schei*e zu bauen. C++ kann so einfach sein.

Rohe Arrays sind nicht kopierbar und nicht zuweisbar.

Die Frage bzw. das Thema ist schon etwas älter.
Wichtig ist die Frage:

Warum ist in der Funktion eine statisch angelegte Variable in einer Funktion kleiner als eine nicht-statische Variable?

Für mich heißt das, dass der Wert im Arbeitsspeicher dauerhaft gespeichert bleibt, bis der Prozess beendet wird.
Warum zum Teufel benötigt aber die nicht-statische Variable mehr RAM ?

Danke im Voraus!

MfG

Seikuassi

krümelkacker schrieb:

C++ kann so einfach sein.

Muss es aber nicht . Scherz .

SeppJ schrieb:

Ein Ressourcenmonitor ist kein Programmentwicklungswerkzeug.

Und lügt ?
Dann bist du auch der Meinung, dass die statische Variable praktisch mehr Speicher verwendet bzw. länger verwendet wird (Programmlebensdauer), oder?

MfG

Seikuassi

Hallo SeppJ,

SeppJ schrieb:

Ein Ressourcenmonitor ist kein Programmentwicklungswerkzeug.

Und lügt ?

Wenn du nicht ganz genau weißt, was er macht: Praktisch ja. Weißt du, was er genau macht?

Dann bist du auch der Meinung, dass die statische Variable praktisch mehr Speicher verwendet bzw. länger verwendet wird (Programmlebensdauer), oder?

Wo liest du das aus meinem Beitrag heraus? Das ist vollkommener Unsinn. Es ändert sich bloß, wo die Variable liegt. Womit wir wieder beim Thema sind, was der Ressourcenmonitor überhaupt genau anzeigt. Nämlich wohl nicht das, was du denkst. Das ist nämlich ein Tool für den Laien, der eine ungefähre Angabe über Speicherverbrauch seiner Anwendungen möchte.

Oder wächst Dein Programm im Speicher?