problem mit emiene code -,- Warum kommen da x´s ?

[Syntax_error]

Uihh das ist ja hässlich.
Sieht mir ganz nach Cäsar-Chiffre aus (google mal). Diese if-Kaskaden sind ja gruselig.

gruß
syntax

[triptop]

Syntax_error schrieb:

Uihh das ist ja hässlich. ... Diese if-Kaskaden sind ja gruselig.

Incocnito schrieb:

Ähm. Einfach so quick&dirty ohne Iteratoren:

#include <iostream>

int main()
{
    std::string eingabe;
    std::cout << "Geb' was ein: ";
    std::getline(std::cin, eingabe);
    for(unsigned i = 0; i < eingabe.length(); ++i)
        eingabe[i]++;
    std::cout << eingabe;
}

so ne scheiße ist auch nicht viel besser...

[seldon]

Gruslig ist das allerdings. Inkognito hat die richtige Idee, aber ganz so einfach ist es dann doch nicht -- 'Z' will wieder auf 'A' gemappt werden, und 'z' auf 'a'.

Du kannst davon ausgehen, dass die Zahlenwerte von 'A' bis 'Z' und 'a' bis 'z' aufsteigend direkt hintereinander liegen; alle gängigen Zeichensätze machen das so. Dementsprechend mal ganz einfach gedacht:

#include <algorithm>
#include <iostream>
#include <string>

char shift_letter(char c) {
  if(c >= 'a' && c <= 'z') return 'a' + (c - 'a' + 1) % 26;
  if(c >= 'A' && c <= 'Z') return 'A' + (c - 'A' + 1) % 26;
  return c; // Nichtalphabetische Zeichen werden nicht umgewandelt.
}

int main() {
  std::string line;

  std::getline(std::cin, line);
  std::transform(line.begin(), line.end(), line.begin(), shift_letter);

  // Alternativ:
  //
  // char c;
  // while(std::cin.get(c) && c != '\n') {
  //   line += shift_letter(c);
  // }

  std::cout << line << '\n';
}

[krümelkacker]

seldon schrieb:

Du kannst davon ausgehen, dass die Zahlenwerte von 'A' bis 'Z' und 'a' bis 'z' aufsteigend direkt hintereinander liegen; alle gängigen Zeichensätze machen das so.

Mag sein. Ich weiß nicht, wie verbreitet EBCDIC ist.

[seldon]

Ah, da hatte ich EBCDIC wohl falsch im Kopf - ich dachte, da wäre das auch so. Gut, es ist die Frage, wie schnell dem TE ein IBM-Mainframe unter die Finger kommt, aber der Einwand ist berechtigt.

Dann wird man um die händische Aufstellung einer Tabelle wohl nicht herumkommen. Das ist im Grunde nicht schwierig, obwohl die Casts bei so was immer obszön aussehen:

#include <algorithm>
#include <iostream>
#include <limits>
#include <string>

class shift_table {
public:
  shift_table() {
    for(std::size_t i = 0; i < sizeof(table_); ++i) {
      table_[i] = static_cast<char>(static_cast<unsigned char>(i));
    }

    map_strings("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
                "BCDEFGHIJKLMNOPQRSTUVWXYZAbcdefghijklmnopqrstuvwxyza");
  }

  inline char operator()(char c) const {
    return table_[static_cast<unsigned char>(c)];
  }

private:
  template<std::size_t N>
  void map_strings(char const (&from)[N], char const (&to)[N]) {
    for(std::size_t i = 0; i < N; ++i) {
      table_[static_cast<unsigned char>(from[i])] = to[i];
    }
  }

  char table_[1 << std::numeric_limits<char>::digits];
} const shift_letter;

int main() {
  std::string line;

  std::getline(std::cin, line);
  std::transform(line.begin(), line.end(), line.begin(), shift_letter);

  std::cout << line << std::endl;
}

Stattdessen wäre auch der Einsatz einer std::(tr1::)unordered_map denkbar. Das sieht dann hübscher aus, ist aber etwas weniger performant in der Benutzung:

#include <algorithm>
#include <iostream>
#include <string>
#include <unordered_map>

