Probleme mit Arrays

[Ramses]

Hallo Zusammen,

ich habe ein kleines (oder großes) Problem mit Arrays und deren Verarbeitung.
Ich habe im Forum auch schon ein paar Einträge gefunden, die ich aber nicht so ganz nachvollziehen kann, bzw. mir auch nicht soo weiter helfen.
Also, ich will Morsezeichen in Text umwandeln.
Dafür habe ich folgenden Code erstellt.
(Seid nachsichtig, aber ich bin C++ Anfänger und alter BASIC-Benutzer ....

#include "stdafx.h"
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#include <cstring>
#include "iostream.h"

char *morse[26] = { ".-", "-...", "-.-.", "-..", ".", "..-.", "--.", "....",
                    "..", ".---", "-.-", ".-..", "--", "-.", "---", ".--.",
                    "--.-", ".-.", "...", "-", "..-", "...-", ".--", "-..-",
                    "-.--", "--.."};

char c_Zwischenspeicher[80];            //Zeiger deklarieren

FILE *File;

void main(void)
{
        char c_Einlesen;
        //char *c_Ergebnis;
        int i,k;
        i=0;
		k=0;

        if ((File = fopen("C:\\TEMP\\morse.txt", "r")) != NULL)   //Datei im aktuellen Verzeichnis öffnen
        {
                while ((c_Einlesen=fgetc(File)) != EOF) //Daten bis zum Ende einlesen
                {
             *(c_Zwischenspeicher+i)=c_Einlesen;					//Daten einlesen und Adresse eins höher zählen

                         printf(" Zwischenspeicher %i: %c \n",i, *(c_Zwischenspeicher+i));
						 //printf(" Zwischenspeicher %i: %p \n",i, c_Zwischenspeicher+i);
                         i++;

                }

						  for (i=0;i<26;i++)                     //Eingelsene Daten durchgehen bis zum Ende
						 {

									printf("\n Morse %i: %c",i,  *(morse[i]));
									printf("\n Zwischenspeicher %i: %c",i,  *(c_Zwischenspeicher+i));

								if strcmp(c_Zwischenspeicher+i, morse[i])==0) 						{
				                       printf("\nHALLO!");                                         

								}

						  }
				}

        else{
                cout<<"Fehler beim Einlesen der Daten!";
        }
}

====================================================
Das Problem ist, dass er den eingelesenen Text nicht mit den Morsezeichen vergleicht, also die Funktion strcmp nicht richtig verarbeitet. Also er gibt nicht "HALLO" aus!.
Hoffentlich habt ihr ne Idee, danke schon mal.
Ramses

Zur Info ich verwende VisualStudio 6.0 auf Windows XP

[Stelfer]

//also in c++ hast du ander input output streams, z.b. ostream - du hast ein c programm
#include <stdio.h>
#include <stdlib.h> 
#include <string.h> 
#include <iostream> 
/*
	die neuen bibos in c++ wären
	<cstdio><cstdlib><cstring> wie oben und iostream
	dazu müsstest du noch den namespace einbinden
*/
using namespace std;
char *morse[26] = { ".-", "-...", "-.-.", "-..", ".", "..-.", "--.", "....", 
                    "..", ".---", "-.-", ".-..", "--", "-.", "---", ".--.", 
                    "--.-", ".-.", "...", "-", "..-", "...-", ".--", "-..-", 
                    "-.--", "--.."}; 

char c_Zwischenspeicher[80];            //Zeiger deklarieren  <---- das ist kein zeiger das ist ein char Array

FILE *File; //machs doch lokal

int main(void) //main hat int als rückgabe
{ 
        char c_Einlesen; 
        int i=0,k=0; 

        if ((File = fopen("C:\\TEMP\\morse.txt", "r")) != NULL)   //Datei im aktuellen Verzeichnis öffnen 
        { 
                while ((c_Einlesen=fgetc(File)) != EOF) //Daten bis zum Ende einlesen 
                { 
					*(c_Zwischenspeicher+i)=c_Einlesen;                    //Daten einlesen und Adresse eins höher zählen 

                         printf(" Zwischenspeicher %i: %c \n",i, *(c_Zwischenspeicher+i));  
                         i++; 

                } 

                          for (i=0;i<26;i++)                     //Eingelsene Daten durchgehen bis zum Ende 
                         { 
                                    printf("\n Morse %i: %c",i,  *(morse[i])); 
                                    printf("\n Zwischenspeicher %i: %c",i,  *(c_Zwischenspeicher+i)); 

								//strcmp vergleicht auch die groß kleinschreibung, berücksichtigen !
                                if (strcmp(c_Zwischenspeicher+i, morse[i])==0)
                                       printf("\nHALLO!");

                          } 
                } 

        else{ 
                cout<<"Fehler beim Einlesen der Daten!"; 
        } 
}

