Meine Hauptdatei "Test.cpp":

#include "ConfigLaden.h"
#include <iostream>
using namespace std;

int main (int nNumberofArgs, char* pszArgs[])
{
    ConfigLoad Test("Pups.txt");
    Test.ReadNextLine();
    if (Test.FoundString("Hallo!"))
    {
        cout << "Tada!";
    } else {
        cout << "Geht net";
    }
    return 0;
}

Die "ConfigLaden.h":

#ifndef _CONFLADEN_H_
#define _CONFLADEN_H_
#include <string>
#include <fstream>

using namespace std;

class ConfigLoad
{
    private:
        char* Puffer;
        ifstream *pKonfiguration;

    public:
        ConfigLoad(char* file);
        void ReadNextLine();
        bool FoundString(char* search) const;
        size_t StringPos(char* search) const;
        int ReadInt(size_t nPosition) const;//Bis kein Zahlzeichen mehr kommt
        double ReadDouble(size_t nPosition) const;
        char* ReadString(size_t nPosition) const;
}
#endif

Und die "ConfigLaden.cpp", gekürzt, damits nicht zu lange wird:

//using namespace std;

ConfigLoad::ConfigLoad(char* file)
{
    Puffer = new char[1000];

    //Datei öffnen
    pKonfiguration = new ifstream (file);

    //Fehlerkontrolle
    if (!pKonfiguration -> good())
    {
        delete pKonfiguration;
        cout << " konnte nicht geöffnet werden.";
    }
}

void ConfigLoad::ReadNextLine()
{
    if (!pKonfiguration -> eof())
    {
        pKonfiguration -> getline(Puffer, 1000);
    }
}

bool ConfigLoad::FoundString(char* search) const
{
    bool found = false;
    size_t position = 1000;

    //Suchen
    position = Puffer.find(search);
    if (position != 1000)
    {
        found = true;
    }

    return found;
}

size_t ConfigLoad::StringPos(char* search) const
{
    size_t found = 0;

    //Suchen
    found = Puffer.find(search);
    found += search.length();

    return found;
}

int ConfigLoad::ReadInt(size_t nPosition) const
{
    int Integer = 0;
    char* ZwischenPuffer = new char[1000];
    char* IntPuffer = new char[1000];
    bool Zahl = false;

    //ZwischenPuffer füllen
    ZwischenPuffer = Puffer.substr (nPosition);

    //Ab dem ersten nicht-Zahlzeichen abschneiden
    for (size_t i = 0; i < ZwischenPuffer.length(); i++)
    {
        Zahl = false;

        switch (ZwischenPuffer[i])
        {
            case "0":
                Zahl = true;
                break;
            case "1":
                Zahl = true;
                break;
            case "2":
                Zahl = true;
                break;
            case "3":
                Zahl = true;
                break;
            case "4":
                Zahl = true;
                break;
            case "5":
                Zahl = true;
                break;
            case "6":
                Zahl = true;
                break;
            case "7":
                Zahl = true;
                break;
            case "8":
                Zahl = true;
                break;
            case "9":
                Zahl = true;
                break;
            default:
                break;
        }

        //Wenn Zahl zu Ende, zusammenkopieren
        if(!Zahl)
        {
            IntPuffer = ZwischenPuffer.substr (0, (i - 1));
            i = ZwischenPuffer.length(); //Schleife beenden
        }
    }
    //In int umwandeln
    Integer = atoi(IntPuffer);

    return Integer;
}

