4. Umlaute in C++ auf Dos Konsulen anwendung

Umlaute in C++ auf Dos Konsulen anwendung

  • ?

    ich hab das mal so gelöst.

    #include <iostream>
#include <string>

#define GER_CHAR_ONE    'Ä'
#define GER_CHAR_TWO    'ä'
#define GER_CHAR_THREE  'Ö'
#define GER_CHAR_FOUR   'ö'
#define GER_CHAR_FIVE   'Ü'
#define GER_CHAR_SIX    'ü'
#define GER_CHAR_SEVEN  'ß'

using namespace std;

char* GermanCodes ( char* String ) {
    char AsciiCodes[7] = { 'Ž','„','™','”','š','','á' };
    for ( unsigned int Counter = 0; Counter <= strlen(String); Counter++ ) {
        if ( String[Counter] == GER_CHAR_ONE )
            String[Counter] = AsciiCodes[0];
        if ( String[Counter] == GER_CHAR_TWO )
            String[Counter] = AsciiCodes[1];
        if ( String[Counter] == GER_CHAR_THREE )
            String[Counter] = AsciiCodes[2];
        if ( String[Counter] == GER_CHAR_FOUR )
            String[Counter] = AsciiCodes[3];
        if ( String[Counter] == GER_CHAR_FIVE )
            String[Counter] = AsciiCodes[4];
        if ( String[Counter] == GER_CHAR_SIX )
            String[Counter] = AsciiCodes[5];
        if ( String[Counter] == GER_CHAR_SEVEN )
            String[Counter] = AsciiCodes[6];
    }
    return String;
}

int main ( void ) {
    cout << GermanCodes("Ägäin");
    return 0;
}

    verbesserungsvorschläge gerne erwünscht. auch kritische kritiken 🙂

    0
  • S

    Kritik ist meistens kritisch ;).

    Defines und C++ - nicht so gut.
    Dann würde ich ihnen lieber explizit die Zahlen zuweisen die für den Code stehen, als diese Kürzel wie TM oder so.

    Ist eine solche Kritik kritisch oder nicht? *g*

    MfG SideWinder

    0
  • ?

    kritik ist immer kritisch? jo das stimmt 😉 😉
    kritisch genug ist ja die kritik 😃

    thx. bin halt kein c++ programmierer. ich hab c so gerne. ursprünglich war der code ja c und hab ich nur mal schnell überflogen um das cout reinzubringen.

    0
  • D

    kannst natürlich auch mit printf arbeiten 😉

    printf("%cbung",220);

    0
  • L

    HI Leute,
    danke für die ganzen Tipps.
    Ich glaube ich hab mein Problem aber nicht richtig beschrieben,
    das Printf oder auch cout mit ascii werten arbeiten kann ist mir bekannt gewesen, mein problem ist eher das ich etwas suche was mehr dem motto what you see is what you get das soll heisen ich möchte in printf wirklich Umlaute eintragen können und die im Compiler auch sehen um später wenn das Programm läuft auch diese dann aus gegeben zu bekommen.
    als bsp:

    int main ()
    {
    printf(" Schöner Tag noch und viel Spaß\n");
    return 0;
    }
    um dann auf den Bildschirm zu sehen

    Schöner Tag und noch viel Spaß

    Irgend einer eine Idee ?

    😕
    mfg Alex

    0
  • ?

    hmm...

    du schreibst ne funktion namens gprintf();
    gprintf konvertiert die umlaute, und übergibt dann den konvertierten text an die funktion printf(); weiter.

    der kannst du deinen text übergeben gprintf("Schönen Tag noch und viel Spaß\n");

    wüsste jetzt sonst nicht, wie du printf(); begreiflich machen könntest das es dt. umlaute gibt. dann müsste printf(); ja auch alle anderen sprachzeichen verstehen. wie zb. die chinesischen schriftzeichen. um das problem zu lösen erfand man ja auch Unicode. nur ist das nicht auf allen windowssystemen so implementiert wie in der nt-linie.

    und das g in gprintf stört ja nicht wirklich oder?

    0
  • F

    Hi,
    versuch mal, in deinem Editor den Umlaut so einzugeben:

    Alt + Auf dem Zahlenpad deiner Tastatur: 0148

    0148 ist der ASCII-Code für "ö"
    Bei mir klappt es so.

    0
  • ?

    dann steht bei dir wirklich das ö?
    bei mir steht dann ”.
    und das verwendet die funktion GermanCodes. du musst also diese kombination nicht auswendig können.

    0
  • F

    In meinem Quellcode steht freilich auch ´´
    aber in dem kompilierten Programm steht dann schon "ö"
    klappt es bei dir nicht?

    0
  • S

    Jo, sollte im compilierten Code schon stehen :).

    Seht euch mal folgendes an:

    // umlautbuf.h