[Th]

//strcmp vergleicht auch die groß kleinschreibung, berücksichtigen !
if (strcmp(c_Zwischenspeicher+i, morse[i])==0)
printf("\nHALLO!");

. und - haben aber keine Groß-/Kleinschreibung

[*D*Evil]

Hmm hab mich gerade mal über Morsecode informiert ... kommt zwischen jedem Buchstaben eine Freistelle? Also bsw.

-·· · ···- ·· ·-·· --- ·--· · ·-·

? Dann kann ich dir da vllt weiterhelfen ...

[Ramses]

Hallo @all,

erst mal danke für die Infos.
@Stelfer:
werde Deinen Code mal ausprobieren.
@(D)Evil:
Ja, die einzelnen Zeichen werden durch ein Leerzeichen getrennt.
Was meint ihr eigentlich bis jetzt zu meinem Code?
Kanns (irgendwann mal) funktionieren, oder sind größere Denkfehler drin?
Danke,

Ramses

[*D*Evil]

hmm naja hab mal angefangen dir was zu schreiben ... musst de allerdings selber fertig machen

MorseParser.h

#if !defined(MORSE_PARSER_H__INCLUDED)
#define MORSE_PARSER_H__INCLUDED

#include <iostream>
#include <fstream>
#include <string>
#include <map>
#include <algorithm>
#include <cctype>

class MorseParser
{
public:
	MorseParser();
	~MorseParser();

public:
	static MorseParser&		instance()	{	static MorseParser parser; return parser;	}

public:
	bool		parse_morse_file(const std::string&);
	void		parse_morse(std::string&);
	void		parse_string(std::string&);

private:
	std::map<char, std::string>		m_morsecode;
};

#endif // MORSE_PARSER_H__INCLUDED

MorseParser.cpp

#include "MorseParser.h"

MorseParser::MorseParser()
{
	m_morsecode.insert(std::make_pair('a', ".- "));
	m_morsecode.insert(std::make_pair('b', "-... "));
	m_morsecode.insert(std::make_pair('c', "-.-. "));
	m_morsecode.insert(std::make_pair('d', "-.. "));
	m_morsecode.insert(std::make_pair('e', ". "));
	m_morsecode.insert(std::make_pair('f', "..-. "));
	m_morsecode.insert(std::make_pair('g', "--. "));
	m_morsecode.insert(std::make_pair('h', ".... "));
	m_morsecode.insert(std::make_pair('i', ".. "));
	m_morsecode.insert(std::make_pair('j', ".--- "));
	m_morsecode.insert(std::make_pair('k', "-.- "));
	m_morsecode.insert(std::make_pair('l', ".-.. "));
	m_morsecode.insert(std::make_pair('m', "-- "));
	m_morsecode.insert(std::make_pair('n', "-. "));
	m_morsecode.insert(std::make_pair('o', "--- "));
	m_morsecode.insert(std::make_pair('p', ".--. "));
	m_morsecode.insert(std::make_pair('q', "--.- "));
	m_morsecode.insert(std::make_pair('r', ".-. "));
	m_morsecode.insert(std::make_pair('s', "... "));
	m_morsecode.insert(std::make_pair('t', "- "));
	m_morsecode.insert(std::make_pair('u', "..- "));
	m_morsecode.insert(std::make_pair('v', "...- "));
	m_morsecode.insert(std::make_pair('w', ".-- "));
	m_morsecode.insert(std::make_pair('x', "-..- "));
	m_morsecode.insert(std::make_pair('y', "-.-- "));
	m_morsecode.insert(std::make_pair('z', "--.. "));
}

MorseParser::~MorseParser()
{
	m_morsecode.clear();
}

bool MorseParser::parse_morse_file(const std::string& string_filename)
{
	std::ifstream file_stream(string_filename.c_str(), std::ios::in);
	if (file_stream.is_open() == false || file_stream.good() == false)
		return false;

	while (file_stream.eof() == false)
	{
		std::string string_line;
		std::getline(file_stream, string_line);
		parse_morse(string_line);
	}

	file_stream.close();	
	return true;
}