double ConfigLoad::ReadDouble(size_t nPosition) const
{
    double Double = 0.0;
    char* ZwischenPuffer = new char[1000];
    char* DoublePuffer = new char[1000];
    bool Zahl = false;

    //ZwischenPuffer füllen
    ZwischenPuffer = Puffer.substr (nPosition);

    //Ab dem ersten nicht-Zahlzeichen abschneiden
    for (size_t i = 0; i < ZwischenPuffer.length(); i++)
    {
        Zahl = false;

        switch (ZwischenPuffer[i])
        {
            case "0":
                Zahl = true;
                break;
            case "1":
                Zahl = true;
                break;
            case "2":
                Zahl = true;
                break;
            case "3":
                Zahl = true;
                break;
            case "4":
                Zahl = true;
                break;
            case "5":
                Zahl = true;
                break;
            case "6":
                Zahl = true;
                break;
            case "7":
                Zahl = true;
                break;
            case "8":
                Zahl = true;
                break;
            case "9":
                Zahl = true;
                break;
            case ".":
                Zahl = true;
                break;
            default:
                break;
        }

        //Wenn Zahl zu Ende, zusammenkopieren
        if(!Zahl)
        {
            DoublePuffer = ZwischenPuffer.substr (0, (i - 1));
            i = ZwischenPuffer.length(); //Schleife beenden
        }
    }
    //In int umwandeln
    Double = atof(DoublePuffer);

    return Double;
}

char* ConfigLoad::ReadString(size_t nPosition) const
{
    char* ZwischenPuffer = new char[1000];
    char* EndPuffer = new char[1000];
    bool Leerzeichen = false;

    //ZischenPuffer füllen
    ZwischenPuffer = Puffer.substr (nPosition);

    //Ab dem ersten nicht-Zeichen abschneiden
    for (size_t i = 0; i < ZwischenPuffer.length(); i++)
    {
        Leerzeichen = false;

        switch (ZwischenPuffer[i])
        {
            case " ":
                Leerzeichen = true;
                break;
            case "\0":
                Leerzeichen = true;
                break;
            case "\r":
                Leerzeichen = true;
                break;
            case "\n":
                Leerzeichen = true;
                break;
            case "\t":
                Leerzeichen = true;
                break;
            case "":
                Leerzeichen = true;
                break;
            default:
                break;
        }

        //Wenn Zahl zu Ende, zusammenkopieren
        if(Leerzeichen)
        {
            EndPuffer = ZwischenPuffer.substr (0, (i - 1));
            i = ZwischenPuffer.length(); //Schleife beenden
        }
    }

    return EndPuffer;
}

Egal was ich amche, ich hab auch schon einmal alle Semikolons überprüft, weil Google das als Fehlerquelle vorgeschlagen hat. Ich erhalte immer:

C:\Programme\CodeBlocks\MinGW\bin\..\lib\gcc\mingw32\3.4.5\..\..\..\..\include\c++\3.4.5\iostream|48|error: expected unqualified-id before "namespace"|
C:\Eigene Dateien\C++\Projekte\Dateientest\Test.cpp||In function `int main(int, char**)':|
C:\Eigene Dateien\C++\Projekte\Dateientest\Test.cpp|11|error: `cout' was not declared in this scope|
C:\Eigene Dateien\C++\Projekte\Dateientest\Test.cpp|11|warning: unused variable 'cout'|
C:\Eigene Dateien\C++\Projekte\Dateientest\Test.cpp|13|error: `cout' was not declared in this scope|
C:\Eigene Dateien\C++\Projekte\Dateientest\Test.cpp|13|warning: unused variable 'cout'|
||=== Build finished: 3 errors, 2 warnings ===|

Woran kann das liegen? Wie gesagt, bei Google hab ich nur den Fehler gefunden, dass ein Semikolon irgendwo fehlt, aber ich finde kein Fehlendes.

kleiner tip um solche fehler zu vermeiden:
binde zuerst die standardheader ein und dann deine eigenen

#include <string>
#include <fstream>
#include <iostream>
#include <cctype>
#include "ConfigLaden.h"

//using namespace std;

ConfigLoad::ConfigLoad(char* file)
{
    Puffer = new char[1000];

    //Datei öffnen
    pKonfiguration = new std::ifstream (file);

    //Fehlerkontrolle
    if (!pKonfiguration -> good())
    {
        delete pKonfiguration;
        std::cout << " konnte nicht geöffnet werden.";
    }
}

void ConfigLoad::ReadNextLine()
{
    if (!pKonfiguration -> eof())
    {
        pKonfiguration -> getline(Puffer, 1000);
    }
}

bool ConfigLoad::FoundString(char* search) const
{
    bool found = false;
    size_t position = 1000;

    //Suchen
    position = Puffer.find(search);
    if (position != 1000)
    {
        found = true;
    }

    return found;
}

size_t ConfigLoad::StringPos(char* search) const
{
    size_t found = 0;

    //Suchen
    found = Puffer.find(search);
    found += search.length();

    return found;
}

int ConfigLoad::ReadInt(size_t nPosition) const
{
    int Integer = 0;
    char* ZwischenPuffer = new char[1000];
    char* IntPuffer = new char[1000];
    bool Zahl = false;

    //ZwischenPuffer füllen
    ZwischenPuffer = Puffer.substr (nPosition);

    //Ab dem ersten nicht-Zahlzeichen abschneiden
    for (size_t i = 0; i < ZwischenPuffer.length(); i++)
    {
        Zahl = false;

        if(isdigit(ZwischenPuffer[i]))
        {
            Zahl = true;
        }

        //Wenn Zahl zu Ende, zusammenkopieren
        if(!Zahl)
        {
            IntPuffer = ZwischenPuffer.substr (0, (i - 1));
            i = ZwischenPuffer.length(); //Schleife beenden
        }
    }
    //In int umwandeln
    Integer = atoi(IntPuffer);

    return Integer;
}

double ConfigLoad::ReadDouble(size_t nPosition) const
{
    double Double = 0.0;
    char* ZwischenPuffer = new char[1000];
    char* DoublePuffer = new char[1000];
    bool Zahl = false;

    //ZwischenPuffer füllen
    ZwischenPuffer = Puffer.substr (nPosition);

    //Ab dem ersten nicht-Zahlzeichen abschneiden
    for (size_t i = 0; i < ZwischenPuffer.length(); i++)
    {
        Zahl = false;

        if (isdigit(ZwischenPuffer[i]))
        {
            Zahl = true;
        }

        if (ZwischenPuffer[i] == ".")
        {
            Zahl = true;
        }

        //Wenn Zahl zu Ende, zusammenkopieren
        if(!Zahl)
        {
            DoublePuffer = ZwischenPuffer.substr (0, (i - 1));
            i = ZwischenPuffer.length(); //Schleife beenden
        }
    }
    //In int umwandeln
    Double = atof(DoublePuffer);

    return Double;
}

char* ConfigLoad::ReadString(size_t nPosition) const
{
    char* ZwischenPuffer = new char[1000];
    char* EndPuffer = new char[1000];
    bool Leerzeichen = false;

    //ZischenPuffer füllen
    ZwischenPuffer = Puffer.substr (nPosition);

    //Ab dem ersten nicht-Zeichen abschneiden
    for (size_t i = 0; i < ZwischenPuffer.length(); i++)
    {
        Leerzeichen = false;

        if (isspace(ZwischenPuffer[i]))
        {
            Leerzeichen = true;
        }

        //Wenn Zahl zu Ende, zusammenkopieren
        if(Leerzeichen)
        {
            EndPuffer = ZwischenPuffer.substr (0, (i - 1));
            i = ZwischenPuffer.length(); //Schleife beenden
        }
    }

    return EndPuffer;
}

Und die Fehlermeldungen:

ConfigLaden.cpp||In member function `bool ConfigLoad::FoundString(char*) const':|
ConfigLaden.cpp|39|error: request for member `find' in `((const ConfigLoad*)this)->ConfigLoad::Puffer', which is of non-class type `char* const'|
ConfigLaden.cpp||In member function `size_t ConfigLoad::StringPos(char*) const':|
ConfigLaden.cpp|53|error: request for member `find' in `((const ConfigLoad*)this)->ConfigLoad::Puffer', which is of non-class type `char* const'|
ConfigLaden.cpp|54|error: request for member `length' in `search', which is of non-class type `char*'|
ConfigLaden.cpp||In member function `int ConfigLoad::ReadInt(size_t) const':|
ConfigLaden.cpp|67|error: request for member `substr' in `((const ConfigLoad*)this)->ConfigLoad::Puffer', which is of non-class type `char* const'|
ConfigLaden.cpp|70|error: request for member `length' in `ZwischenPuffer', which is of non-class type `char*'|
ConfigLaden.cpp|82|error: request for member `substr' in `ZwischenPuffer', which is of non-class type `char*'|
ConfigLaden.cpp|83|error: request for member `length' in `ZwischenPuffer', which is of non-class type `char*'|
ConfigLaden.cpp||In member function `double ConfigLoad::ReadDouble(size_t) const':|
ConfigLaden.cpp|100|error: request for member `substr' in `((const ConfigLoad*)this)->ConfigLoad::Puffer', which is of non-class type `char* const'|
ConfigLaden.cpp|103|error: request for member `length' in `ZwischenPuffer', which is of non-class type `char*'|
ConfigLaden.cpp|120|error: request for member `substr' in `ZwischenPuffer', which is of non-class type `char*'|
ConfigLaden.cpp|121|error: request for member `length' in `ZwischenPuffer', which is of non-class type `char*'|
ConfigLaden.cpp||In member function `char* ConfigLoad::ReadString(size_t) const':|
ConfigLaden.cpp|137|error: request for member `substr' in `((const ConfigLoad*)this)->ConfigLoad::Puffer', which is of non-class type `char* const'|
ConfigLaden.cpp|140|error: request for member `length' in `ZwischenPuffer', which is of non-class type `char*'|
ConfigLaden.cpp|152|error: request for member `substr' in `ZwischenPuffer', which is of non-class type `char*'|
ConfigLaden.cpp|153|error: request for member `length' in `ZwischenPuffer', which is of non-class type `char*'|
||=== Build finished: 16 errors, 0 warnings ===|

