» Verschlüsselung von Text-Dateien mit vigenere-Tafel

// header vigenere.h von vigenere1f
#ifndef VIGENERE_INC_
#define VIGENERE_INC_ 1

#include <stdio.h>
#include <iostream>
#include <string>
#include <iomanip>  // wegen setw
#include <unistd.h> // wegen getcwd()
#include <fcntl.h>  /// Symbolische Konstanten fuer open
#include <fstream>
#include <sys/stat.h> // getFilesize, stat
#include <stdlib.h> // malloc

//int shift(char c);

void clpuf(void);               // Tastaturpuffer loeschen
short getcharart(char letter);  // stellt Laenge des Zeichens in Byte fest
int atoint(char letter);        // signed char in int 
std::string getstrchar(std::string mot, int pos);
int getletterpos(std::string mot, std::string letter);
int letterlaenge(std::string str); // Stellt die Laenge eines cpp-Strings in Buchstaben fest. string.lengtch() stellt die Laenge in Byte fest
int getfistcharpos(std::string alf, int pos);
unsigned int chartoint(unsigned char intteile[4]);  // 4Byte-unsigned char array zu 4Byte int
void clearchararray(char array[], int lge);         // eindimensionales Array loeschen
std::string getfilestring(std::fstream *datei, int *zeize);
void ZeigeZeichen(int i, std::string char_letter, std::string letter_chiffriert, std::string letter_dechiffriert);

class vigenere
{
 public:
   vigenere();
   ~vigenere();	
   //Menues
   void HAUPTMENUE(void);
   int MenueFrage(void);
   void GetKeyword(void);	
   void GetPlaintext(void);
   
   void ShowVigenereTable(void);
   void SetzeTestVorgaben(void);
   void Buchstabenplatzliste(void);
   void BuchstabenplatzTest(void);
   void Rotiere_plaintext(void);
   void rotiere_Ur_abc(void);
      
   std::string vigens(std::string alf, int pos);
   std::string mkvigboard(std::string zeichen, int xpos);
   std::string get_xpos_Letter(std::string Ur_abc, int pos);
   int get_xLetter_pos(std::string Ur_abc, std::string gesucht);
   std::string RotiereUr_abc(std::string Ur_abc, int i, std::string *keychar);
   std::string chiffrieren(int i,  std::string char_txt, int chiffreart);
   void ShowLaengentafel(void);
   void ShowKey(void);
   void ShowVarib(int i, int j, std::string teile);
   void ShowVari(int i, int j, std::string teile, std::string char_chiffriert);  
   void getcurdir(void);
   void StringToChar(std::string wort, char satz[]);
   long getFilesize(const std::string& filename);
   int ReadValIn(std::string in_File_Name, int modus);
   void putfilestring(std::ofstream *datei, std::string tosend);
   
   //String-Variable
   std::string Ur_abc;
   std::string abc_rotiert = ""; 
   std::string key = "";        // Schluesselwort
   std::string plaintext = "";  // zu schiffrierender Text
   std::string teilb = "";
   std::string keychar = "";    // Buchstabe von  Schluesselwort
   std::string srcfilename = "";
   std::string tarfilename = "";
   char dummy[400];
   int klen;
   int kbulen;
   int txtlen;
   int txtbulen;
   int abclen;
   int Ur_abc_buchslen;
   int ypos;
   long srcdatlen;
   
};

#endif

// header vigenere.cpp of vigenere1f
//vigenere::vigenere()
//vigenere::~vigenere(){};	 
//std::string vigenere::vigens(std::string Ur_abc, int pos)
//std::string getstrchar(std::string mot, int pos)
//std::string vigenere::mkvigboard(std::string zeichen, int xpos)	
//int getfistcharpos(std::string alf, int pos)
//void vigenere::getcurdir(void)
//void vigenere::StringToChar(std::string wort, char satz[])
//long vigenere::getFilesize(const std::string& filename)
//int vigenere::ReadValIn(std::string in_File_Name)

#include "vigenere.h"
 
vigenere::vigenere()
{
 std::string Ur_abc_init = "abcdefghijklmnopqrstuvwxyzöäüß ABCDEFGHIJKLMNOPQRSTUVWXYZÖÄÜ0123456789.,!?;:-+*~#'<>|²³€@/^°µ_§${}[]()´`\n"; // mit Newline-sign
 Ur_abc = Ur_abc_init;	
 abclen = Ur_abc.length();
 Ur_abc_buchslen = letterlaenge(Ur_abc); // Laenge Ur_abc in Buchstaben
};
vigenere::~vigenere(){};	 


