Ich möchte eine Such-Funktion schreiben, die so aussehen könnte:

void search(int z,string t,string a){...}

Die Funktion soll ein Objekt innerhalb eines vectors suchen. Dabei soll es dem Benutzer aber erlaubt sein weniger als 3 Agumente anzugeben. Z.b.soll er auch nur mit z und t oder z und a ein Ergebniss erhalten, ohne dass die Funktion anmerkt, dass zu wenige Argumente übergeben wurden!

Wie ist das zu lösen?

Mfg Golfi

Überladung nennt sich das.

#include "../../../std_lib_facilities.h"

class Book
{
public:
	string title;
	string autor;
	int ISBN;
};

vector<Book>Books;
int pb;

void search()
{ 
	search(0,"default","default");
} 

void search(int ISBN)
{ 
	search(ISBN,"default","default");
}

void search(int ISBN,string title)
{ 
	search(ISBN,title,"default");
} 

void search(int ISBN,string title,string autor)
{
	for(int i = 0;i<Books.size();++i)
	{
		if(ISBN == Books[i].ISBN && title == Books[i].title && autor == Books[i].autor)//Wenn alle Daten übereinstimmen
		{
			pb = i;
	    }
	}
}

int main()
{
	Book h;
	Book Test;
	Test.title = "Test";
	Test.autor = "Nick";
	Test.ISBN = 1234;
	Books.push_back(h);
	Books.push_back(Test);
	int ISBN = 1234;
	search();
	cout<<pb;
	keep_window_open();
}

Was ich nicht versteht, woher bekommen die search_funktionen denn die Argumente nach denen sie suchen sollen. Wenn ich z.b. nach der ISBN suchen möchte, muss ich dann search(ISBN) machen? Aber woher bekommt die search den integer ?muss der global sein?

void search(){ search(0,"default","default");}
void search(int z){ search(z,"default","default");}
void search(int z,string t){ search(z,t,"default");}
void search(int z,string t,string a){...}

Überladung nennt sich das.

void search(int z = 0, string t = "default", string a = "default") {...}

Default-Parameter nennt sich das. :p

Die Objekte in dem vector sollen Objekte mit folgendem Typ sein:

class Test
{
public:
int z;
stirng a;
string b;
}

Danke

void search(int count, ...)
{
    va_list l;
    va_start(l, count);
    for (int i = 0; i < count; ++i)
    {
        char *str = va_arg(l, char*);
        std::cout << "Str " << i << " : " << str << std::endl;
    }
    va_end(l);
}

search(3, "Test", "TdA", "OJ");
search(2, "Test2", "TdAasd");

Gruß, Daniel

Meiner Meinung kann man das nur lösen indem man den Funktionnamen ändern und es so schreibt

void search_t(int z, string t) {search(z, t, "Default für a");}
void search_a(int z, string a) {search(z, "Default für t", a);}
void search(int z) {search(z, "Default für t", "Default für a");}
void search(int z,string t,string a){...}

Das problem ist doch das der Compiler nicht erkennen kann ob der übergebene String jetzt für a oder für t übergeben wird.Die Funktion wäre nicht eindeutig da t und a beides Strings sind.

Meiner Meinung kann man das nur lösen indem man den Funktionnamen ändern und es so schreibt

void search_t(int z, string t) {search(z, t, "Default für a");}
void search_a(int z, string a) {search(z, "Default für t", a);}
void search(int z) {search(z, "Default für t", "Default für a");}
void search(int z,string t,string a){...}

Falsch. Ich empfehle dir das Buch "Effektiv C++ programmieren" von Scott Meyers.
Scott erklärt in diesem Buch, dass man dafür Enums (für eine abzählbare Menge von Eingabewerten, etwa Wochentage) oder eigene Typen dafür verwendet.

also etwa sowas:

class Autor {
  string name;
  bool is_set;
  Autor(const char * name) : name(name), bool(name) {}
  bool isset() const { return is_set; }
  const string& name() const { return name; }
};

class Titel{
//... analog zu Autor
};

class ISBN{
//...
};

entry_type suche(ISBN i, Autor a, Titel t);

int main() {
  entry_type result = suche(ISBN(0), Autor("Scott Meyers"), Titel(0));

  std::cout << result << std::endl;

}

Sowas in etwa. Die C-String sind zwar nicht schön, aber man kriegt über den Nullzeiger die Optionalität geschenkt - string* sollte auch gehen, ist aber umständlicher in der Benutzung.

Daniel_S schrieb:

Das problem ist doch das der Compiler nicht erkennen kann ob der übergebene String jetzt für a oder für t übergeben wird.Die Funktion wäre nicht eindeutig da t und a beides Strings sind.

Meiner Meinung kann man das nur lösen indem man den Funktionnamen ändern und es so schreibt

void search_t(int z, string t) {search(z, t, "Default für a");}
void search_a(int z, string a) {search(z, "Default für t", a);}
void search(int z) {search(z, "Default für t", "Default für a");}
void search(int z,string t,string a){...}

Falsch. Ich empfehle dir das Buch "Effektiv C++ programmieren" von Scott Meyers.
Scott erklärt in diesem Buch, dass man dafür Enums (für eine abzählbare Menge von Eingabewerten, etwa Wochentage) oder eigene Typen dafür verwendet.

also etwa sowas:

class Autor {
  string name;
  bool is_set;
  Autor(const char * name) : name(name), bool(name) {}
  bool isset() const { return is_set; }
  const string& name() const { return name; }
};

