variableninhalt abspeichern

**reddragon1212** · 30.05.2010, 11:56

Hallo erstmal,

ich bin noch ein c++ anfänger und möchte gerne ein kleines projekt für mich umsetzen, da das auch einen großen nutzen für mich hat

Und zwar möchte ich einen serienplaner in c++ schreiben der mir ausgibt welche folgen ich schon geguckt habe

naja ich denke ich würde alles soweit hinbekommen, nur mein größtes problem ist ich weiß nicht wie ich den inhalt in einer variable abspeicher und aufzufen kann
ich habe schon versucht mit den streams zu arbeiten aber das hat nicht so ganz geklappt.

naja wie gesagt ich bin halt noch totaler anfänger, ich musste ne pause einlegen in c++ da dies mein letztes schuljahr war, aber nun bin ich durch

Vielen Dank schonmal für eure hilfe

**blackberry** · 30.05.2010, 12:00

Entweder du nennst uns ein konkretes Problem mit den Streams, oder du besorgst dir ne Lib die das für dich macht - z.B. SQLite SQLite Home Page

**Bonkers** · 30.05.2010, 12:06

Also du möchtest den Inhalt von Variablen in einer Datei speichern?

**blackberry** · 30.05.2010, 12:16

Ich hätte da noch was, was ich vor ca. 8 Monaten mal wegen eines Threads auch hier in dieser Section gemacht habe.

Code:

#include <stdio.h>
#include <vector>


using namespace std;

typedef struct _VARINFO
{
    int namelen;
    int contentlen;
}
VARINFO;

typedef struct _VAR
{
    VARINFO info;
    char *name;
    char *content;
}
VAR;

typedef vector<VAR> VARLIST;

enum VARS_MODES
{
    VAR_NO_OVERWRITE,
    VAR_OVERWRITE
};

enum VARS_ERRORS
{
    VAR_SUCCESS,
    VAR_FOPEN,
    VAR_READERROR,
    VAR_OUTOFMEMEORY,
    VAR_NO_VAR_FOUND
};

int vars_add(VARLIST *varlist, char *name, char *content, int contentlen, int overwrite)
{
    VAR var;
    int i;
    
    var.info.namelen = strlen(name);
    var.info.contentlen = contentlen;
    
    for(i = 0; i < varlist->size(); i++)
    {
        if ((*varlist)[i].info.namelen == var.info.namelen)
        {
            if (!memcmp((*varlist)[i].name, name, var.info.namelen))
            {
                if (overwrite == VAR_NO_OVERWRITE)
                {
                    return VAR_SUCCESS;
                }
                break;
            }
        }
    }
    
    if (i == varlist->size() || VAR_OVERWRITE)
    {
        if (!(var.name = (char *) malloc(var.info.namelen + 1))
            || !(var.content = (char *) malloc(var.info.contentlen + 1)))
        {
            return VAR_OUTOFMEMEORY;
        }
        
        memcpy(var.name, name, var.info.namelen);
        memcpy(var.content, content, var.info.contentlen);
        
        if (i < varlist->size())
        {
            free((*varlist)[i].content);
            free((*varlist)[i].name);
            (*varlist)[i] = var;
        }
        else
        {
            varlist->push_back(var);
        }
    }
    
    return VAR_SUCCESS;
}

int vars_update(VARLIST *varlist, char *name, char *content, int contentlen)
{
    int i;
    
    for(i = 0; i < varlist->size(); i++)
    {
        if ((*varlist)[i].info.namelen == strlen(name))
        {
            if (!memcmp((*varlist)[i].name, name, (*varlist)[i].info.namelen))
            {
                if ((*varlist)[i].info.contentlen == contentlen)
                {
                    memcpy((*varlist)[i].content, content, contentlen);
                }
                else
                {
                    free((*varlist)[i].content);
                    if (!((*varlist)[i].content = (char *) malloc(contentlen + 1)))
                    {
                        return VAR_OUTOFMEMEORY;
                    }
                    memcpy((*varlist)[i].content, content, contentlen);
                }
                return VAR_SUCCESS;
            }
        }
    }
    
    return VAR_NO_VAR_FOUND;
}

int vars_get(VARLIST *varlist, char *name, VAR *var)
{
    int i;
    
    for(i = 0; i < varlist->size(); i++)
    {
        if ((*varlist)[i].info.namelen == strlen(name))
        {
            if (!memcmp((*varlist)[i].name, name, (*varlist)[i].info.namelen))
            {
                *var = (*varlist)[i];
                return VAR_SUCCESS;
            }
        }
    }
    
    return VAR_NO_VAR_FOUND;
}