class shift_table {
public:
  shift_table() : table_(101) {
    map_strings("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
                "BCDEFGHIJKLMNOPQRSTUVWXYZAbcdefghijklmnopqrstuvwxyza");
  }

  inline char operator()(char c) const {
    std::unordered_map<char, char>::const_iterator i = table_.find(c);
    return i == table_.end() ? c : i->second;
  }

private:
  template<std::size_t N>
  void map_strings(char const (&from)[N], char const (&to)[N]) {
    for(std::size_t i = 0; i < N - 1; ++i) {
      table_[from[i]] = to[i];
    }
  }

  std::unordered_map<char, char> table_;
} const shift_letter;

int main() {
  std::string line;

  std::getline(std::cin, line);
  std::transform(line.begin(), line.end(), line.begin(), shift_letter);

  std::cout << line << std::endl;
}

[Schwanzvergleich]

Schaut euch doch bitte mal an, auf welchem Niveau der OP programmiert.

Was sollen diese, für den OP, vollkommen nutzlose und nicht nachvollziehbare "Lösungen" schon wieder?

Ihr schafft es echt nicht situationsangemessen zu antworten. Allein, dass jetzt auch schon exotischer Müll wie EBCDIC berücksichtigt wird ... *facepalm*

[pieselfatzke]

Schwanzvergleich schrieb:

Was sollen diese, für den OP, vollkommen nutzlose und nicht nachvollziehbare "Lösungen" schon wieder?

[...]

Allein, dass jetzt auch schon exotischer Müll wie EBCDIC berücksichtigt wird ... *facepalm*

Das heißt für mich, "nicht nachvollziehbar" bezieht sich NICHT auf den EBCDIC-Code, du hast also Probleme mit diesem hier.
Dann kann man dir leider nicht helfen, denn das ist vollkommen primitiver Code, verständlich und vor allem deutlich robuster als der Ursprungscode mit seinen tausendundx Zeilen...

[seldon]

Ja, man sollte den Leuten erstmal C mit Klassen und eine läuft-bei-mir-wird-schon-richtig-sein-Einstellung zu vermitteln. Vielleicht ein paar gotos einwerfen und Copy&Paste als sinnvolle Technik darstellen?

Es wäre ja auch nicht richtig, wenn man Anfängern keine schlechten Angewohnheiten beibrächte, die sie sich im Laufe der Jahre mühsam wieder abgewöhnen können. Herr Wolf.

[MFK]

mockis schrieb:

ich ahbe einen "übersetzer" gemacht der aus a = b macht aus b = c usw naja wenn ich das ausführe kommt immer ein x vor dem buchstaben aber ich weiß nciht warum das kommt -,- kann mir jmd helfen ?

Das Problem ist, dass du nach jeder Eingabe dein Wort-Array durchsuchst, auch die Positionen, an denen du noch gar nichts gespeichert hast. Da dort alles Mögliche drinstehen kann, können da eben auch Buchstaben stehen, die dann diese Ausgaben erzeugen.

Ganz allgemein brauchst du gar kein Array, weil du sowieso jeden Buchstaben einzeln verarbeitest.

Und du solltest dir schnellstmöglich Schleifen ansehen, die können deinen Code massiv verkleinern.

[SeppJ]

MFK schrieb:

Und du solltest dir schnellstmöglich Schleifen ansehen, die können deinen Code massiv verkleinern.

Er kann Schleifen, da ist ein while drin. Ein Programmierpsychologe kann vielleicht erklären, wieso es trotzdem schief gegangen ist.

[mockis]

ich habe sehr sehr wenig erfahrung! ich kenne die häflter der befehle dir ihr nutzt garnicht ... m´schleiufen kenne ich und behersche ich nur ich war zu doof da iwas draus zu machen

[Dobi]

Schwanzvergleich schrieb:

Schaut euch doch bitte mal an, auf welchem Niveau der OP programmiert.
Was sollen diese, für den OP, vollkommen nutzlose und nicht nachvollziehbare "Lösungen" schon wieder?
Ihr schafft es echt nicht situationsangemessen zu antworten. Allein, dass jetzt auch schon exotischer Müll wie EBCDIC berücksichtigt wird ... *facepalm*

Auch wenns dem OP nicht hift, freue ich mich über sowas immer, weil ich sehr davon profitiere.