Gleich zu beginn, ich habe mit Absicht meine eigene Behandlung des Dynamischen Arrays gebaut, um das zu verstehen, wie es intern in etwa aufgebaut sein könnte (bei vectoren)

Hier mal der Source:

mystring.h

#include <iostream>
#include <cstring>
#include <sstream>
#include <stdarg.h>

#ifndef MYSTRING
#define MYSTRING 1
using namespace std;

class myString{
    string value;
    public:
        myString& operator=(string v1);

        int toInt();
        float toFloat();
        double toDouble();
        string toString();
};
#endif
class myString;

mystring.cpp

#include "mystring.h"

int myString::toInt()
{
    stringstream ssStream(this->value);
    int iReturn;
    ssStream >> iReturn;

    return iReturn;
}

float myString::toFloat()
{
    stringstream ssStream(this->value);
    float fReturn;
    ssStream >> fReturn;

    return fReturn;
}

double myString::toDouble()
{
    stringstream ssStream(this->value);
    double dReturn;
    ssStream >> dReturn;

    return dReturn;
}

string myString::toString()
{
    return this->value;
}

myString& myString::operator=(string v1){
    this->value = v1;
    return *this;
};

config.h

#include "mystring.h"

#ifndef MYCONFIG
#define MYCONFIG 1
enum MyConfigTypes{
    READ_ONLY,
    READ_WRITE
};

struct MyConfigStructure{
    myString Value;
    string ConfigName;
    MyConfigTypes Type;
};
class Config{
    public:
        void AddDefaultConfigVar(string,string,MyConfigTypes);
        void SetConfigVar(string,string);
        myString GetConfigVar(string);

        int GetSize();

        Config();
        ~Config();

        void LoadConfig(string);
        void SaveConfig(string);

        void SetDebug(bool);
    private:
        void __Debug(string, ...);

        void __AddArrayElement();
        void __DeleteArrayElement(int);

        MyConfigStructure* ConfigArray;
        int CurrArraySize;
        bool IsDebugEnabled;

};

extern Config ConfigHandle;
#endif
class Config;

config.cpp

#include "config.h"

Config ConfigHandle;

void Config::__Debug(string DebugMessage, ...){
    if(this->IsDebugEnabled == true){
        va_list argzeiger;
        va_start(argzeiger,DebugMessage);

        DebugMessage = "ConfigDebug: " + DebugMessage;

        vprintf(DebugMessage.c_str(),argzeiger);
        va_end(argzeiger);
    }
}

int Config::GetSize(){
    return this->CurrArraySize;
}

void Config::__AddArrayElement(){
    MyConfigStructure* TempArray;
    TempArray = new MyConfigStructure[(this->CurrArraySize+1)];

    for(int i = 0; i < this->CurrArraySize; i++)
        TempArray[i] = this->ConfigArray[i];

    this->ConfigArray = TempArray;
    this->CurrArraySize++;

    this->__Debug("__AddArrayElement: Element erfolgreich hinzugefügt...\n");
}

void Config::__DeleteArrayElement(int DelID){
    MyConfigStructure* TempArray;
    TempArray = new MyConfigStructure[(this->CurrArraySize-1)];

    int MinusCount = 0;
    for(int i = 0; i < this->CurrArraySize; i++){
        if(i == DelID){
            MinusCount = 1;
        }else{
            if(MinusCount == 0)
                TempArray[i] = this->ConfigArray[i];
            else
                TempArray[i-1] = this->ConfigArray[i];
        }
    }

    this->ConfigArray = TempArray;
    this->CurrArraySize--;
}

void Config::SetConfigVar(string VarName, string VarValue){
    this->__Debug("SetConfigVar: Start.\n");
    for(int i = 0; i<this->CurrArraySize; i++){
        if(this->ConfigArray[i].ConfigName == VarName){
            if(this->ConfigArray[i].Type != READ_ONLY){
                this->ConfigArray[i].Value = VarValue;
            }else{
                this->__Debug("Warnung: ConfigValue[%s] ist schreibgeschuetzt.\n\n",VarName.c_str());
            }
            break;
        }else{
            if(this->ConfigArray[i].ConfigName == "")
            {
                this->ConfigArray[i].ConfigName = VarName;
                this->ConfigArray[i].Value = VarValue;
                this->ConfigArray[i].Type = READ_WRITE;
                this->__Debug("SetConfigVar: Setze vorhandene Array Value auf neuen Wert.\n");
                break;
            }
        }
        if(i == this->CurrArraySize-1){
            this->__Debug("SetConfigVar: Fordere mehr Elemente an.\n");
            this->__AddArrayElement();
            this->SetConfigVar(VarName, VarValue);
            break;
        }
    }
};