#ifndef UMLAUTBUF_H__INCLUDED
#define UMLAUTBUF_H__INCLUDED

#include <iostream>

#ifdef _MSC_VER
#define HAS_CHAR_TRAITS
#endif

#ifndef HAS_CHAR_TRAITS
#define int_type int
const int_type GEN_EOF = EOF;
#endif

class umlautbuf : public std::streambuf
{
    public:    
        umlautbuf ( std::streambuf* sb );
        int_type overflow(int_type c);
        #ifdef HAS_CHAR_TRAITS
        typedef std::streambuf::traits_type traits_type;
        #endif

    private:
        std::streambuf* m_Buffer;
        umlautbuf( const umlautbuf& );
        umlautbuf& operator= (const umlautbuf& );
};

// Kleine Resource-Aquisition-is-initialization-Klasse
// die dafür sorgt, dass auch im Falle von Exceptions alles
// schön wiederhergestellt und gelöscht wird
class AutoUmlautBuffer
{
    public:
        AutoUmlautBuffer(std::ostream& os) :
            m_Os(os),
            m_OldBuf(os.rdbuf()),
            m_NewBuf(new umlautbuf(m_OldBuf))
        {  
            os.rdbuf(m_NewBuf);
        }
        ~AutoUmlautBuffer()
        {
            m_Os.rdbuf(m_OldBuf);
            delete m_NewBuf;
        }
    private:
        std::ostream& m_Os;
        std::streambuf* m_OldBuf;
        std::streambuf* m_NewBuf;
};

#endif

// umlautbuf.cpp

#include "umlautbuf.h"
#ifdef HAS_CHAR_TRAITS
typedef umlautbuf::traits_type::int_type int_type;
#endif
using namespace std;

umlautbuf::umlautbuf ( streambuf* sb ) : m_Buffer(sb) {}

int_type umlautbuf::overflow(int_type c)
{
    #ifdef HAS_CHAR_TRAITS
    if (!traits_type::eq_int_type(c, traits_type::eof()))
    #else
    if (c != GEN_EOF)
    #endif
    {
        #ifdef HAS_CHAR_TRAITS
        traits_type::char_type Temp = c;
        #else
        char Temp = c;  // oder unsigned char?
        #endif
        switch(Temp)
        {
            case 'Ä' : c = 142; break;
            case 'ä' : c = 132; break;
            case 'Ö' : c = 153; break;
            case 'ö' : c = 148; break;
            case 'Ü' : c = 154; break;
            case 'ü' : c = 129; break;
            case 'ß' : c = 225; break;
            default: break;

        }
        #ifdef HAS_CHAR_TRAITS
        if ( traits_type::eq_int_type(m_Buffer->sputc(c), traits_type::eof()))
            return traits_type::eof();
        #else
        if (m_Buffer->sputc(c) == GEN_EOF)
            return GEN_EOF;
        #endif
    }
    #ifdef HAS_CHAR_TRAITS
    return traits_type::not_eof(c);
    #else
    return int_type(c);
    #endif
}

// main.cpp
#include "umlautbuf.h"
using namespace std;
int main()
{
    AutoUmlautBuffer p(cout);
    cout << "Äh Hallo" << endl;
}

    Schöne Grüße von Hume :).

    MfG SideWinder

    0
  • ?

    sorry hab gedacht durch diese tastenkombination würde dann ö im editor stehen. das es im kompilierten programm dann ist, ist mir schon klar (sonst würde GermanCodes() net funktionieren :D)

    jepp der code von hume ist net schlecht. jetzt muss ich nichtmal mehr die funktion GermanCodes() aufrufen um dt. Umlaute auszugeben.

    falls ich mal irgendwann anfange c++ zu verwenden ist es bestimmt interessant :D:D:D

    0
Anmelden zum Antworten