int vars_read(VARLIST *varlist, char *file, int overwrite)
{
    FILE *fp;
    VAR var;
    int i;
    
    if (!(fp = fopen(file, "rb")))
    {
        return VAR_FOPEN;
    }
    
    while(!feof(fp))
    {
        if (fread(&var.info, 1, sizeof(var.info), fp) != sizeof(var.info))
        {
            return VAR_READERROR;
        }
        
        if (!(var.name = (char *) malloc(var.info.namelen + 1))
            || !(var.content = (char *) malloc(var.info.contentlen + 1)))
        {
            return VAR_OUTOFMEMEORY;
        }
        
        if (fread(var.name, 1, var.info.namelen, fp) != var.info.namelen
            || fread(var.content, 1, var.info.contentlen, fp) != var.info.contentlen)
        {
            free(var.name);
            free(var.content);
            return VAR_READERROR;
        }
        
        for(i = 0; i < varlist->size(); i++)
        {
            if ((*varlist)[i].info.namelen == var.info.namelen)
            {
                if (!memcmp((*varlist)[i].name, var.name, var.info.namelen))
                {
                    if (overwrite == VAR_OVERWRITE)
                    {
                        free((*varlist)[i].content);
                        free((*varlist)[i].name);
                        (*varlist)[i] = var;
                    }
                    break;
                }
            }
        }
        if (i == varlist->size())
        {
            varlist->push_back(var);
        }
    }
    
    fclose(fp);
    return VAR_SUCCESS;
}

int vars_write(VARLIST *varlist, char *file)
{
    FILE *fp;
    VAR var;
    int i;
    
    vars_read(varlist, file, VAR_NO_OVERWRITE);
    if (!(fp = fopen(file, "wb")))
    {
        return VAR_FOPEN;
    }
    
    for(i = 0; i < varlist->size(); i++)
    {
        fwrite(&(*varlist)[i].info, 1, sizeof((*varlist)[i].info), fp);
        fwrite((*varlist)[i].name, 1, (*varlist)[i].info.namelen, fp);
        fwrite((*varlist)[i].content, 1, (*varlist)[i].info.contentlen, fp);
    }
    
    fclose(fp);
    return VAR_SUCCESS;
}

/*
int vars_add(VARLIST *varlist, char *name, char *content, int contentlen, int overwrite);
int vars_update(VARLIST *varlist, char *name, char *content, int contentlen);
int vars_get(VARLIST *varlist, char *name, VAR *var);
int vars_read(VARLIST *varlist, char *file, int overwrite);
int vars_write(VARLIST *varlist, char *file);
*/

int main(void)
{
    char file[] = "myVars.backup";
    VARLIST varlist;
    VAR var1;
    
    vars_read(&varlist, file, VAR_NO_OVERWRITE);
    vars_add(&varlist, "var1", "\x00\x00\x00\x00", sizeof(int), VAR_NO_OVERWRITE);
    
    vars_get(&varlist, "var1", &var1);
    (*((int *) var1.content))++;
    vars_update(&varlist, "var1", var1.content, var1.info.contentlen);
    vars_write(&varlist, file);
    
    printf("var1 = %d\n", *((int *) var1.content));
    
    return 0;
}

Damit sollte man auch Structs abspeichern können.
Wenn du die ganzen Dinger auf eine feste Größe beschränken willst (Speicherplatzmäßig eher nicht zu empfehlen, aber da es ein kleines Programm sein wird sicher vertretbar), dann könntest du jeweils einen Array via vars_add hinzufügen und später wieder einlesen.

**reddragon1212** · 30.05.2010, 12:22

Ja, und so dass ich diesen auch wieder aufrufen kann

Ich habe das ganze nach dieser seite gemacht
Dateizugriffe

nur wird da nur mit zahlen gearbeitet und nicht mit text also einem string

also mein Problem ist einfach dass ich den inhalt nicht aufgerufen bekomm

vielleicht hat ja jemand auch was besseres zu den streams

Zitat von BlackBerry

Ich hätte da noch was, was ich vor ca. 8 Monaten mal wegen eines Threads auch hier in dieser Section gemacht habe.

Code:

#include <stdio.h>
#include <vector>


using namespace std;

