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

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

. und - haben aber keine Groß-/Kleinschreibung

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

? Dann kann ich dir da vllt weiterhelfen ...

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

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).

//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!");