Ich werd da echt nicht schlau draus.

error: request for member `find' in `((const ConfigLoad*)this)->ConfigLoad::Puffer', which is of non-class type `char* const'

ist doche eindeutig.
Du behandelst nen const char* wie ein Objekt... Der "Puffer" sollte vllt ein std::string sein?!?

C:\Eigene Dateien\C++\Projekte\Dateientest\ConfigLaden.cpp||In member function `void ConfigLoad::ReadNextLine()':|
ConfigLaden.cpp|31|error: no matching function for call to `std::basic_ifstream<char, std::char_traits<char> >::getline(std::string&, int)'|
C:\Programme\CodeBlocks\MinGW\bin\..\lib\gcc\mingw32\3.4.5\..\..\..\..\include\c++\3.4.5\bits\istream.tcc|582|note: candidates are: std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::getline(_CharT*, std::streamsize, _CharT) [with _CharT = char, _Traits = std::char_traits<char>]|
C:\Programme\CodeBlocks\MinGW\bin\..\lib\gcc\mingw32\3.4.5\..\..\..\..\include\c++\3.4.5\istream|399|note:                 std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::getline(_CharT*, std::streamsize) [with _CharT = char, _Traits = std::char_traits<char>]|

Gibt es einen Weg, ein char-Array in einen String umzuwandeln?

Die anderen Puffer sind immer noch char-Arrays und mit einem einfachen "=", wie hier:

ZwischenPuffer = Puffer.substr (nPosition);

will er die Umwandlung nicht machen:

C:\Eigene Dateien\C++\Projekte\Dateientest\ConfigLaden.cpp|69|error: cannot convert `std::basic_string<char, std::char_traits<char>, std::allocator<char> >' to `char*' in assignment|

Gibt es einen Weg, ein char-Array in einen String umzuwandeln?

Die anderen Puffer sind immer noch char-Arrays und mit einem einfachen "=", wie hier:

ZwischenPuffer = Puffer.substr (nPosition);

will er die Umwandlung nicht machen:

C:\Eigene Dateien\C++\Projekte\Dateientest\ConfigLaden.cpp|69|error: cannot convert `std::basic_string<char, std::char_traits<char>, std::allocator<char> >' to `char*' in assignment|

Mannmannmann... Wieso denn char* umwandeln in string?!? Verwende einen std::string! char*::find gibt es einfach nicht, da bracuht man sich nicht wundern.