// schneidet aus cpp-string ab Position 0 bis einschliesslich pos
// den Teilstring aus und stellt ihn ans Ende des cpp-Strings
std::string vigenere::vigens(std::string Ur_abc, int pos)
{
 int Ur_abc_bulen = 0, charpos = 0; 
 std::string Buchstabe = "";
 std::string teila = Ur_abc;
 std::string teilb = Ur_abc;
 
 Ur_abc_bulen = letterlaenge(Ur_abc);
 
 if ((pos > 0) && (pos < (Ur_abc_bulen - 1))) 
  {
   Buchstabe = get_xpos_Letter(Ur_abc, pos);
   charpos = getletterpos(Ur_abc, Buchstabe);	 
   
   teila = Ur_abc.substr(0,  charpos);  // erster Teil von Zeichen 0 an bis einschliesslich pos zu teila kopieren
   teilb.erase (0, charpos);            // Loesche von teilb der ersten Teil
   teilb += teila;                      // geloeschten ersten Teil an teilb anhaengen
   //std::cout << "pos=" << pos << "  charpos = " << charpos << "  Buchstabe=" << Buchstabe <<    "  teila= " << teila << "  teilb=" << teilb << std::endl;
  }	 
   else teilb = Ur_abc;
    
 return teilb;
}

 
// Gibt den Buchstaben an Position pos im String mot zurueck
std::string getstrchar(std::string mot, int pos)
{
 std::string rewer = "";
 int lge, chlen = 0, firstcharpos = 0;
 
 lge = mot.length();            // Laenge von mot in Byte

 firstcharpos = getfistcharpos(mot, pos);  // Position des ersten Bytes bei laengeren Zeichen
 chlen = getcharart(mot[firstcharpos]);	 // Laenge des Zeichens feststellen 

 if(pos < lge)
  rewer = mot.substr(pos,  chlen);  
 	
 return rewer;	
} 


// Dient zur Herstellung des rotierten Alphabets
// vigens schneidet aus cpp-string(arg1) ab Position 0 bis pos
// den Teilstring aus und stellt ihn ans Ende des cpp-Strings
std::string vigenere::mkvigboard(std::string zeichen, int xpos)		 
{
 int txtlen = 0;
 std::string teilc = "";
 
  txtlen = zeichen.length();  // Laenge von zeichen in Byte feststellen
 
  // wenn xpos >= 1 dann xpos -1 bei vigens
  if ((xpos > 0) && (xpos < txtlen)) 
   teilc = vigens(zeichen, xpos); // Nach xpos des Schluesselbuchstabens Originalalphabet rotieren
	 else
      teilc = zeichen;   

 return teilc;	  	  
}

int getfistcharpos(std::string alf, int pos)	 
{
 int i, chlen = 0; 
 chlen = getcharart(alf[pos]); 
 
 if (chlen == 5)//(chlen > 1)
 for (i = pos; i >= 0; i--)
  {
   chlen = getcharart(alf[i]); 
   if (chlen <= 4)
    { 
	 pos = i; 
	 break;
	}
	
  }
  
//std::cout << std::endl; 
 return pos;
} 

void vigenere::getcurdir(void)
{
  char curverz[400] = {0};
  
  if (getcwd(curverz, sizeof(curverz)) == NULL)
    perror("getcwd() error");	
   else std::cout << "current DIR: " << curverz << std::endl;
} 

// converts a cpp string to char
void vigenere::StringToChar(std::string wort, char satz[])
{
int slei, wolen;
wolen = wort.length();

for (slei = 0; slei < wolen; slei++)
 {
 satz[slei] = wort[slei];
 satz[slei +1] = '\0';
 }
}

long vigenere::getFilesize(const std::string& filename)
{
 struct stat st;

  if(stat(filename.c_str(), &st) != 0)
   {
    return 0;
   }

    return st.st_size;   
}