void Config::AddDefaultConfigVar(string VarName,string VarValue,MyConfigTypes Type){
    for(int i = 0; i<this->CurrArraySize; i++){
        if(this->ConfigArray[i].ConfigName == VarName){
            this->ConfigArray[i].Value = VarValue;
            this->ConfigArray[i].Type = Type;
            break;
        }else{
            if(this->ConfigArray[i].ConfigName == "")
            {
                this->ConfigArray[i].ConfigName = VarName;
                this->ConfigArray[i].Value = VarValue;
                this->ConfigArray[i].Type = Type;
                break;
            }
        }
        if(i == this->CurrArraySize-1){
            this->__Debug("SetConfigVar: Fordere mehr Elemente an.\n");
            this->__AddArrayElement();
            this->SetConfigVar(VarName, VarValue);
            break;
        }
    }
};

myString Config::GetConfigVar(string VarName){
    myString ReturnVar;
    ReturnVar = "";
    for(int i = 0; i<this->CurrArraySize; i++){
        if(this->ConfigArray[i].ConfigName == VarName){
            ReturnVar = this->ConfigArray[i].Value;
            this->__Debug("GetConfigVar: Returne passenden Eintrag.\n");
            break;
        }
    }

    return ReturnVar;
};

void Config::SetDebug(bool State){
    this->IsDebugEnabled = State;
}

void Config::LoadConfig(string FileName){
    FILE * pFile;

    char Name[255];
    char Value[255];

    pFile = fopen (FileName.c_str(),"r");

    if(pFile){
        while (!feof(pFile)) {
            fscanf (pFile, "%s = %s\n", Name, Value);
            this->SetConfigVar(Name,Value);
        }
        fclose (pFile);
    }else{
        this->__Debug("%s konnte nicht geöffnet werden.\n\n", FileName.c_str());
    }
}
void Config::SaveConfig(string FileName){
    FILE * pFile;

    pFile = fopen (FileName.c_str(),"w+");
    if(pFile){
        for (int i=0 ; i<this->CurrArraySize ; i++)
        {
            if(this->ConfigArray[i].ConfigName != ""){
                if(this->ConfigArray[i].Type != READ_ONLY){
                    fprintf (pFile, "%s = %s\n",this->ConfigArray[i].ConfigName.c_str(),this->ConfigArray[i].Value.toString().c_str());
                }
            }else{
                break;
            }
        }
        fclose (pFile);
    }else{
        this->__Debug("%s konnte nicht geöffnet werden.\n\n", FileName.c_str());
    }
}

Config::Config(){
    this->CurrArraySize = 1;
    this->ConfigArray = new MyConfigStructure[1];
    this->IsDebugEnabled = false;
}

Config::~Config(){
    delete this->ConfigArray;
}

Wie gesagt, wäre schon wenn mir Fehler aufgezeigt werden könnten, ich nehme auch Lob entgegen, wobei ich kaum denke, dass man das Loben kann...

Ansonsten: Die Speicherverwaltung solltest du lieber den Profis überlassen - std::vector<> (in deinem Fall würde ich sogar eine std::map<> empfehlen) ist da wesentlich besser optimiert als dein Lösungsansatz. Und anstelle der FILE*-Dateiverarbeitung würde ich dir zu IOStreams raten.

PS: Und Namen mit __ am Anfang solltest du besser nicht verwenden - die sind reserviert für die Nutzung durch den Compiler.

vector<MyConfigStructure> ConfigArray;

geschrieben habe, der mit nen NoType Fehler rausgehaun hat... (Ich meine iss ja auch klar, iss ja ne Structure und kein Type)

Das mit dem this, merk ich mir und änders auch noch

Und __ Finde ich einfach Praktisch um Funktionen, für mich verständlich, als Verwaltungsfunktionen zu deklarieren, also diese Funktionen aber eine Grundlegende Bedeutung in der Klasse und sind meistens für Verwaltung oder Debuggen zuständig... das man es nicht machen sollte ist mir bewusst... ich werd die __ einfach nach dem Namen der Funktion setzen und schon gehts auch

Bei Vector hatte ich aber leider das Problem, dass wenn ich:

vector<MyConfigStructure> ConfigArray;

geschrieben habe, der mit nen NoType Fehler rausgehaun hat... (Ich meine iss ja auch klar, iss ja ne Structure und kein Type)

Auch eine struct ist ein Typ Also was genau war die Meldung, die du bekommen hast? (und wie sah der zugehörige Code aus?)

PS: Was die Namen mit Unterstrichen angeht: Nicht alle derartigen Namen werden tatsächlich benutzt. Aber ein Compilerhersteller kann sich jederzeit entscheiden, einen dieser Namen zu verwenden - und wenn z.B. in der nächsten Version deines Compilers ein #define __Debug auftaucht, fliegt dir dein Programm um die Ohren.

PPS: Was für einen Sinn sollen denn die Forward-Deklarationen class mystring; bzw. class config; am Ende der Header haben?

Zu deinem PPS, k.A. hab das hier irgendwo gesehn, wo es um Aufteilung einer Klasse in mehrere Dateien ging, und da wurde es genau so erklärt...
Ich habs einfach übernommen

