spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

// ///////////////////////////////////////////////////////////////////////////

// Datei:        helper.h

// ///////////////////////////////////////////////////////////////////////////

// Autor:        Patrick Ullmann

// Erstellt:     23.09.2004

// Änderungen:   23.09.2004 (Patrick)  Datei erstellt

// ///////////////////////////////////////////////////////////////////////////

// Beschreibung: Diverse kleine Hilferlein *g*


#ifndef __helper_h___23_09_2004___1076196505551201163650965128323046192943529_
#define __helper_h___23_09_2004___1076196505551201163650965128323046192943529_

// I N C L U D E S ///////////////////////////////////////////////////////////

#include <string>
#include <locale>
#include <algorithm>

// S T R U K T U R E N ///////////////////////////////////////////////////////

    // Der folgende Code wurde von Benjamin Kaufmann übernommen!!

    // http://fara.cs.uni-potsdam.de/~kaufmann/?page=GenCppFaqs&faq=stricmp

namespace helper
{
    class LocCharEq_t
    {
    public:
        LocCharEq_t (const std::locale& location = std::locale::classic()) : 
        m_location (location),
        m_type (std::use_facet<std::ctype<char> > (m_location)) {};

        inline bool operator () (char left, char right) const
        { return (m_type.tolower(left) == m_type.tolower(right)); }

    private:
        const std::locale& m_location;
        const std::ctype<char>& m_type;
    };
        
    class LocNoCaseEqual_t
    {
    public:
        LocNoCaseEqual_t (const std::locale& location = std::locale::classic()):
        m_location (location) {};
        
        inline bool operator () (const std::string& left, const std::string& right) const
        {
            if (left.length() != right.length())
                return (false);

            return  std::equal (left.begin(),
                                left.end(), right.begin(),
                                LocCharEq_t(m_location));
        }

    private:
        const std::locale& m_location;
    };

} // Namespace


// F U N K T I O N E N ///////////////////////////////////////////////////////

namespace helper
{
        // Vergleiche 2 Strings auf case-insensitiv Ebene

    inline bool equal_string (const std::string& left, 
                            const std::string& right, 
                            const std::locale& location)
    { 
        return LocNoCaseEqual_t(location)(left, right); 
    }
} // Namespace


#endif

C-/C++-Quelltext

// ///////////////////////////////////////////////////////////////////////////

// Datei:        dictionary.h

// ///////////////////////////////////////////////////////////////////////////

// Autor:        Patrick Ullmann

// Erstellt:     23.09.2004

// Änderungen:   23.09.2004 (Patrick)  Datei erstellt

// ///////////////////////////////////////////////////////////////////////////

// Beschreibung: Ein Wörterbuch halt :)


#ifndef __dictionary_h___23_09_2004___107619650555120116365096513046192943529_
#define __dictionary_h___23_09_2004___107619650555120116365096513046192943529_

// I N C L U D E S ///////////////////////////////////////////////////////////

#include <iostream>
#include <sstream>
#include <vector>
#include "helper.h"

// S T R U K T U R E N ///////////////////////////////////////////////////////

namespace dictionary
{
    class vocabulary
    {
    public:
            // Con- und Destructor

        vocabulary  (void) {};
        ~vocabulary (void) {};
        
            // Löscht alle Inhalte

        inline void clear (void)
        { 
            m_normal.clear ();
            m_translations.clear ();
        }

            // Setzt das Wort welches abgefragt wird

        inline void setNormal (const std::string &normal)
        { m_normal = normal; }

            // Gibt das Abfragungswort wieder 

        inline std::string getNormal (void) const
        { return (m_normal); }

            // Fügt ein Übersetzungswort hinzu

        inline void addTranslation (const std::string &translation)
        { 
                // Bevor das Wort rein kommt, erst testen ob es das

                // Wort schon gibt.

            if (!checkTranslation (translation))
                m_translations.push_back (translation); 
        }

            // Testet ob die Übersetzung schon vorhanden ist.

        inline bool checkTranslation (const std::string &translation) const
        {
                // Durchlaufe alle Übersetzungsmöglichkeiten

            for (unsigned int i=0; i<m_translations.size(); ++i)
            {
                    // Übersetzungsmöglichkeiten gefunden? Wenn ja, Raus hier!

                if (helper::equal_string (translation, m_translations[i], std::locale("german")))
                    return (true);
            }

                // Übersetzungsmöglichkeiten wurde nicht gefunden

            return (false);
        }

            // Gibt alle Übersetzungsmöglichkeiten schön Formatiert

            // in einem String zurück

        inline std::string getTranslations (void) const
        {
                // Der Stream für die Rückgabe

            std::stringstream result("");

                // Alle Übersetzungsmöglichkeiten durchlaufen

            for (unsigned int i=0; i<m_translations.size(); ++i)
            {
                    // Reinstopfen

                result << m_translations[i].c_str();
                    // Das letzte bekommt kein ', '!

                if (i < m_translations.size()-1)
                    result << ", ";
            }

                // Und ab damit!

            return result.str();
        }