int vigenere::ReadValIn(std::string in_File_Name, int modus)
{
 int rewer = -1, i;
 long bulen = srcdatlen;
 std::fstream dat_ein;
 std::ofstream dat_aus;
 std::string char_letter = "";
 std::string letter_chiffriert = "";
 std::string letter_dechiffriert = "";
 char chararray[8];
 

 if((modus < 0) || (modus > 1)) modus = 0; 
 
 std::cout << "Modus = " << modus << std::endl;
 
 dat_ein.open(in_File_Name, std::fstream::in | std::fstream::binary);

 if (!dat_ein)
  {
   std::cout << "Datei konnte nicht geoeffnet werden!" << std::endl;
   return rewer;
  }
 
 dat_aus.open(tarfilename.c_str(), std::ofstream::out | std::ofstream::binary);
  if (!dat_aus)
   {
    std::cout << "Ziel-Datei kann nicht erstellt werden!" << std::endl;
    return(rewer);
   }
    else 
    std::cout << "Ziel- und Quelldatei wurden geoeffnet, lese Zeichen ein." << std::endl;

 
 
 bulen = 0;
 for (i = 0; i < srcdatlen; i++)
  {
   char_letter = getfilestring(&dat_ein, &i);   // Zuerst UTF8-Zeichen von Quelldatei holen
	
   //In c-String-array konvertieren
   clearchararray(chararray, 8);           
   StringToChar(letter_chiffriert, chararray);	
	
   bulen++; // Zeichenzaehler
     
   letter_chiffriert = chiffrieren(i, char_letter, modus);
     
   //letter_dechiffriert = chiffrieren(i, letter_chiffriert, 1);
   //ZeigeZeichen(i, char_letter, letter_chiffriert, letter_dechiffriert); 
   
   putfilestring(&dat_aus, letter_chiffriert);
   
  }


 dat_ein.close();
 std::cout << std::endl << "Quelldatei wurde geschlossen." << std::endl;
 dat_aus.close();
 std::cout << "Ziel-Datei wurde erstellt und gechlossen." << std::endl;
 rewer = 0;

 return rewer;
}

//int atoint(char letter)
//unsigned int chartoint(unsigned char intteile[4])
//short getcharart(char letter)
//int letterlaenge(std::string str)
//std::string vigenere::get_xpos_Letter(std::string Ur_abc, int pos)
//int getletterpos(std::string mot, std::string letter)
//int vigenere::get_xLetter_pos(std::string Ur_abc, std::string gesucht)
//void vigenere::ShowVari(int i, int j, std::string teile, std::string char_chiffriert) 
//void vigenere::ShowVarib(int i, int j, std::string teile)
//void vigenere::ShowKey(void)
//std::string vigenere::RotiereUr_abc(std::string Ur_abc, int i, std::string *keychar)
//std::string vigenere::chiffrieren(int i, std::string char_txt, int chiffreart)
//void clearchararray(char array[], int lge)
//std::string getfilestring(std::fstream *datei, int *zeize)
//void vigenere::putfilestring(std::ofstream *datei, std::string tosend)
//void ZeigeZeichen(int i, std::string char_letter, std::string letter_chiffriert, std::string letter_dechiffriert) 



#include "vigenere.h"

// loescht Tastaturpuffer
void clpuf(void)
{
 while (getc(stdin) != '\n')
    ;
}
 
//Umwandlung von signed char zu int
int atoint(char letter)
{
 int rewer;
 if ( letter < 0)
  rewer = letter + 256;
   else rewer = (int)letter;
 return rewer;
}  


// Konvertiert ein 4Byte-langes unsigned_char_array in einen unsigned_int-Wert
unsigned int chartoint(unsigned char intteile[4])
{
 union intpart{
 unsigned int erge;
 unsigned char ipart[4];	
} ipt;

 ipt.ipart[0] = intteile[0];
 ipt.ipart[1] = intteile[1];
 ipt.ipart[2] = intteile[2];
 ipt.ipart[3] = intteile[3];
 
return ipt.erge;
}

 
// erkennt bei UTF 8 die Zeichenlaenge in Byte
short getcharart(char letter)
{
 short rewer = -1;
 int bu = atoint(letter);
	if (bu < 192) rewer = 1; // Dann liegt ein einzelnes Zeichen fuer einen Buchstaben vor
	if ((bu >= 192) && (bu < 224)) rewer = 2;  // Erstes Markierunszeichen fuer 2 Byte pro Buchstaben
	if ((bu >= 224) && (bu < 240)) rewer = 3;  // Erstes Markierunszeichen fuer 3 Byte pro Buchstaben
	if (bu >= 240)rewer = 4;                   // Erstes Markierunszeichen fuer 4 Byte pro Buchstaben
	if ((bu >=128) && (bu <= 191)) rewer = 5; // ist Folge-Byte von 2 bis 4 Byte pro Zeichen
 return rewer;
} 