Und genau so liest du aus nem std::istream in einen std::string:
http://www.cplusplus.com/reference/string/getline/

Solltest echt noch etwas in deinem C++-Buch schmökern, bevor du dich an solch "komplexe" Programme ransetzt

• Viel zu viele new s und new[] s
• Viel zu viele Zeiger
• Zuviel char*
• Speicher- und Resource-Lecks
• Ein impliziter Konstruktor, der ein expliziter sein sollte
• Misachtung der Dreierregel
• Puffer ist vom Typ char* und besitzt keine Elementfunktionen (wie zB "find")

Dir ist scheinbar das RAII-Konzept noch nicht bekannt. Unbedingt nachholen! In C++ kapselt man die Verwaltung einer einzelnen Resource in der Regel in einem dedizierten Objekt (zB std::string oder std::ifstream ).

Objekte, die "logisch" gesehen Mitglieder eines anderen Objektes sind, sollten es auch "praktisch" sein, sofern möglich -- also direkte Objekt-Mitglieder, statt nur über private Zeiger erreichbar.

class foo {
    ...
    std::ifstream dings; // <-- muss kein Zeiger sein
    ...
  };

Es gibt natürlich ausnahmen (Polymorphie, Compiler-Firewall). In Deinem Fall ist aber ein Zeiger auf ein ifstream Objekt unnötig. Du erzeugst dieses Objekt direkt im Konstruktor selbst. Es kann genauso gut ein "echtes" Objekt-Element sein.

BTW: Konstruktoren dürfen auch Exceptions schmeißen.

Tipp: Schnapp Dir ein gutes Buch zum Thema C++. Du kannst Dir damit viel Zeit und Ärger ersparen. Du tappst im Moment im Dunkeln. Ein Buch kann hier sehr erhellend sein und Dir den Weg leuchten -- mal metaphorisch gesprochen.

Gruß,
SP

@OMGler, ich benutze die getline-Funktion exakt so wie in der Referenz beschrieben und trotzdem bekomme ich die schon geposteten Fehlermeldungen. Der Fehler liegt irgendwo anders.

Ich schreib jetzt alles zum zweiten Mal zurück in String und mach den Filestreamzeiger zu nem Filestream.

Die "ConfigLaden.cpp" geht jetzt so:

#include <string>
#include <fstream>
#include <iostream>
#include <cctype>
#include "ConfigLaden.h"

//using namespace std;

ConfigLoad::ConfigLoad(std::string file)
{
    //Puffer = new char[1000];

    Puffer = "";

    //Datei öffnen
    std::ifstream Konfiguration(file);

    //Fehlerkontrolle
    if (!Konfiguration -> good())
    {
        Konfiguration.close();
        std::cout << "Konnte nicht geoeffnet werden.";
    }
}

void ConfigLoad::ReadNextLine()
{
    if (!Konfiguration.eof())
    {
        Konfiguration.getline(Puffer, 1000);
    }
}

bool ConfigLoad::FoundString(std::string search) const
{
    bool found = false;
    size_t position = 1000;

    //Suchen
    position = Puffer.find(search);
    if (position != 1000)
    {
        found = true;
    }

    return found;
}

size_t ConfigLoad::StringPos(std::string search) const
{
    size_t found = 0;

    //Suchen
    found = Puffer.find(search);
    found += search.length();

    return found;
}

int ConfigLoad::ReadInt(size_t nPosition) const
{
    int Integer = 0;
    std::string ZwischenPuffer;
    std::string IntPuffer;
    bool Zahl = false;

    //ZwischenPuffer füllen
    ZwischenPuffer = Puffer.substr (nPosition);

    //Ab dem ersten nicht-Zahlzeichen abschneiden
    for (size_t i = 0; i < ZwischenPuffer.length(); i++)
    {
        Zahl = false;

        if(isdigit(ZwischenPuffer[i]))
        {
            Zahl = true;
        }

        //Wenn Zahl zu Ende, zusammenkopieren
        if(!Zahl)
        {
            IntPuffer = ZwischenPuffer.substr (0, (i - 1));
            i = ZwischenPuffer.length(); //Schleife beenden
        }
    }
    //In int umwandeln
    Integer = atoi(IntPuffer);

    return Integer;
}