void MorseParser::parse_morse(std::string& string_code)
{
	string_code += ' ';
	for (std::map<char, std::string>::iterator it = m_morsecode.begin(); it != m_morsecode.end(); ++it)
	{
		size_t pos = string_code.find((*it).second);
		while (pos != std::string::npos)
		{
			if (pos == 0 || string_code[pos - 1] == ' ' || (string_code[pos - 1] != '.' && string_code[pos - 1] != '-'))
				string_code.replace(pos, (*it).second.length(), 1, (*it).first);
			else
				++pos;
			pos = string_code.find((*it).second, pos);
		} 
	}
	std::cout << string_code << std::endl;
}

void MorseParser::parse_string(std::string& string)
{
	std::transform(string.begin(), string.end(), string.begin(), std::tolower);
	for (std::map<char, std::string>::iterator it = m_morsecode.begin(); it != m_morsecode.end(); ++it)
	{
		size_t pos = string.find((*it).first, 0);
		while (pos != std::string::npos)
		{
			string.replace(pos, 1, (*it).second);
			pos = string.find((*it).first, pos);
		} 
	}
	std::cout << string << std::endl;
}

main.h

#if !defined(MAIN_H__INCLUDED)
#define MAIN_H__INCLUDED

#include <iostream>
#include <string>
#include <sstream>

#include "MorseParser.h"

template <typename t> t read_type(std::string const &prompt, const t& min, const t& max) 
{
	std::istringstream isstr;
	std::string s;
	t ret;

	do {
		std::cout << prompt << std::flush;
		std::getline(std::cin, s);

		isstr.clear();
		isstr.str(s);
		isstr >> ret;
	} while (!isstr || ret > max || ret < min);

	return ret;
}

#endif // MAIN_H__INCLUDED

Wobei du hier die read_type-Funktion auch anders machen kannst

main.cpp

#include "main.h"

int main()
{
	std::cout << "Morse-Parser V0.1" << std::endl;
	std::cout << "(1) Datei" << std::endl;
	std::cout << "(2) Morsecode-Eingabe" << std::endl;
	std::cout << "(3) Stringcode-Eingabe" << std::endl;
	std::cout << "(4) Beenden" << std::endl;

	unsigned short sel = 0;
	do
	{
		sel = read_type<unsigned short>("Auswahl: ", 1, 4);
		switch (sel)
		{
		case 1:
			{
				std::cout << "\t-> Dateiname: " << std::flush;
				std::string string_filename;
				std::getline(std::cin, string_filename);
				if (MorseParser::instance().parse_morse_file(string_filename) == false)
					std::cout << "FEHLER: Die Datei konnte nicht geöffnet werden!" << std::endl;
			} break;
		case 2:
			{
				std::cout << "\t-> Morsecode-Eingabe: " << std::flush;
				std::string string_line;
				std::getline(std::cin, string_line);
				MorseParser::instance().parse_morse(string_line);
			} break;
		case 3:
			{
				std::cout << "\t-> Stringcode-Eingabe: " << std::flush;
				std::string string_line;
				std::getline(std::cin, string_line);
				MorseParser::instance().parse_string(string_line);
			} break;
		}
		std::cout << "\n" << std::endl;
	} while (sel != 4);
	return 0;
}

so ... funktioniert noch nicht ganz richtig ... also such mal den Fehler

Edit
2/2 Fehlern rausgenommen.
1/1 Aufgabe selbst gemacht. (Also std::transform an die richtige Stelle gesetzt).

[*D*Evil]

Naja aber versuch das erstmal zu verstehen ... und find den letzten Fehler ... er hat was mit std::string::replace zu tun Und befindet sich in parse_morse

[*D*Evil]

Hmm du brauchst mir zu lange da setz ich dir die Lösung lieber selber hin ... das Problem ist, das du gucken musst, wenn du den String parst, das davor kein '-' oder '.' liegt ... weil dann kommt da Müll raus ...

[Stelfer]

Th schrieb:

//strcmp vergleicht auch die groß kleinschreibung, berücksichtigen !
if (strcmp(c_Zwischenspeicher+i, morse[i])==0)
printf("\nHALLO!");

. und - haben aber keine Groß-/Kleinschreibung

while ((c_Einlesen=fgetc(File)) != EOF) { 
                    *(c_Zwischenspeicher+i)=c_Einlesen;                    //Daten einlesen und Adresse eins höher zählen 

                        ...

              ...  if (strcmp(c_Zwischenspeicher+i, morse[i])==0)  //was steht den in c_Zwischenspeicher ? der liest es aus der datei
                                       printf("\nHALLO!");