// Stellt die Laenge eines cpp-Strings in Buchstaben fest. string.length() stellt die Laenge in Byte fest
int letterlaenge(std::string str)
{ 
  std::string dummy = "";
  int i, bu = 0, sl = 1, lge = -1, bulen = 0;
  lge = str.length();

  bulen = lge;

 for (i = 0; i < lge; i++)
  {
   bu = str[i];               // Hole einzelnes Char aus str
   sl = getcharart(bu);       // Bestimme Zeichenlaenge
   dummy = str.substr(i,sl);  // Kopiere Zeichen in dummy
   if(sl > 1 ) i += (sl - 1); // Wenn Zeichen laenger als 1 char i += (Zeichenlaenge -1)
   bulen -= (sl - 1);         // Von strlaenge (Zeichenlaenge -1) abziehen
   //std::cout << str.at(i) << " =  " << int atoint(str.at(i)) << std::endl;
   //std::cout << "i: " << i  << " bulen="<< bulen  << "  " << dummy << " = " << std::setw(3) << bu << "   laenge: " << sl << "  =  " << atoint(bu) << std::endl;
  }
 //std::cout << "-----------\n";
 return bulen;
}  




// Holt aus einen cpp-String das Zeichen nach Buchstabennummer, nicht nach Byte-Nummer
std::string vigenere::get_xpos_Letter(std::string Ur_abc, int pos)	
{
 int j, bulen = 0, chlen = 0, abclen = 0; 
 std::string teilb = "";      
 abclen = Ur_abc.length();	

   for (j = 0; j < abclen; j++)
	     { 
		  chlen = getcharart(Ur_abc[j]);    // Bestimme Laenge des Zeichens von Ur_abc
		  if(chlen <= 4) teilb = Ur_abc.substr(j, chlen);  // Kopiere Ur_abc in teilb
		   else teilb = "";
		 
		   if((chlen < 5) && (bulen == pos)) break;
		   	  
           if (chlen <= 4) bulen++;
		 } 

 return teilb;
}	  

//Sucht im String mot nach der Zeichenfolge letter und gibt bei Erfolg dessen Position zurück
int getletterpos(std::string mot, std::string letter)
{
 std::size_t found;
 int pos = -1;
 
 found = mot.find(letter);
 
 if (found!=std::string::npos)
    pos = found;
  
 return pos; 
}

int vigenere::get_xLetter_pos(std::string Ur_abc, std::string gesucht)	
{
 int j, bulen = 0, chlen = 0, abclen = 0; 
 std::string teilb = "";      
 
 abclen = Ur_abc.length();	// Byte-Laenge von Ur_abc

   for (j = 0; j < abclen; j++)
	     { 
		  chlen = getcharart(Ur_abc[j]);    // Bestimme Laenge des Zeichens von Ur_abc
		  if(chlen <= 4) teilb = Ur_abc.substr(j, chlen);  // Kopiere Ur_abc in teilb
		   else teilb = "";
		 
           if (teilb.compare(gesucht) == 0) break;
		   			  
           if (chlen <= 4) bulen++;
		 } 
  
 return bulen; 
}	  



void vigenere::ShowVari(int i, int j, std::string teile, std::string char_chiffriert)  
{ 
 int keycharlen = 0, teilelen = 0;
 
 keycharlen = keychar.length();
 teilelen = teile.length();
 
 std::cout << "  i=" << std::setw(2) << i << " j=" << std::setw(2) << j;
 std::cout << "  keychar= "<< std::setw(keycharlen) << keychar << "  chiffiert-teile: " << std::setw(teilelen) << teile;
 std::cout << "  unchiffriert[i]="<< char_chiffriert << " text-ypos= "  << std::setw(2)<< ypos;
 std::cout << "  abc rotiert: " << abc_rotiert << std::endl;
}
 
void vigenere::ShowVarib(int i, int j, std::string teile)  
{ 
 int keycharlen = 0, teilelen = 0;
 
 keycharlen = keychar.length();
 teilelen = teile.length();        
 std::cout << "  i=" << std::setw(2) << i << " j=" << std::setw(2) << j;
 std::cout << "  keychar= " << std::setw(keycharlen) << keychar << "  chiffriert-teile: " << std::setw(teilelen) << teile;
 std::cout << "  unchiffriert[i]="<< plaintext[j] << " text-ypos= " << std::setw(2)<< ypos;
 std::cout << "  abc rotiert: " << abc_rotiert << std::endl;
}

void vigenere::ShowKey(void)
{       
 std::cout << "Schluessel......: " << key << std::endl;
 std::cout << "Schluessel-Laenge in Byte......: " << klen << std::endl;
 std::cout << "Schluessel-Laenge in Buchstaben: " << kbulen << std::endl<< std::endl;
}