double ConfigLoad::ReadDouble(size_t nPosition) const
{
    double Double = 0.0;
    std::string ZwischenPuffer;
    std::string DoublePuffer;
    bool Zahl = false;

    //ZwischenPuffer füllen
    ZwischenPuffer = Puffer.substr (nPosition);

    //Ab dem ersten nicht-Zahlzeichen abschneiden
    for (size_t i = 0; i < ZwischenPuffer.length(); i++)
    {
        Zahl = false;

        if (isdigit(ZwischenPuffer[i]))
        {
            Zahl = true;
        }

        if (ZwischenPuffer[i] == '.')
        {
            Zahl = true;
        }

        //Wenn Zahl zu Ende, zusammenkopieren
        if(!Zahl)
        {
            DoublePuffer = ZwischenPuffer.substr (0, (i - 1));
            i = ZwischenPuffer.length(); //Schleife beenden
        }
    }
    //In int umwandeln
    Double = atof(DoublePuffer);

    return Double;
}

std::string ConfigLoad::ReadString(size_t nPosition) const
{
    std::string ZwischenPuffer;
    std::string EndPuffer;
    bool Leerzeichen = false;

    //ZischenPuffer füllen
    ZwischenPuffer = Puffer.substr (nPosition);

    //Ab dem ersten nicht-Zeichen abschneiden
    for (size_t i = 0; i < ZwischenPuffer.length(); i++)
    {
        Leerzeichen = false;

        if (isspace(ZwischenPuffer[i]))
        {
            Leerzeichen = true;
        }

        //Wenn Zahl zu Ende, zusammenkopieren
        if(Leerzeichen)
        {
            EndPuffer = ZwischenPuffer.substr (0, (i - 1));
            i = ZwischenPuffer.length(); //Schleife beenden
        }
    }

    return EndPuffer;
}

Die Fehlermeldungen: Der Compiler sucht basic_ifstream anstatt ifstream und die atoi und atof Funktionen funktionieren mit Strings nicht.

ConfigLaden.cpp||In constructor `ConfigLoad::ConfigLoad(std::string)':|
ConfigLaden.cpp|17|error: `ifstream' was not declared in this scope|
ConfigLaden.cpp|17|error: expected `;' before "Konfiguration"|
ConfigLaden.cpp|20|error: base operand of `->' has non-pointer type `std::ifstream'|
ConfigLaden.cpp|17|warning: unused variable 'ifstream'|
ConfigLaden.cpp||In member function `void ConfigLoad::ReadNextLine()':|
ConfigLaden.cpp|31|error: no matching function for call to `std::basic_ifstream<char, std::char_traits<char> >::getline(std::string&, int)'|
istream.tcc|582|note: candidates are: std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::getline(_CharT*, std::streamsize, _CharT) [with _CharT = char, _Traits = std::char_traits<char>]|
istream|399|note:                 std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::getline(_CharT*, std::streamsize) [with _CharT = char, _Traits = std::char_traits<char>]|
ConfigLaden.cpp||In member function `int ConfigLoad::ReadInt(size_t) const':|
ConfigLaden.cpp|89|error: cannot convert `std::string' to `const char*' for argument `1' to `int atoi(const char*)'|
ConfigLaden.cpp||In member function `double ConfigLoad::ReadDouble(size_t) const':|
ConfigLaden.cpp|127|error: cannot convert `std::string' to `const char*' for argument `1' to `double atof(const char*)'|
||=== Build finished: 6 errors, 1 warnings ===|

#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <cctype>
#include "configloader.h"

ConfigLoad::ConfigLoad(const std::string& filename):
konfiguration(filename.c_str())
{
    if(!konfiguration)
        std::cerr << "Konnte nicht geoeffnet werden.\n"; 
}

bool ConfigLoad::ReadNextLine() 
{
	if(std::getline(konfiguration, puffer))
		return true;
	return false;
} 

bool ConfigLoad::FoundString(const std::string& search) const 
{
	return puffer.find(search) != std::string::npos;
}

