Warum funktioniert der C++-Code nicht?
#include <iostream>
#include <Windows.h>
#include <string.h>
#include <conio.h>
#include <fstream>

using namespace std;

string Kontroll(void); // zweite Main-Funktion
char charEingabe(void); // verarbeitet die einzelenen char-Zeichen und schickt sie zur verschlüsslung
char Verschlüsslung(char); // verschlüsselt die Zeichen
char Keyword(int); // bestimmt Keyword und verschlüsselt es

int main()
{
  string opener; // Variable um Kontroll() zu öffnen
  cout << "Bitte geben Sie die zu verschluesselde Nachricht an: \a" << endl; // Aufforderung zur Eingabe des Klartextes

  opener = Kontroll();
  
  return(0); // Ende der Funktion
}

string Kontroll(void)
{
  char Symbol; // Kurzspeichert die einzelnen Symbole
  bool maker = false; // vermittelt für die if und die while Schleife
  string Code; // speichert den Endtext

  while (maker == false) {
    // Schleife, die beendet wird, sobald Symbol = \n ist
    Symbol = charEingabe(); //Definierung von Symbol

    if (Symbol == GetKeyState(VK_RETURN) || Symbol == GetKeyState(0x0D)) {
      // Test ob Symbol = \n
      maker = true;   //beendung der while-Schleife
      cout << "madeit"; // Überprüfung des Ergebnisses
    }
    else {
      Code += Symbol; //fügt die einzelnen Symbole (außer \n) an den String an
    }
  }

  return(Code);
}

char charEingabe(void)
{
  char aSymbol; // Definierung der Eingebungsvariable
  cin >> aSymbol; //eingabe
  char vSymbol = Verschlüsslung(aSymbol);

  return(vSymbol); // verschlüsseltes Symbol wird als Symbol zurückgegeben
}

char Verschlüsslung(char waiter)
{
  int zahl = 1; // Variable um den richtigen char in Keyword() auszuwählen
  int number_waiter = (int)waiter; // Umwandlung von der zu verschlüsselnden Variable zu einer Zahl (ASCII)
  number_waiter = number_waiter + Keyword(zahl); //Verschlüsslung der Variable
  char transfer = (char)number_waiter; //Zurückumwandlung der Variable in char

  return(transfer);
}

char Keyword(int i)
{
  char s_Keyword1 = 'M'; // von hier
  char s_Keyword2 = 'A';
  char s_Keyword3 = 'H';
  char s_Keyword4 = 'A';
  char s_Keyword5 = 'L';
  char s_Keyword6 = 'O';  // bis hier nur das keyword

  int n_Keyword1 = (int)s_Keyword1; // von hier
  int n_Keyword2 = (int)s_Keyword2;
  int n_Keyword3 = (int)s_Keyword3;
  int n_Keyword4 = (int)s_Keyword4;
  int n_Keyword5 = (int)s_Keyword5;
  int n_Keyword6 = (int)s_Keyword6; // bis hier Umwandlung int

  if (i == 1) { // von hier
    return(n_Keyword1);
  }
  else if (i == 2) {
    return(n_Keyword2);
  }
  else if (i == 3) {
    return(n_Keyword3);
  }
  else if (i == 4) {
    return(n_Keyword4);
  }
  else if (i == 5) {
    return(n_Keyword5);
  }
  else if (i == 6) {
    return(n_Keyword6); // bis hier Definierung der Rückgabevariable durch die Variable aus Verschlüsslung(): zahlS
  }
}
Computer, Programmieren, C-plus-plus
Hey, habe ein problem, unzwar soll ich nächste woche in informatik eine Caesar verschlüsselung programmieren, aber es funktioniert aus irgendeinen grund nicht?

import java.util.Scanner;

public class Caesar {

public static void main (String[] args) {

    Scanner scanner = new Scanner (System.in);

    System.out.println("Zu verschlüsselnden Text eingeben:");

    String text = scanner.nextLine(); // Text eingeben

    System.out.println("Um wieviele Stellen soll verschoben werden? (1-26)");

    int offset = scanner.nextInt(); 
    // Offset (Verschiebung) wählen

    if (offset >= 1 && offset <= 25) {

    char [] meinArray = text.toCharArray();
    // den Text in ein Char Array laden

    char [] meinNeuesArray = verschluesseln(offset, meinArray);
    // mit der Methode (siehe unten) "verschluesseln" ein neues 
    // Char Array mit dem verschlüsselten Text erstellen

    // verschlüsselten Text wieder ausgeben:

        System.out.println("\nSo sieht der Text verschlüsselt aus:");

    for (int i = 0; i < meinNeuesArray.length; i++) {

        System.out.print(meinNeuesArray[i]);
    }
        System.out.println("\n");

    scanner.close();
}
    else System.out.println("Die Verschiebung muss zwischen 1 und 127 liegen!");
}

// hier die Methode zum verschlüsseln

public static char[] verschluesseln(int offset, char[] charArray) {

    char[] cryptArray = new char[charArray.length];
    // erstmal ein leeres Char Array erstellen

    for (int i = 0; i < charArray.length; i++) {

                int verschiebung = (charArray[i] + offset)%26;
                // ursprüngliches Zeichen plus Offset modulo 128

                cryptArray[i] = (char) (verschiebung);

    }
    return cryptArray;

}

}

Java, Informatik
C: Wie kann ich ein Pointer-Array anlegen, um die Fundstellen zu speichern?