class Titel{
//... analog zu Autor
};

class ISBN{
//...
};

entry_type suche(ISBN i, Autor a, Titel t);

int main() {
  entry_type result = suche(ISBN(0), Autor("Scott Meyers"), Titel(0));

  std::cout << result << std::endl;

}

Echt? Machst du eine extra Klasse für Name, Vorname, Straße, Benutzername, Titel, Nachrichtentext, X-Koordinate, Y-Koordinate, Autoname, Schiffname usw...

Echt? Machst du eine extra Klasse für Name, Vorname, Straße, Benutzername, Titel, Nachrichtentext, X-Koordinate, Y-Koordinate, Autoname, Schiffname usw...

Finde ich auch übertrieben. Man könnte es sich für spezielle Formate wie ISBN-Nummer überlegen, aber für die meisten Eigenschaften würde ich std::string nehmen.

Die Alternative eine Klasse mit allen Eigenschaften.

struct Buch
{
    Buch(); // setzt Default-Werte

    std::string Titel;
    std::string Autor;
    ...
};

int main()
{
    Buch b;
    b.Titel = "Effective C++";
    b.Autor = "Scott Meyers";

    Suche(b);
}

Natürlich kann man hier noch stundenlang rumwerkeln und z.B. mit Set/Get kapseln, Named Constructor Idiom für schnelle temporäre Objekte anwenden oder sogar mehrere Argumentreihenfolgen erlauben. Aber ich bezweifle, dass sich der Aufwand lohnt.

bmario_ schrieb:

Daniel_S schrieb:

Das problem ist doch das der Compiler nicht erkennen kann ob der übergebene String jetzt für a oder für t übergeben wird.Die Funktion wäre nicht eindeutig da t und a beides Strings sind.

Meiner Meinung kann man das nur lösen indem man den Funktionnamen ändern und es so schreibt

void search_t(int z, string t) {search(z, t, "Default für a");}
void search_a(int z, string a) {search(z, "Default für t", a);}
void search(int z) {search(z, "Default für t", "Default für a");}
void search(int z,string t,string a){...}

Falsch. Ich empfehle dir das Buch "Effektiv C++ programmieren" von Scott Meyers.
Scott erklärt in diesem Buch, dass man dafür Enums (für eine abzählbare Menge von Eingabewerten, etwa Wochentage) oder eigene Typen dafür verwendet.

also etwa sowas:

class Autor {
  string name;
  bool is_set;
  Autor(const char * name) : name(name), bool(name) {}
  bool isset() const { return is_set; }
  const string& name() const { return name; }
};

class Titel{
//... analog zu Autor
};

class ISBN{
//...
};

entry_type suche(ISBN i, Autor a, Titel t);

int main() {
  entry_type result = suche(ISBN(0), Autor("Scott Meyers"), Titel(0));

  std::cout << result << std::endl;

}

Echt? Machst du eine extra Klasse für Name, Vorname, Straße, Benutzername, Titel, Nachrichtentext, X-Koordinate, Y-Koordinate, Autoname, Schiffname usw...

Dort wo es sinnvoll ist

Ist sicher nicht überall sinnvoll. Scott Meyers hat sich da mit dem Datum aber ein sehr gutes Beispiel gesucht. Angenommen du schreibst eine Klasse, die ein Datum kapselt. Dann wäre der Konstruktor schnell aufgeschrieben:

Date(int day, int month, int year);

Jetzt stell dir vor, ein Ami benutzt die Klasse für Weihnachten:

Date xmas = Date(12,24,2011);

Okay, das kannst du mit assert() oder ähnlichem Abfangen, aber was ist mit dem 6.1.

Date heiligeDreiKoenige = Date(1,6,2012);

Rumms! Nun wird das Weihnachtszeugs zum Kindertag weggeräumt

In diesem Speziellen Fall sind Klassen geeignet um ein fehlerhaftes Benutzen der Klasse schon beim kompilieren zu entdecken.

Date(Day d, Month m, Year y);

(Achtung: explicit Konstruktor, hab ich oben vergessen)

Der selbe Ami kann nun folgendes nicht mehr kompilieren:

Date nikolaus = Date(Month(12), Day(6), Year(2011));

Damit haben wir einen Logikfehler bereits beim Kompileren abgefangen. Super!

template <typename T, typename TypeTag = void>
class Value
{
	public:
		Value()
		: mValue()
		{
		}

		explicit Value(T value)
		: mValue(value)
		{
		}

		T Get() const
		{
			return mValue;
		}

	private:
		T mValue;
};

Der zweite Template-Parameter dient zur typsicheren Unterscheidung bei ähnlichen Typen. Beispiel:

namespace Tags
{
	struct Day;
	struct Month;
	struct Year;
}

typedef Value<int, Tags::Day>   Day;
typedef Value<int, Tags::Month> Month;
typedef Value<int, Tags::Year>  Year;

Die Grundidee bleibt aber die selbe. Ein eigener Typ für semantisch verschiedene Eingabewerte. Man muss das natürlich nicht immer so machen, aber gerade für Schnittstellen bietet sich diese zusätzliche Sicherheit an. Man kann das ganze auch weitertreiben, etwa Day in Abhängigkeit zu Month bringen (30 vs 31 Tage) oder gar noch Year (man denke nur Schaltjahre). Aber dies sollte man im Einzelfall überprüfen.