Fehler erkennen

cout << "Wort eingeben" ;
cin >> wort;

if (wort == intel)
{cout << "Intel prouziert Prozessoren ";}

if (wort == nvidia)
{cout << "nVidia stellt Grafikkarten her ";}

if (wort == acer)
{cout << "Acer entwickelt Laptops ";}

if (wort == nokia)
{cout << "Nokia ist einer der groeßten Handyhersteller. ";}

if (wort == infeneon)
{cout << "Infeneon bietet Halbleiterchips an. ";}

Oben seht ihr ein kleines Programm. Wenn z.B. Intel eintippt, zeigt es an, was in cout steht.

Aber wenn der User statt Intel sowas eintipppt -> ihsfjhdfjhsdfhj <- dann soll das programm alles anzeigen was mit i anfängt (z.B. Intel, infeneon), da das wort was der User eingegeben hat auch mit " i " anfängt.
(Das soll wie bei Goolgle funktionieren : "Meinten Sie : ......")

Könnt ihr das Programm so modifizieren, sodass es nach meiner Beschreibung funktioniert??

thx

brotbernd

equal_range mit einem predicate für Teilstrings.
Eingabe "i" -> infineon, intel
Eingabe "inf" -> infineon

#include <array>
#include <algorithm>
#include <iterator>
#include <string>
#include <iostream>

template<typename Iter> 
class string_match 
{
public:
	typedef Iter iterator;

	struct partial_string {
		partial_string(const std::string& str):str(str){}
		std::string str;
	};

	struct partial_str_less {
		bool operator()(const std::string& lhs, const std::string& rhs) const {
			return lhs < rhs;
		}

		bool operator()(const std::string& lhs, const partial_string& rhs) const {
			return lhs.substr(0,rhs.str.size()) < rhs.str;
		}

		bool operator()(const partial_string& lhs, const std::string& rhs) const {
			return lhs.str < rhs.substr(0,lhs.str.size());
		}
	};

	string_match(Iter first, Iter last);
	std::pair<Iter, Iter> match(const std::string& match);
 private:
	Iter m_first;
	Iter m_last;
 };

template<typename Iter> 
string_match<Iter>::string_match(Iter first, Iter last):
	m_first(first),
	m_last(last)
{}

template<typename Iter> 
std::pair<Iter, Iter> string_match<Iter>::match(const std::string& match) {
	return equal_range(m_first, m_last, partial_string(match), partial_str_less());
}

int main()
{
	using namespace std;
	typedef tr1::array<string, 5> arr;
	typedef arr::const_iterator Iter;
	typedef string_match<Iter> match;

	tr1::array<string, 5> dict = {
		"intel", "nvidia", "acer", "nokia", "infineon"};
	sort(dict.begin(),dict.end());

	match matcher(dict.begin(), dict.end());
	for(;;){
		string s;
		cout << "eingabe:";
		cin >> s;
		if (s == "q") break;

		pair<match::iterator, match::iterator> result = 
			matcher.match(s);

		copy(result.first, result.second, 
			ostream_iterator<string>(cout,"\n"));
	}

	return 0;
}

brotbernd schrieb:

equal_range mit einem predicate für Teilstrings.
Eingabe "i" -> infineon, intel
Eingabe "inf" -> infineon

#include <array>
#include <algorithm>
#include <iterator>
#include <string>
#include <iostream>

template<typename Iter> 
class string_match 
{
public:
	typedef Iter iterator;

	struct partial_string {
		partial_string(const std::string& str):str(str){}
		std::string str;
	};

	struct partial_str_less {
		bool operator()(const std::string& lhs, const std::string& rhs) const {
			return lhs < rhs;
		}

		bool operator()(const std::string& lhs, const partial_string& rhs) const {
			return lhs.substr(0,rhs.str.size()) < rhs.str;
		}

		bool operator()(const partial_string& lhs, const std::string& rhs) const {
			return lhs.str < rhs.substr(0,lhs.str.size());
		}
	};
 
	string_match(Iter first, Iter last);
	std::pair<Iter, Iter> match(const std::string& match);
 private:
	Iter m_first;
	Iter m_last;
 };

template<typename Iter> 
string_match<Iter>::string_match(Iter first, Iter last):
	m_first(first),
	m_last(last)
{}

template<typename Iter> 
std::pair<Iter, Iter> string_match<Iter>::match(const std::string& match) {
	return equal_range(m_first, m_last, partial_string(match), partial_str_less());
}

int main()
{
	using namespace std;
	typedef tr1::array<string, 5> arr;
	typedef arr::const_iterator Iter;
	typedef string_match<Iter> match;

	tr1::array<string, 5> dict = {
		"intel", "nvidia", "acer", "nokia", "infineon"};
	sort(dict.begin(),dict.end());

	match matcher(dict.begin(), dict.end());
	for(;;){
		string s;
		cout << "eingabe:";
		cin >> s;
		if (s == "q") break;

		pair<match::iterator, match::iterator> result = 
			matcher.match(s);

		copy(result.first, result.second, 
			ostream_iterator<string>(cout,"\n"));
	}

	return 0;
}