/* 24_02 dynamische Speicherverwaltung
   demonstriert realloc
   ZUR BEACHTUNG: Dies ist ein reines Demo-Programm!
                  Speicher-Reallokation in 10-Byte-Blöcken ist in der Praxis nicht sinnvoll!
                  Speicherallokation und insbesondere Speicher-Reallokation kosten erhebliche System-Resourcen!
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define STRLEN 10

int Such(char* strPtr, char* Ptr2);

int main()
{
  int n = 1;
  char* strPtr = (char*)malloc(n * STRLEN); // kleinen Speicherblock anfordern
  char* strPtr2 = (char*)malloc(n * STRLEN); // kleinen Speicherblock anfordern
  printf("Bitte Text eingeben: \n");
  fgets(strPtr, STRLEN, stdin); // einlesen
  printf("\n");

  while (strPtr[strlen(strPtr) - 1] != '\n') // Ende erreicht, letztes Zeichen '\n'?
  {
    n++; // Anzahl Blöcke inkrementieren
    strPtr = (char*)realloc(strPtr, n * STRLEN); // größeren Speicher anfordern: n Blöcke
    fgets(strPtr + strlen(strPtr), STRLEN + 1, stdin); // weiter einlesen, terminierende 0 überschreiben, STRLEN + 1 Byte stehen zur Verfügung
  }

  printf("Nach welcher Zeichenfolge soll gesucht werden?\n");
  fgets(strPtr2, STRLEN, stdin); // einlesen
  printf("\n");

  while (strPtr2[strlen(strPtr2) - 1] != '\n') // Ende erreicht, letztes Zeichen '\n'?
  {
    n++; // Anzahl Blöcke inkrementieren
    strPtr2 = (char*)realloc(strPtr2, n * STRLEN); // größeren Speicher anfordern: n Blöcke
    fgets(strPtr2 + strlen(strPtr2), STRLEN + 1, stdin); // weiter einlesen, terminierende 0 überschreiben, STRLEN + 1 Byte stehen zur Verfügung
  }

  printf("Zeichenfolge wurde %i mal gefunden\n", Such(strPtr, strPtr2));
  return 0;
}

int Such(char* strPtr, char* strPtr2)
{
  int n = 0;
  int p = 0;
  int sip = 0;

  int ltext = strlen(strPtr) - 1;
  int lzfolge = strlen(strPtr2) - 1;
  int lgteilt = ltext / lzfolge;
  char* ptrarr[] = { NULL };

  while ((lgteilt) > 0)
  {
    for (int i = 0; i < lzfolge; i++)
    {
      if (strPtr[p] == strPtr2[i])
      {
        sip++;
      }

      p++;
    }

    lgteilt--;
  }

  return (sip / lzfolge);
}

Ich verstehe leider nicht ganz, wie man ein Pointer-Array anlegen soll, um die Fundstellen zu speichern.

Ich habe zwar eine Schleife, aber diese kann z. B. "yay" nicht mit "ay" vergleichen.

Danke für die Hilfe.

C: Wie kann ich ein Pointer-Array anlegen, um die Fundstellen zu speichern?
Computer, Technik, Programmieren, C Programmierung, Technologie
Ich kann der Syntax dieser Rekursion nicht folgen?

Ich will wissen, was hier exakt passiert:

public String d(int x)
{
    if (x < 10)
    {
        return "" + zifferAlsZeichen(x);
    }
    else
    {
        return d(x / 10) + zifferAlsZeichen(x % 10);
    }
}

/**
 * Wandelt eine Ziffer (0 bis 9) in ein Zeichen ('0' bis '9') um.
 * Wie das genau funktioniert, muesst ihr nicht unbedingt verstehen.
 */
private char zifferAlsZeichen(int x)
{
    return (char)('0' + x);
}

Frage 1: Verstehen des Ablaufs

Wird der Methode d sagen wir 1234 übergeben, dann

  1. springt die Methode in den Else-Zweig.
  2. Hier wird Methode d mit (1234 / 10) = int 123 nochmal aufgerufen.
  3. Methode d wird solange rekursiv aufgerufen, bis x auf 1 geschrumpft ist.
  4. Abbruch-Bedingung greift nun und gibt einen leeren String zurück, in den Ziffern in Form von Zeichen eingespeichert werden?
  5. Im letzten Stack-Layer wurde mit der 1 die Abbruch-Bedingung bestätigt, weshalb als nächster Schritt nun alle "abgeschnittenen" Zahlen wieder "eingesammelt" werden.
  6. Der Stack wird ab jetzt also wieder abgebaut und verbleibende Anweisung 'ziffernAlsZeichen(x%10)' im else-Zweig wird abgearbeitet.
  7. Die erste Zahl auf dem Rückweg ist also die 12, die per Modulo zu 2 reduziert und dann als '2'-Zeichen gecastet wird (wie auch schon die '1' zuvor), um dann an den Rückgabe-String "angeheftet" zu werden.
  8. Das gleiche passiert mit allen weiteren Zahlen, bis der Stack wieder abgebaut ist.

Frage 2: Verstehen von 'zifferAlsZeichen'

private char zifferAlsZeichen(int x)
    {
           return (char)('0' + x);
    } 

Um eine Zahl in einen char zu casten würde es doch reichen z.B. (char) 2 zu schreiben? Wieso '0' + x ? Oder wird damit die große der zu castenden auf eine Stelle beschränkt? Weil alles ab 2 Stellen wäre ja auch kein char mehr.

Danke für Deine Hilfe!

Vielleicht kannst Du auch noch kurz kommentieren, ob ich mir unnötige Arbeit mache, wenn ich den Ablauf dieser Zeilen so bis ins Detail verstehen will?

Gruß Josh

Java, Rekursion

Was möchtest Du wissen?