Ausgabe des Programm(Hornschema) |
| 29.05.2018, 01:26 | Auf diesen Beitrag antworten » | |||||||||||||||||||||||||||||||||||
| beta258 | Ausgabe des Programm(Hornschema) Wie kann man auf die Ausgabe des Programms kommen. Kann das leider nicht nachvollziehen, kann mir einer weiterhelfen. Lösungen: Nr. 1 (x,k,grad) Nr. Rückgabewert 1. (3,0,2) 6. 7*3+a[0]=24 2. (3,1,1) 5. 2*3+a[1]=7 3. (3,2,0) 4. a[2]= 2 Ausgabe: 24 Der Code, der diese Ausgaben produziert ist im Anhang. Ich verstehe leider nicht so, wie man auf diese Ergebnisse kommt. Könnte mir einer helfen und sagen, wie und welche Codes diese Ausgaben(die einzelnen Schritte, die dazu führen) produzieren und wie? Wäre sehr nett, wenn ihr mir helfen könntet 
|
|||||||||||||||||||||||||||||||||||
|
|
||||||||||||||||||||||||||||||||||||
| 30.05.2018, 00:11 | Auf diesen Beitrag antworten » | |||||||||||||||||||||||||||||||||||
| as_string | Was genau verstehst Du nicht? Kennst Du das Horner Schema zum effizienten ausrechnen eines Polynoms? Gruß Marco |
|||||||||||||||||||||||||||||||||||
| 01.06.2018, 01:31 | Auf diesen Beitrag antworten » | |||||||||||||||||||||||||||||||||||
| beta258 |
2 1 3 x=3 + 6 21 2 7 24 Grad ist doch immer z.B. ^2 oder so und x=3 ist ja konstant. Und 1 , 2 , 3 sind immer die Nummern Schuldige, wenn ich mich so schlecht ausdrücke ):
Warum muss für k also die Nr. extra eingeben werden, dass k+1 wird, außer es enthält kein Grad, obwohl das letzte dann k=3 wäre, oder gilt das erst für das folgende und nicht für das aktuelle(so eine Art Zähler?)
Und wozu dient eigentlich extrra dieses & , etwa um die beiden zu verknüpfen?
Wieso muss da extra double deklariert werden, obwohl das schon bei der Funktion getan wurde Und ist vector nicht double, weswegen man doch nicht extra vector <double> a deklarieren müsste. Schließlich wollte ich noch wissen, ob
|
|||||||||||||||||||||||||||||||||||
| 01.06.2018, 11:21 | Auf diesen Beitrag antworten » | |||||||||||||||||||||||||||||||||||
| as_string |
Zwar schwer lesbar, aber ok.
Grad ist hier 2, richtig, aber x ist ja eigentlich nicht konstant, sondern eben gerade eine Variable, die hier zur Beispiel-Berechnung halt mal den Wert 3 annehmen soll. Letztlich willst Du ja aber das Polynom-Objekt eigentlich zur Berechnung von vielen Funktionswerten des Polynoms verwenden, wenn man das wirklich mal nutzen würde (also z. B. um einen Funktions-Graph des Polynoms zu zeichnen, musst Du ja ganz häufig alle möglichen x-Werte einsetzen, um die y-Werte raus zu bekommen). Nummern? Was für Nummern??? 2, 1 und 3 sind hier die Koeffizienten des Polynoms, also die Vorfaktoren.
vector ist eine generische Klasse, die viele Elemente eines bestimmten Datentyps (nicht nur double, sondern alle möglichen Klassen sind möglich) beinhalten kann. Hier brauchen wir für die Koeffizienten ja eine Liste (also einen Vektor) von double-Werten, deshalb kann man mit vector<double> eine Klasse angeben, die eben einen Vektor liefert, in dem nur double-Werte rein können. Variable a, vom Typ vector<double>, ist eine Member-Variable der Klasse Polynom. dem Konstruktor wird die Übergabe eines Koeffizienten-Vektors definiert (bzw. der Referenz, da ist ja ein Kaufmanns-Und hinten dran!), die direkt in a zugewiesen wird. Und dann gibt es noch in main() einen entsprechenden Vektor in einer lokalen Variable "koeff". In main() wird koeff mit Werten belegt und dieser auf diese Art vorbelegte Vektor wird zur Initialisierung des neuen Objekts Namens p der Klasse Polynom verwendet. Das führt dazu, dass die Member-Variable a des Objekts p die Werte vom koeff-Vektor übernimmt. Du kannst auf diese Art viele Polynome mit unterschiedlichen Koeffizienten definieren, indem Du die Koeffizienten zuerst in einen Vektor schreibst und dann beim Initialisieren des neuen Polynoms übergibst. Dann wird a der unterschiedlichen Polynome auch mit unterschiedlichen Koeffizienten belegt.
Das ist eine Operator-Überladung für die Klammern. Das erst ermöglicht, dass man in Zeile 24 die Ausgabe von p(3) auf diese Art schreiben kann, weil die Klammer hinter p zu diesem Operator aufgelöst wird und dann die für diesen operator definierte Anweisungs-Block ausgeführt wird, nämlich der
Ich denke, hier verstehst Du gar nicht, was überhaupt gemacht wird! p(3) in main() ruft diesen Code auf, deligiert also direkt nach poly mit den entsprechenden Anfangswerten x, 0 und a.size() -1, wobei x dann eben den Wert 3 annimmt und a ist ja mit 3, 1, 2 vorbelegt, also ist a.size() 3 und es wird letztlich poly(3, 0, 2) aufgerufen (entsprechend der ersten Zeile Deiner Musterlösung). In poly gibt es aber einen rekursiven Aufruf, wobei 3 immer weiter gegeben wird, aber k um eins erhöht weiter gegeben wird und grad eins niedriger, also wird aus der 0 (k im zweiten Argument) eine 1 und aus 2 (dem grad im 3. Argument) wird auch eine 1, deshalb hat man (3, 1, 1). Im letzten Aufruf von poly wird dann entsprechend (3,2,0) übergeben. Die einzelnen Aufrufe rechnen genau die Werte aus, die Du oben in Deinem tabellarischen Schema von Hand auch ausgerechnet hast: poly(3,2,0) gibt die 2 zurück, die bei poly(3,1,1) verwendet wird, um in Summe auf die 7 zu kommen, und letztlich wird die 7 dann im Aufruf von poly(3,0,2) verwendet, um in Summe das Endergebnis von 24 auszurechnen. Dabei werden genau die Rechenschritte durchgeführt, die im Horner-Schema auch ausgeführt werden müssen. Überlege Dir mal diese einzelnen Rechenschritte und schau, wie der Ablauf mit dieser Rekursion ist und wie damit genau diese benötigten Rechenschritte auch durchgeführt werden. Gruß Marco |
|||||||||||||||||||||||||||||||||||
| Anzeige | ||||||||||||||||||||||||||||||||||||
|
|
||||||||||||||||||||||||||||||||||||
|
|
Verwandte Themen
| Die Beliebtesten » |
|
| Die Größten » |
| Die Neuesten » |