wow geht es net bisl einfacher???.
das programm soll ja nur den anfangsbuchstaben lesen und alles ausgeben was mit diesen buschtabe anfängt.^^

brotbernd

Das ist doch sehr einfach.
Das entschiedene ist, dass du eine sortierte Range an Wörtern braucht und daran ein equal_range durchführst.
Wenn du nur den Anfangsbuchstaben betrachten willst musst du das predicate (partial_str_less) anpassen.

bool operator()(const std::string& lhs, const std::string& rhs) const {
            return lhs[0] < rhs[0];
        }

Schau dir mal im obigen Link die Referenz zu equal_range an.
Mach dich mit der STL vertraut, das ist extrem nützliches Zeugs.

elise

fang doch einfach mal an.

ersten buchstaben der eingabe abholen und dann die daten in irgendeiner form (array, datei...) abholen und je eingabe ausgeben. so ist wohl eure aufgabe

wenn du nicht weiterkommst, wieder fragen.

:xmas2:

Samyboy

Hallo,

Ich verstehe deine Probleme völlig mit diesen 100 Zeilen Code.

Ich als Anfänger (jetzt schon nen bissl weiter fortgeschritten :p) möchte auch immer den ganze Code nachvollziehen können.

Also hier ist eine viel einfachere Lösung, die auch bloss das macht, was du möchtest, nicht mehr.

Oh und bei deinen if checks sollte das so aussehen:

if (wort == "blabla") // richtig
if (wort == blabla) // falsch

Ich würde dir vorschlagen deine Wörter in ein Array zu packen, bei der Eingabe zuerst schauen ob ein Wort, dass in deinem Array eingegeben wurde existiert, falls ja dieses ausgeben.
Danach durch dein Array loopen, jeweils den ersten Buchstaben der Eingabe mit dem ersten Buchstaben deines Strings in deinem Array vergleichen, falls es übereinstimmt ausgeben:

string words[3] = {"bla", "ala", "cala"};
const int SIZE = 3;
bool isInWords = false;

cin >> word;

for (int i = 0; i < SIZE; i++) {
  if (word == words[i]) {
     cout << words[i] << endl;
     isInWords = true;
     break;
  }
}

if (!isInWords) { // Falls kein Wort mit der Eingabe übereinstimmt
  for (int i = 0; i < SIZE; i++) {
    if (word[0] == words[i][0]) { // Falls die ersten Buchstaben übereinstimmen..
      cout << words[i] << endl;
    }
  }
}

Es ist ungetestet, also falls was nicht funktioniert tuts mir leid

brotbernd

Samyboy schrieb:

for (int i = 0; i < SIZE; i++) {

Was machst du wenn SIZE die Größe des Dudens ist? Möchtest du wirklich jedes Wort einzeln durchgehen?

Samyboy

brotbernd schrieb:

Samyboy schrieb:
for (int i = 0; i < SIZE; i++) {
Was machst du wenn SIZE die Größe des Dudens ist? Möchtest du wirklich jedes Wort einzeln durchgehen?

Nein, dann würde ich das ganze natürlich nicht so machen.

Aber es ist offentsichtlich, dass Er/Sie noch ein Anfänger ist, daher möchte ich Ihn/Sie nicht mit Code bombadieren, denn wenn man das bei mir anfangs tat, verlor ich sofort die Lust und Motivation

brotbernd

Das ist halt eine generische Lösung die ich so aus der Kiste gezaubert habe.
Aber weil heute der 4.Advent :xmas1: ist eine Reduzierung aufs Wesentliche für unmotivierte Anfänger

bool str_less(const std::string& lh, const std::string& rh)
{
        // Anfangsbuchstabe ist kleiner
	return lh[0] < rh[0];
}

int main()
{
	using namespace std;
	typedef tr1::array<string, 5> Wortarray;
	typedef Wortarray::const_iterator Iter;

	// Array von bekannten Wörtern
	Wortarray dict = {
        "intel", "nvidia", "acer", "nokia", "infineon"}; 
	// Wörter sortieren
	sort(dict.begin(), dict.end());

	for(;;){
		// Suchwort eingeben
		string s;
		cout << "eingabe:";
		cin >> s;
		if (s == "q") break;

		// Wörter suchen mit str_less
		pair<Iter,Iter> result = 
			equal_range(dict.begin(), dict.end(), s, &str_less);

		// Nach cout kopieren
		copy(result.first, result.second, 
			ostream_iterator<string>(cout, "\n"));
	}

	return 0;
}

Achtung: Leere Strings werden in str_less nicht abgefangen.
Wenn etwas unklar ist nicht aufgeben sondern fragen