typedef struct _VARINFO
{
    int namelen;
    int contentlen;
}
VARINFO;

typedef struct _VAR
{
    VARINFO info;
    char *name;
    char *content;
}
VAR;

typedef vector<VAR> VARLIST;

enum VARS_MODES
{
    VAR_NO_OVERWRITE,
    VAR_OVERWRITE
};

enum VARS_ERRORS
{
    VAR_SUCCESS,
    VAR_FOPEN,
    VAR_READERROR,
    VAR_OUTOFMEMEORY,
    VAR_NO_VAR_FOUND
};

int vars_add(VARLIST *varlist, char *name, char *content, int contentlen, int overwrite)
{
    VAR var;
    int i;
    
    var.info.namelen = strlen(name);
    var.info.contentlen = contentlen;
    
    for(i = 0; i < varlist->size(); i++)
    {
        if ((*varlist)[i].info.namelen == var.info.namelen)
        {
            if (!memcmp((*varlist)[i].name, name, var.info.namelen))
            {
                if (overwrite == VAR_NO_OVERWRITE)
                {
                    return VAR_SUCCESS;
                }
                break;
            }
        }
    }
    
    if (i == varlist->size() || VAR_OVERWRITE)
    {
        if (!(var.name = (char *) malloc(var.info.namelen + 1))
            || !(var.content = (char *) malloc(var.info.contentlen + 1)))
        {
            return VAR_OUTOFMEMEORY;
        }
        
        memcpy(var.name, name, var.info.namelen);
        memcpy(var.content, content, var.info.contentlen);
        
        if (i < varlist->size())
        {
            free((*varlist)[i].content);
            free((*varlist)[i].name);
            (*varlist)[i] = var;
        }
        else
        {
            varlist->push_back(var);
        }
    }
    
    return VAR_SUCCESS;
}

int vars_update(VARLIST *varlist, char *name, char *content, int contentlen)
{
    int i;
    
    for(i = 0; i < varlist->size(); i++)
    {
        if ((*varlist)[i].info.namelen == strlen(name))
        {
            if (!memcmp((*varlist)[i].name, name, (*varlist)[i].info.namelen))
            {
                if ((*varlist)[i].info.contentlen == contentlen)
                {
                    memcpy((*varlist)[i].content, content, contentlen);
                }
                else
                {
                    free((*varlist)[i].content);
                    if (!((*varlist)[i].content = (char *) malloc(contentlen + 1)))
                    {
                        return VAR_OUTOFMEMEORY;
                    }
                    memcpy((*varlist)[i].content, content, contentlen);
                }
                return VAR_SUCCESS;
            }
        }
    }
    
    return VAR_NO_VAR_FOUND;
}

int vars_get(VARLIST *varlist, char *name, VAR *var)
{
    int i;
    
    for(i = 0; i < varlist->size(); i++)
    {
        if ((*varlist)[i].info.namelen == strlen(name))
        {
            if (!memcmp((*varlist)[i].name, name, (*varlist)[i].info.namelen))
            {
                *var = (*varlist)[i];
                return VAR_SUCCESS;
            }
        }
    }
    
    return VAR_NO_VAR_FOUND;
}

int vars_read(VARLIST *varlist, char *file, int overwrite)
{
    FILE *fp;
    VAR var;
    int i;
    
    if (!(fp = fopen(file, "rb")))
    {
        return VAR_FOPEN;
    }
    
    while(!feof(fp))
    {
        if (fread(&var.info, 1, sizeof(var.info), fp) != sizeof(var.info))
        {
            return VAR_READERROR;
        }
        
        if (!(var.name = (char *) malloc(var.info.namelen + 1))
            || !(var.content = (char *) malloc(var.info.contentlen + 1)))
        {
            return VAR_OUTOFMEMEORY;
        }
        
        if (fread(var.name, 1, var.info.namelen, fp) != var.info.namelen
            || fread(var.content, 1, var.info.contentlen, fp) != var.info.contentlen)
        {
            free(var.name);
            free(var.content);
            return VAR_READERROR;
        }
        
        for(i = 0; i < varlist->size(); i++)
        {
            if ((*varlist)[i].info.namelen == var.info.namelen)
            {
                if (!memcmp((*varlist)[i].name, var.name, var.info.namelen))
                {
                    if (overwrite == VAR_OVERWRITE)
                    {
                        free((*varlist)[i].content);
                        free((*varlist)[i].name);
                        (*varlist)[i] = var;
                    }
                    break;
                }
            }
        }
        if (i == varlist->size())
        {
            varlist->push_back(var);
        }
    }
    
    fclose(fp);
    return VAR_SUCCESS;
}