std::string vigenere::RotiereUr_abc(std::string Ur_abc, int i, std::string *keychar)
{
  int kchpos;
  std::string abc_rotiert;
   
  *keychar = get_xpos_Letter(key, i);        // einzelnes Ur_abc aus Schluesselstring nach teilb holen
  kchpos= get_xLetter_pos(Ur_abc, *keychar); // Originalposition des SchluesselUr_abcs im Originalalphpabet feststellen
  abc_rotiert = mkvigboard(Ur_abc, kchpos);  // Nach Schluesselbuchstabe Originalalphabet rotieren 
   
  //std::cout << "kchpos: " << kchpos << std::endl; 
  return abc_rotiert; 
}

std::string vigenere::chiffrieren(int i, std::string char_txt, int chiffreart)
{
 std::string letter_chiffriert = "";
 
 if (chiffreart == 0)
  {
   abc_rotiert = RotiereUr_abc(Ur_abc, i, &keychar);   // Herstellung des rotierten Alphabets
   ypos = get_xLetter_pos(Ur_abc, char_txt);               // Sucht in Ur_abc nach char_txt und gibt bei Erfolg dessen Position zurück
   letter_chiffriert = get_xpos_Letter(abc_rotiert, ypos); // hole einzelnes Ur_abc von rotierten Alphabet 
  }
  else
  {
   abc_rotiert = RotiereUr_abc(Ur_abc, i, &keychar);   // Herstellung des rotierten Alphabets
   ypos = get_xLetter_pos(abc_rotiert, char_txt);   // Sucht in abc_rotiert nach char_chiffriert und gibt bei Erfolg dessen Position zurück
   letter_chiffriert = get_xpos_Letter(Ur_abc, ypos);    
  }	  
 return letter_chiffriert;
}	

void clearchararray(char array[], int lge)
{
 for (int i = 0; i < lge; i++)
  array[i] = 0;	 
}

std::string getfilestring(std::fstream *datei, int *zeize)
{
 int i, chlen = 0, j;
 char buchs;
 std::string erge = "";
 
 j = *zeize;
 datei->get(buchs);  
 chlen = getcharart(buchs);
 erge += buchs;

 for (i = 1; i < chlen; i++)
  {
   datei->get(buchs);
   erge += buchs;
   j++;
  }

  *zeize = j;

 return erge;
}

void vigenere::putfilestring(std::ofstream *datei, std::string tosend)
{
 char buchs;
 char arrayteile[8];
 int i, tosend_lge = 0;
 
 tosend_lge = tosend.length(); // Laenge von cpp-String tosend in Byte

 clearchararray(arrayteile, 8);
 StringToChar(tosend, arrayteile);

 for (i = 0; i < tosend_lge; i++)
  datei->put(arrayteile[i]);
 
}

void ZeigeZeichen(int i, std::string char_letter, std::string letter_chiffriert, std::string letter_dechiffriert) 
{ 
 std::cout << "i=" << std::setw(3) << i << "  unchiffriert=" << char_letter << "  chiffriert=" << letter_chiffriert;
 std::cout << "  dechiffriert=" << letter_dechiffriert << std::endl;
   //std::cout << "  uisign=" << std::setw(3) << uisign << "   letter=" << char_letter << "  chlen=" << chlen << std::endl;
   //std::cout << "  bulen=" << bulen << std::endl;
}  

// Datei menues.cpp von viegener1f
#include "vigenere.h"
//Inhalt menues.cpp:
//void vigenere::HAUPTMENUE(void)
//int vigenere::MenueFrage(void)
//void vigenere::GetKeyword(void)
//void vigenere::GetPlaintext(void)
//void vigenere::rotiere_Ur_abc(void)
//void vigenere::ShowVigenereTable(void)
//void vigenere::SetzeTestVorgaben(void)
//void vigenere::Buchstabenplatzliste(void)
//void vigenere::BuchstabenplatzTest(void)
//void vigenere::ShowLaengentafel(void)
//void vigenere::Rotiere_plaintext(void)


void vigenere::HAUPTMENUE(void)
{   
  std::cout << std::endl << "Vigenere Versuch" << std::endl;
  std::cout << "Programmende..............0" << std::endl;
  std::cout << "Schluesseleingabe.........1" << std::endl;
  std::cout << "Texteingabe...............2" << std::endl;
  std::cout << "rotiere Ur-Alphabet.......3" << std::endl;
  std::cout << "Texteingabe rotieren......4" << std::endl; //5
  std::cout << "Ur_abc chiffrieren........5" << std::endl; //4
  std::cout << "Ur_abc dechiffrieren......6" << std::endl;
  std::cout << "Zeige vignere-Tafel.......7" << std::endl;
  std::cout << "Vorgabe fuer Test.........8" << std::endl;
  std::cout << "Dateitest................11" << std::endl;
}

