Char verwandeln

GPC

char array[10];
for (int i=0; i<10; i++)
cin >> array[i];

for (int i=0;i<10;++i) {
  switch (array[i]) {
    case 'a': array[i] = 'x'; break;
    //usw.
  };
};

Das unten wird nicht klappen, da du versuchst, einem einzelnen char einen string zuzweisen. Wenn du das machen willst, brauchst du ein string arr[i] oder ein char **;

array[a]= "\x1#"

bleib nur noch

switch quantity not an integer

sarah1986

ich habe bei mir den code mal ausprobiert. ein paar änderungen mussten gemacht werden, aber so wie folgt, funzt er.
wie schon gesagt wurde, kannst du so das a nur in ein zeichen umwandeln, aber die lösung wurde ja genannt (ist bei mir noch nicht berücksichtigt).
wenn der code nicht gehen sollte, schau mal in den einstellungen des compilers nach, ob alles passt, sonst weiß ichs auch net.
das mit dem integer-fehler liegt vermutlich daran, dass bei case das a nicht in '' gefasst war, so muss es aber, wenn es ein zeichen ist.

funktionierender code:

#include <iostream>
#include <conio.h>
using namespace std;

int main()
{
	char array[10]; 
	for (int i=0; i<10; i++)
		array[i]=' ';
	for (int i=0; i<10; i++) 
	{	cin >> array[i]; 

		switch (array[i]) 
		{	case 'a': 
			array[i]='x'; 
			break; 
		}

		cout << array [i];
	} 
}

LordJaxom

@imo2:

Wenn Du immernoch entgegen aller Beispiele nach dem "switch" keine Klammern hast wird der Fehler auch noch was bleiben :p ^^

GPC

@sarah1986
Vermeide conio.h, da dies compilerabhängig ist. Nimm lieber cstdlib und getchar() als Ersatz für getch()

sarah1986

beim borland und visual c++ funzt es. aber hast schon recht

und wenn ich jetzt dem char a den string \x1# zuweißen will wie kann ich das dann umsetzen?

Caipi

imo2 schrieb:

und wenn ich jetzt dem char a den string \x1# zuweißen will wie kann ich das dann umsetzen?

Erstmal vorweg: Einem char (Ein Zeichen) kannst du keinen String (mehrere Zeichen) zuweisen.
Du willst wahrscheinlich ein bestimmtes Zeichen durch einen string ersetzen, oder?
Wenn ja: Am besten verwendest du direkt std::string. Ansonsten musst du dir eine Funktion schreiben, die nach einem Zeichen sucht, und dieses durch den entsprechenden string ersetzt. (AFAIK gibt es keine derartige str...() Funktion in der Standardbibliothek...)

imo2 schrieb:

hmhm so könnte es funzen nur er beschwert sich über switch:
switch quantity not an integer

Die Beschwerde resultiert daraus, dass du dem Switch-Konstrukt einen int (oder etwas, dass implizit in einen int konvertierbar ist) übergeben musst...

sarah1986 schrieb:

beim borland und visual c++ funzt es. aber hast schon recht

Es gibt aber noch viel mehr Compiler

Gruß Caipi

CStoll

[quote="Caipi"]

imo2 schrieb:

(AFAIK gibt es keine derartige str...() Funktion in der Standardbibliothek...)

Ja, allerdings - deswegen hatte ich ja schon weiter oben string::replace vorgeschlagen, der kann einzelne Zeichen durch Zeichenketten ersetzen.

Werner Salomon

imo2 schrieb:

hm das ist auch nicht gerade das was ich suche gibt es nicht irgend einen befehl wie ich einen char als einen anderen ausgebe`?

Einen einzelnen (C++-)Befehl gibt es nicht. Aber man kann sich einen Konverter 'Converter' bauen, demselben mitteilen welche Zeichen in was umgewandelt werden sollen und einen Umschalter (IoSwitch), um den Konverter in die Ausgabe eines ostream's hineinzuhängen .. etwa so:

int main()
{
    using namespace std;
    Converter cv;
    cv.change( 'a', "\\x1#" ); // statt 'a' '\x1#' ausgeben
    cv.change( '0', "<->" ); // statt '0' '<->' ausgeben
    {
        IoSwitch iosw( cout, cv.rdbuf( cout.rdbuf() ) ); // Converter in cout einhängen
        cout << "Hallo " << 3 * 34 << endl;
        cout << "4 kleine A: aaaa" << endl;
    }   // <-- im Destruktor von IoSwitch wird hier cout wieder restauriert
    cout << "ab hier ist wieder alles normal" << endl;

    return 0;
}

Der Converter ist ein std::streambuf. Die Umwandlung passiert in der Methode 'overflow' s.u.

#include <streambuf>
#include <map>
#include <string>

class Converter : public std::streambuf
{
public:
    typedef std::streambuf base_type;
    typedef base_type::traits_type traits_type;

    Converter() : base_type(), m_target( 0 ), m_z() {}

    Converter* rdbuf( std::streambuf* target )
    {
        m_target = target;
        return this;
    }

    void change( char z, const std::string& txt ) { m_z[ z ] = txt; }

protected:
    virtual int overflow( int_type x = traits_type::eof() )
    {
        if( traits_type::eq_int_type( x, traits_type::eof() ) )
            return traits_type::not_eof( x );

        z_type::iterator i = m_z.find( traits_type::to_char_type( x ) );
        if( i != m_z.end() )
        {   // Zeichen durch gespeicherten String ersetzen
            if( m_target->sputn( i->second.c_str(), std::streamsize( i->second.size() ) )
                        == i->second.size() )
                return traits_type::not_eof( x ); // ok
            return traits_type::eof(); // Fehler bei Ausgabe weitergeben
        }
        return m_target->sputc( x ); // Zeichen einfach weitergeben
    }

private:
    std::streambuf* m_target;
    typedef std::map< char, std::string > z_type;
    z_type m_z;
};

und der Umschalter sorgt nach RAII dafür, dass am Ende wieder alles so ist wie vorher

#include <streambuf>
#include <ios>

struct IoSwitch
{
    IoSwitch( std::basic_ios< char >& ios_, std::streambuf* sb )
        : m_ios( ios_ )
        , m_sb( m_ios.rdbuf( sb ) )
    {}
    ~IoSwitch()
    {
        m_ios.rdbuf( m_sb );
    }
private:
    std::basic_ios< char >& m_ios;
    std::streambuf* m_sb;

    // -- Kopieren verhindern
    IoSwitch( const IoSwitch& );
    IoSwitch& operator=( const IoSwitch& );
};

Falls eine Datei 'a.txt' mit dem gleichen Konverter in eine neue Datei 'b.txt' umgewandelt werden soll, so geht das z.B. so:

Converter cv;
    // .. Umwandlungen festlegen (s.o.)
    ostream( cv.rdbuf( ofstream( "b.txt" ).rdbuf() ) ) << ifstream( "a.txt" ).rdbuf();

.. noch 10 Tage bis Weihnachten
:xmas2: Werner