std::string::size_type ConfigLoad::StringPos(const std::string& search) const 
{
	return puffer.find(search);
}

int ConfigLoad::ReadInt(std::string::size_type nPosition) const 
{
	int ret_int(0);
	for(std::string::size_type beg(nPosition), end(puffer.size()); beg < end; ++beg) {
		if(!isdigit(puffer[beg]) || beg + 1 == end) {
			std::istringstream iss(puffer.substr(nPosition, beg + 1));
			iss >> ret_int;
			break;
		}
	}
    return ret_int;
} 

double ConfigLoad::ReadDouble(std::string::size_type nPosition) const 
{ 
	double ret_double(0.0);
	for(std::string::size_type beg(nPosition), end(puffer.size()); beg < end; ++beg) {
		if((!isdigit(puffer[beg]) && puffer[beg] != '.') || beg + 1 == end) {
			std::istringstream iss(puffer.substr(nPosition, beg + 1));
			iss >> ret_double;
			break;
		}
	}
    return ret_double;
} 

std::string ConfigLoad::ReadString(std::string::size_type nPosition) const 
{
	std::ostringstream oss;
	for(std::string::size_type beg(nPosition), end(puffer.size()); beg < end; ++beg) {
		if(isspace(puffer[beg]) || beg + 1 == end) {
			oss.str(puffer.substr(nPosition, beg + 1));
			break;
		}
	}
    return oss.str();
}

#include "configloader.h"
#include <iostream>

int main()
{ 
    ConfigLoad config("test.txt");
	while(config.ReadNextLine()) {
		if(config.FoundString("Hallo"))
			std::cout << "Begruessung in dieser Zeile vorhanden." << std::endl;
		else
			std::cout << "Keine Begruessung vorhanden." << std::endl;

		std::cout << "Lese int an Position 0: " << config.ReadInt(0) << std::endl;
		std::cout << "Lese double an Position 0: " << config.ReadDouble(0) << std::endl;
		std::cout << "Lese Wort an Position 0: " << config.ReadString(0) << std::endl;
	}
}

test.txt

test
test Hallo test
87 noch ein Hallo test
kein test
92.4

@OMGler, ich benutze die getline-Funktion exakt so wie in der Referenz beschrieben und trotzdem bekomme ich die schon geposteten Fehlermeldungen. Der Fehler liegt irgendwo anders.

Du benutzt die eben genau nicht so wie in dem von mir geposteten Link.
Um dir das Rumsuchen zu ersparen, hier exakt das Beispiel, wie es im Link unten steht:

// getline with strings
#include <iostream>
#include <string>
using namespace std;

int main () {
  string str;
  cout << "Please enter full name: ";
  getline (cin,str);
  cout << "Thank you, " << str << ".\n";
}

Und anstatt zu jammern, solltest du echt mal die Meldungen lesen und versuchen zu verstehen (ist nicht sooo schwer).
Um das mal anzustoßen:

error: `ifstream' was not declared in this scope|

Er kennt ifstream nicht. Was macht man da?

error: expected `;' before "Konfiguration"

Folgefehler...

ConfigLaden.cpp|20|error: base operand of `->' has non-pointer type `std::ifstream'|

operator-> geht nur mit Pointern, und dein ifstream-Objekt ist ein non-pointer. Was macht man da?

Und nun:

error: no matching function for call to `std::basic_ifstream<char, std::char_traits<char> >::getline(std::string&, int)'|
istream.tcc|582|note: candidates are: std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::getline(_CharT*, std::streamsize, _CharT) [with _CharT = char, _Traits = std::char_traits<char>]|

Das sagt mir, dass du getline nicht so verwendest wie du es vorgibst...

Ich hör mit den Fehlern hier mal auf, du hast echt nur ifstream* durch ifstream ersetzt, genauso wie die Deaklaration von Puffer in std::string umgemünzt, aber im Code nichts verändert. Hol das nach...

@Krise, danke für's korrigieren. Ich werd das jetzt ein paar Mal durchlesen. Sehr lehrreich.