int vigenere::MenueFrage(void)
{
 int frage = 18, i;
 std::string wastun = "";
 std::string erge[16] = {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10","11","12","13","14","15"};
 
 std::cout << std::endl << "Ihre Wahl: ";
 std::cin >> wastun; // frage 
 
 for (i = 0; i < 16; i++)
  {
   if (wastun.compare(erge[i]) == 0)
   {
	frage = i;
    break;   
   }
 }
 clpuf();
 
 return frage;
}

void vigenere::GetKeyword(void)
{
 int j;	 
    
 std::cout << "Eingabe des Schluessels: ";
 std::cin >> key; 
 clpuf();

 klen = key.length();
 kbulen = letterlaenge(key);
 std::cout << "Schluessel-Laenge in Byte......: " << klen << std::endl;
 std::cout << "Schluessel-Laenge in Buchstaben: " << kbulen << std::endl<< std::endl;   
         
 //Stellt die Position des Ur_abcs Nr. srcpos vom String source im String alphabet fest und gibt diese zurueck
 for (j = 0; j < kbulen; j++)		 	
  {
   keychar = get_xpos_Letter(key, j);  // einzelnes Ur_abc aus Schluesselstring nach teilb holen
   std::cout << " j=" << std::setw(2) << j << "  substr= " << keychar << std::endl;
  }
}  

void vigenere::GetPlaintext(void)
 { 
  std::cout << "Eingabe von plaintext: ";
  std::getline (std::cin, plaintext); 
  
  txtlen = plaintext.length();
  txtbulen = letterlaenge(plaintext);

  std::cout << "plaintext war.................: " << plaintext << std::endl;
  std::cout << "Laenge plaintext in Byte......: "<< txtlen << std::endl;
  std::cout << "plaintext Laenge in Buchstaben: " << txtbulen << std::endl;
 }
 
 
void vigenere::rotiere_Ur_abc(void)
{         
  int xpos = 0;
  std::string teilb = "";

  std::cout << "rotiere Ur-Alphabet" << std::endl;
  // plaintext Position von Teilstring aendern
  std::cout << std::endl << Ur_abc << std::endl;
  ShowLaengentafel();
  abclen = Ur_abc.length();
  std::cout << "Laenge des Ur_abc in byte......: " << abclen << std::endl;
  std::cout << "Laenge des Ur_abc in Buchstaben: " << letterlaenge(Ur_abc) << std::endl;
  std::cout << "\nUr_abc vorher: " << Ur_abc << std::endl;
         
  std::cout << "bis pos: ";
  std::cin >> xpos; 
  std::cout << "Eingabe pos: "  << xpos << std::endl;
  if ((xpos >= 0)  && (xpos < abclen))
   teilb = vigens(Ur_abc, xpos);
   
  std::cout << "rotiertes abc: " << teilb << std::endl;
}


void vigenere::ShowVigenereTable(void)
{   
 int i = 0;
 std::string teilc = "";
 std::string keychar = "";
 
 std::cout << "Zeige Vignere-Tafel" << std::endl;
 ShowKey();
 
 
 klen = letterlaenge(key); 

 for (i = 0; i < klen; i++)
  {
   teilc = RotiereUr_abc(Ur_abc, i, &keychar);
   std::cout << "teilc= " << teilc << std::endl;
  }
}  


 
void vigenere::SetzeTestVorgaben(void)
{   
 std::cout << "Setze Vorgaben fuer Test" << std::endl;  
 key = "asälk";
 klen = key.length();
 kbulen = letterlaenge(key);
	   
 plaintext = "abcdefghijklmnop";
 txtlen = plaintext.length();
 txtbulen = letterlaenge(plaintext);
	   
 ShowKey();
 std::cout << "plaintext.....................: " << plaintext << std::endl; 
 std::cout << "plaintext Laenge in Byte......: " << txtlen << std::endl; 
 std::cout << "plaintext Laenge in Buchstaben: " << txtbulen << std::endl; 
} 
 
void vigenere::Buchstabenplatzliste(void)
{     
 int j,bulen = 0, chlen; 
 std::string teilb;
 
 std::cout << "Buchstabenplatz-Liste" << std::endl;  
 std::cout << std::endl << Ur_abc << std::endl;
 ShowLaengentafel();
 abclen = Ur_abc.length();

 std::cout << "Laenge des Ur_abc in byte......: " << abclen << std::endl;
 std::cout << "Laenge des Ur_abc in Buchstaben: " << letterlaenge(Ur_abc) << std::endl;

 bulen = 0;

    for (j = 0; j < abclen; j++)
	 { 
	  chlen = getcharart(Ur_abc[j]);    // Bestimme Laenge des Zeichens von Ur_abc
	  if(chlen <= 4) teilb = Ur_abc.substr(j, chlen);  // Kopiere Ur_abc in teilb
	    else teilb = "";
	
       std::cout << "Ur_abc[" << std::setw(2) << j << "]="  << "  bulen=" << std::setw(2) << bulen << "   "<< Ur_abc[j];
       std::cout << " dec=" << std::setw(3) << atoint(Ur_abc[j]);
       std::cout << " Ur_abc[" << std::setw(2)<< bulen << "]=" << teilb <<  "  chlen=" << chlen << std::endl;
	  if (chlen <= 4) bulen++;
	} 
}  

void vigenere::BuchstabenplatzTest(void)
{ 
 int j, abclen, Ur_abc_buchslen, xpos = 0;
 std::string teilb = "";
 std::string dummy = "";
 
  std::cout << "Buchstabenplatz-Test" << std::endl;  
  std::cout << std::endl << Ur_abc << std::endl;
  ShowLaengentafel();
 

  abclen = Ur_abc.length();
  Ur_abc_buchslen = letterlaenge(Ur_abc);

  std::cout << "Laenge des Ur_abc in byte......: " << abclen << std::endl;
  std::cout << "Laenge des Ur_abc in Buchstaben: " << Ur_abc_buchslen << std::endl;
	   
	    
   for (j = 0; j < Ur_abc_buchslen; j++)
	{ 
	 teilb = get_xpos_Letter(Ur_abc, j);
	 std::cout << " Ur_abc[" << std::setw(2)<< j << "]=" << teilb << std::endl;
	}  
  
   std::cout << "Suche Buchstabe: ";
   std::cin >> dummy;
	  
   xpos = get_xLetter_pos(Ur_abc, dummy);   	
   std::cout << "an Position: " << xpos << std::endl;
}  
// Gets plaintext from user
void vigenere::ShowLaengentafel(void)
{ std::cout << "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345" << std::endl;
  std::cout << "         |         |         |         |         |         |         |         |         |         |" << std::endl;
}

void vigenere::Rotiere_plaintext(void)
{
 int xpos;
 
 std::cout << "Rotiere eingegebenen Text: ";
 std::cout << "Codiert vorher: " << plaintext << std::endl;
 
 std::cout << "Laenge eingegebener Text: " << txtlen << std::endl;
 std::cout << "bis pos: ";
 std::cin >> xpos; 
 teilb = vigens(plaintext, xpos);
 std::cout << "eingegebener Text neu...: " << teilb << std::endl;
}

// main.cpp von vigenere1f
// Bei der Herstellung des rotierten ABC muss noch korrigiert werden, da Umlaute doppelt
// in der Vigenere-Tafel dargestellt werden


#include "vigenere.h"


int main(int argc,  char *argv[])
{
 vigenere vig;
 
	
 //std::string Ur_abc = "abcdefghijklmnopqrstuvwxyzöäüß ABCDEFGHIJKLMNOPQRSTUVWXYZÖÄÜ0123456789.,!?;:-+*~#'<>|²³€@/^°µ_§${}[]()´`"; 
 //std::string Ur_abc = "abcdefghijklmnopqrstuvwxyzöäüß ABCDEFGHIJKLMNOPQRSTUVWXYZÖÄÜ0123456789";
 std::string letter_chiffriert = "";
 std::string chiffriert = "";
 std::string dechiffriert = "";
 std::string char_letter = "";
 std::string char_txt = "";
 int frage = 18, i, j, chiflen = 0, modus = 0;
 int lgechiffriert = 0;
   
 do
 switch(frage)
 {
   default: vig.HAUPTMENUE();
		 frage = vig.MenueFrage();
      break;


   case 0:
         //free(lesespeicher);
		 std::cout << "Programmende" << std::endl;  
         return 0;
	  break;
	

   case 1:
         vig.GetKeyword();
         frage = 18;
	  break;
 
   
   case 2:
     	 vig.GetPlaintext(); // Gets plaintext from user
 		 frage = 18;
	  break;
	  
   case 3:
         vig.rotiere_Ur_abc();
         frage = 18;		 
	  break; 

   case 4:
         vig.Rotiere_plaintext();
		 frage = 18;
	  break;   	  
	  
   case 5:
         // Ausgabe von plaintext in Buchstaben
         std::cout << std::endl << "Chiffrieren-Test: " << std::endl;
		 vig.ShowKey();
		 std::cout << "plaintext......................: " << vig.plaintext << std::endl;
		 std::cout << "Laenge plaintext in Byte.......: "<< vig.txtlen << std::endl;
		 std::cout << "plaintext Laenge in Buchstaben.: " << vig.txtbulen << std::endl;
		 std::cout << "Laenge des Ur_abc in byte......: " << vig.abclen << std::endl;
	     std::cout << "Laenge des Ur_abc in Buchstaben: " << vig.Ur_abc_buchslen << std::endl;
		
       i = 0; 
       for (j = 0; j < vig.txtbulen; j++)
	    { 
		 char_letter = vig.get_xpos_Letter(vig.plaintext, j); // Aus String plaintext einen Buchstaben holen
	
         letter_chiffriert = vig.chiffrieren(i, char_letter, 0);
 
		 chiffriert += letter_chiffriert;  
		 		 
	     vig.ShowVarib(i, j, letter_chiffriert);  

		 i++;
         if (i >= vig.kbulen) i = 0;
	    }
		 std::cout << "Text chiffriert: " << chiffriert << std::endl << std::endl;
		 frage = 18;
	  break; 	

   case 6:
        // Ausgabe von plaintext in Buchstaben
         std::cout << "Dechiffrieren Test.............: " << std::endl;
         vig.ShowKey();
		 std::cout << "Text chiffriert................: " << chiffriert << std::endl;
		 chiflen = chiffriert.length();
		 lgechiffriert = letterlaenge(chiffriert); // Laenge von String chiffriert in Buchstaben 
		 std::cout << "chiffriert laenge in Byte......: " << chiflen << std::endl;
		 std::cout << "chiffriert laenge in Buchstaben: " << lgechiffriert << std::endl;
		
       i = 0; 
       for (j = 0; j < lgechiffriert; j++)
	    { 
		 char_letter = vig.get_xpos_Letter(chiffriert, j); // Aus String chiffriert einen Buchstaben holen
		 
		 letter_chiffriert = vig.chiffrieren(i, char_letter, 1);
		    		 
		 dechiffriert += letter_chiffriert;  
  
		 vig.ShowVari(i, j, letter_chiffriert, char_letter);  

		 i++;
         if (i >= vig.kbulen) i = 0;  			 
	    }
		 std::cout << "Text dechiffriert: " << dechiffriert << std::endl << std::endl;
		 frage = 18;
	  break; 	

 case 7:
        vig.ShowVigenereTable(); 
		frage = 18;
	  break; 
 
 case 8:
        vig.SetzeTestVorgaben();
	    frage = 18;
	  break;

  case 9:
        vig.Buchstabenplatzliste();
        frage = 18;
	  break;
  
  case 10:
        vig.BuchstabenplatzTest();
        frage = 18;
	  break;
  
  case 11:
        std::cout << "Dateitest" << std::endl;
		vig.getcurdir();
		std::cout << "chiffrieren(0) oder dechiffrieren(1):";
		modus = vig.MenueFrage();
		vig.ShowKey();
		vig.srcfilename = "test.txt";
		std::cout << "Name der Quelldatei: ";
		std::cin >> vig.srcfilename;
		std::cout << "Name der Zieldatei.: ";
		std::cin >> vig.tarfilename;
		vig.StringToChar(vig.srcfilename, vig.dummy);
		std::cout << "Eingabe: " << vig.dummy << std::endl;
		
	    if( access(vig.dummy, F_OK ) != -1 )
         {
          std::cout << "Datei mit Namen\n" << vig.dummy << "\nwurde gefunden " << std::endl; // file exists
          vig.srcdatlen = vig.getFilesize(vig.srcfilename);
		  std::cout << "Dateilaenge betraegt :" << vig.srcdatlen << " Byte" << std::endl;
		  vig.ReadValIn(vig.srcfilename, modus);
		 }
          else 
		   {
            std::cout << "Datei nicht gefunden" << std::endl; // file doesn't exist
           } 
	    frage = 18;
	  break;
  
  
}while(frage != 0);
 
 
 std::cout << "End of Program" << std::endl;  
 return 0;
}
 

Mach mit!