int vars_write(VARLIST *varlist, char *file)
{
    FILE *fp;
    VAR var;
    int i;
    
    vars_read(varlist, file, VAR_NO_OVERWRITE);
    if (!(fp = fopen(file, "wb")))
    {
        return VAR_FOPEN;
    }
    
    for(i = 0; i < varlist->size(); i++)
    {
        fwrite(&(*varlist)[i].info, 1, sizeof((*varlist)[i].info), fp);
        fwrite((*varlist)[i].name, 1, (*varlist)[i].info.namelen, fp);
        fwrite((*varlist)[i].content, 1, (*varlist)[i].info.contentlen, fp);
    }
    
    fclose(fp);
    return VAR_SUCCESS;
}

/*
int vars_add(VARLIST *varlist, char *name, char *content, int contentlen, int overwrite);
int vars_update(VARLIST *varlist, char *name, char *content, int contentlen);
int vars_get(VARLIST *varlist, char *name, VAR *var);
int vars_read(VARLIST *varlist, char *file, int overwrite);
int vars_write(VARLIST *varlist, char *file);
*/

int main(void)
{
    char file[] = "myVars.backup";
    VARLIST varlist;
    VAR var1;
    
    vars_read(&varlist, file, VAR_NO_OVERWRITE);
    vars_add(&varlist, "var1", "\x00\x00\x00\x00", sizeof(int), VAR_NO_OVERWRITE);
    
    vars_get(&varlist, "var1", &var1);
    (*((int *) var1.content))++;
    vars_update(&varlist, "var1", var1.content, var1.info.contentlen);
    vars_write(&varlist, file);
    
    printf("var1 = %d\n", *((int *) var1.content));
    
    return 0;
}

Damit sollte man auch Structs abspeichern können.
Wenn du die ganzen Dinger auf eine feste Größe beschränken willst (Speicherplatzmäßig eher nicht zu empfehlen, aber da es ein kleines Programm sein wird sicher vertretbar), dann könntest du jeweils einen Array via vars_add hinzufügen und später wieder einlesen.

Danke, ich werd mir das mal Anschauen

**blackberry** · 30.05.2010, 12:42

Ein C-String ist ein Zeiger auf ein Zeichen. (das erste Zeichen von einer Zeichenkette)
Willst du also Strings speichern reicht es nicht einfach den Zeiger zu speichern, da beim erneuten Programmstart an der Stelle auf die der Zeiger zeigt dann sicher nicht mehr der gewünschte String ist (sofern dieser vom Programm generiert wurde, oder vom User eigegeben wurde).

Du musst also die Zeichen einzeln in die Datei schreiben und auch eine Möglichkeit finden diese zu trennen.
Dafür könnte ich zwei Formate empfehlen:
#1:
Vor jeder Zeichenkette in der Datei ist ein Integer abgespeichert, der die exakte Länge des Strings in der Datei angibt. Also:
lese int (länge) ein.
reserviere (länge) + 1 bytes via malloc, oder mit dem new-Operator.
lese (länge) bytes vom stream (die Zeichenkette).
setze das letzte Byte auf 0x00 (Null-Terminierung)

#2
Strings sind in der Datei selber durch Nullbytes getrennt (Vorteil: einfacheres Format; Nachteil: man weiß nicht wie groß der String ist).
Hier bietet es sich an mit der string-Klasse aus der STL zu arbeiten (da die das Speichermanagement für dich übernimmt).

solange: byte einlesen und mergen; byte kein nullbyte?
byte zu string hinzufügen.
/solange

**reddragon1212** · 30.05.2010, 12:54

also erstmal vielen Dank die information war sehr hilfreich

ich denke ich werde mich erst mal weiter durch das buch wälzen, das würde ich mit meinen jetzigen kenntnissen einfach noch nicht hin bekommen :/

aber wenn ich dann soweit bin werd ich das so umsetzen, danke

Thema: variableninhalt abspeichern

Themen-Optionen

Anzeige

Hybrid-Darstellung

variableninhalt abspeichern

Ähnliche Themen

[VB.Net] Listview einträge in abspeichern und auslesen

checkbox in datenbank abspeichern wie?

FileZilla Session abspeichern

Problem: Projekte richtig abspeichern

Stichworte

Berechtigungen