    private:
            // Abzufragen des Wort

        std::string m_normal;
            // Übersetzungen des Wortes

        std::vector<std::string> m_translations;
    };

    class database
    {
    public:
            // Con- und Destructor

        database    (void) {};
        ~database   (void) {};

            // Ein Vokabelobjekt einfügen

        inline void add (const vocabulary &_vocabulary)
        { m_vocabulary.push_back (_vocabulary); }

            // Leert die "Datenbank"

        inline void clear (void)
        { m_vocabulary.clear (); }

            // Größe dieser "Datenbank" wiedergeben

        inline int getSize (void) const
        { return (m_vocabulary.size()); }

            // Testet den User 

        inline bool test_user (void) const
        {
                // Zufallsvokabel suchen

            int id = rand()%m_vocabulary.size();

                // Abfragen

            std::cout << "Was bedeutet '" << m_vocabulary[id].getNormal().c_str() 
                      << "' uebersetzt?" << std::endl;

                // Eingabe nehmen

            char buffer[128] = "";
            std::cin.getline (buffer, 128);

                // Ist die Eingabe richtig?

            if (m_vocabulary[id].checkTranslation(buffer))
            {
                    std::cout << "Richtig!" << std::endl;
                    return (true);
            }

                // Eingabe war Falsch!

            std::cout << "Falsch!!" << std::endl;

                // Übersetzungsmöglichkeiten ausgeben

            std::cout << "Die richtigen Uebersetzungen von '"
                      <<  m_vocabulary[id].getNormal().c_str()
                      << "' sind '"
                      << m_vocabulary[id].getTranslations().c_str()
                      << "'." << std::endl;

            return (false);
        }
    
    private:
            // Die Vokabeln

        std::vector<vocabulary>            m_vocabulary;
    };
} // Namespace


#endif

C-/C++-Quelltext

// ///////////////////////////////////////////////////////////////////////////

// Datei:        main.cpp

// ///////////////////////////////////////////////////////////////////////////

// Autor:        Patrick Ullmann

// Erstellt:     24.09.2004

// Änderungen:   24.09.2004 (Patrick)  Datei erstellt

// ///////////////////////////////////////////////////////////////////////////

// Beschreibung: Die Hauptdatei


// I N C L U D E S ///////////////////////////////////////////////////////////

#include <ctime>        // Für time(NULL);

#include "helper.h"
#include "dictionary.h"

// F U N K T I O N E N ///////////////////////////////////////////////////////

int main (void)
{
        // Random initialisieren

    ::srand(time(NULL));

        // Datenbank anlegen und Temp-Vokabelobjekt

    dictionary::database db;
    dictionary::vocabulary voc;

        // Vokabel für 'Neu' anlegen

    voc.setNormal ("neu");
    voc.addTranslation ("modernus");
    voc.addTranslation ("novellus");
    voc.addTranslation ("novus");
    voc.addTranslation ("nuperus");
    voc.addTranslation ("nova");
    voc.addTranslation ("novum");
    voc.addTranslation ("recens");
    voc.addTranslation ("recentis");

        // Vokabel reinstopfen

    db.add (voc);

        // Temp-Vokabelobjekt leeren.

    voc.clear ();

        // Vokabel für 'Ich' anlegen

    voc.setNormal ("ich");
    voc.addTranslation ("ego");

        // Vokabel reinstopfen

    db.add (voc);

        // Temp-Vokabelobjekt leeren.

    voc.clear ();

        // Vokabel für 'lachen' anlegen

    voc.setNormal ("lachen");
    voc.addTranslation ("rideo");
    voc.addTranslation ("risio");
    voc.addTranslation ("ridere");
    voc.addTranslation ("risus");

        // Vokabel reinstopfen

    db.add (voc);

        // Benutzer abfragen 10x abfragen

    for (int i=0; i<10; ++i)
        db.test_user ();

        // Gegen das direkte Schließen der Console

    std::cin.get();

    return 0;
}

C-/C++-Quelltext

namespace Namespace1
{
int iZaehler;
}

namespace Namespace2
{
int iZaehler
}

// nun kann man auf die einzelnen mit dem Scope-Operator (::) zugreifen

Namespace1::iZaehler = 2;
Namespace1::iZaehler = 4;
//Außerdem kann man dann auch noch einen globalen Zähler machen, 

//auf den man dann mit 

//::iZaehler

// zugreifen kann

C-/C++-Quelltext

int x = 33;  // Globaler Namespace kann so aufgerufen werden ::x = 22;


namespace Nox // "Nachname" "Nox"

{
   int x = 55; // Variable kann nur so aufgerufen werden Nox::x = 33; oder mit einer using-direktive

}

namespace Patrick // "Nachname" "Patrick"

{
   int x = 77; // Variable kann nur so aufgerufen werden Patrick::x = 33; oder mit einer using-direktive

}

// Benutzung:

::x = 9999; // Globaler Namespace, also Kein Nachname

Nox::x = 333; // Variable aus dem Namespace Nox

usw.