Zu deinem PS, wie gesagt ich änder das in FuncName__(...)

statt char array würde ich std:string nehmen

Wo genau meinst du bitte??
Ich arbeite die ganze Zeit doch mit string und myString, das einzige mal wo ich char array nehme ist wenn ich das mit c_str() umcaste, damit ichs in den Funktionen verwenden kann???

Ich arbeite die ganze Zeit doch mit string und myString, das einzige mal wo ich char array nehme ist wenn ich das mit c_str() umcaste, damit ichs in den Funktionen verwenden kann???

Erstens kannst du dort die Zwischenspeicherung weglassen und den Rückgabewert von c_str() direkt an fprintf() weitergeben - und zweitens solltest du dort lieber umsteigen auf fstream

Zur internen Speicherung: Ich würde sogar den vector ganz überspringen und stattdessen eine map<string,pair<myString,MyConfigTypes> > verwenden - damit erleichterst du dir die ganzen Suchvorgänge nach einem bestimmten Config-Eintrag.

PS: Zu den Forward-Deklarationen: Die bringen einen Nutzwert von 0.0, also kannst du sie auch weglassen

PPS: Was genau bezweckst du mit dem Config ConfigHandle; ? Entweder der Nutzer kann seine Config-Objekte bei Bedarf definieren, dann braucht er dieses nicht - oder du beschränkst die Nutzung auf genau dieses Objekt, aber dann solltest du ein vernünftiges Singleton aufbauen.

Erstens kannst du dort die Zwischenspeicherung weglassen und den Rückgabewert von c_str() direkt an fprintf() weitergeben - und zweitens solltest du dort lieber umsteigen auf fstream

Okay, ich lese mit die Referenz von fstream mal durch, und ändere dementsprechend.

Zur internen Speicherung: Ich würde sogar den vector ganz überspringen und stattdessen eine map<string,pair<myString,MyConfigTypes> > verwenden - damit erleichterst du dir die ganzen Suchvorgänge nach einem bestimmten Config-Eintrag.

Hier fängts an interessant zu werden, weil ich ab hier 0,0% Plan hab wie man sowas machen könnte, ein Schnippet wäre schön *liebgugg*

Zum PS: Okay ich machse weg

Zum PPS: Ja, der iss für den Globalen Zugriff auf die Klasse da, hab schon über so ein Singleton-Dingens nachgedacht, werd mir demnächst mal ne TUt darüber anschauen und euch dann warscheinlich mit sinnlosen Anfängerfragen bombadieren :D:D

struct MyConfigStrucure
{
  myString Value;
  MyConfgTypes Type
};

typedef map<string,MyConfigStructure> map_type;
map_type ConfigArray;

void Config::SetConfigVar(string VarName, string VarValue){
    __Debug("SetConfigVar: Start.\n");
    map_type::iterator pos=ConfigArray.find(VarName);
    if(pos==ConfigArray.end()
    {
        //nicht gefunden
    }
    else if(pos->Type!=READ_ONLY)
        pos->Value = VarValue;
    else
        Debug("Warnung: ConfigValue[%s] ist schreibgeschuetzt.\n\n",VarName.c_str());
};

(nur mal ein Ausschnitt)

Nun mal noch eine Frage zu Singleton Pattern...

Wenn ich die Dinger hier Privat deklariere,

private:
    Config() {};
    Config(const Config&);
    Config& operator=(const Config&);

damit daruf von aussen nicht zugrgriffen werden kann, muss ich die dann auch noch irgendwo definieren oder kann ich das gänzlich weg lassen, also das definieren? Weil ich selber benötige die ja auch nicht in meinen Funktionen?? Das einzige was ich Deklarieren sollte ist der Konstruktur, den CopyKonstruktur muss ich, bzw. will ich nicht definieren und im Destruct wird dann einfach nur das Speicherbereich-Reinigen reingetan, die dann beim Zerfall des static Objektes gecalled wird..

Des weiteren reich es dann auch eine public Method zu implementieren, die einfach ein Statische sobjekt erzeugt und zurück gibt oder? (Meyers-Singleton)
So gen Richtugn:

public:
        static Config& GetInstanz() 
        {

            static Config Instanz;
            return Instanz;
        }

Oder sehe ich das falsch??
Eigentlich müsste´s das doch alles sein, um das Singleton zu implementieren oder??

Ansonsten reicht der Singleton so für den Hausgebrauch durchaus aus.

if(pos->Type!=READ_ONLY)

Bringt folgendes: error: 'struct std::pair<const std::string, MyConfigStructure>' has no member named 'Type'

das gleiche auch für den member 'Value'

Warum ist das so?

EDIT:
Ist es korrekt, wenn ich es in:

pos->second.Type

ändere, weil ich ja auf das 2te element zugreifen will, bzw. auf den 2ten Typen?