klasse wird nicht als typ erkannt - warum?
-
mapfoO schrieb:
super kommentar...du weisst genau wie ich das meine.
wie soll ich eine funktion erstellen die eine rechenoperation ausführt, welche überhaupt nicht definiert ist?
eine potenz lässt sich nicht mithilfe anderer rechenoperationen darstellen.Doch.
int pow(int basis,int expo){ for i=1 to expo result=*basis; }oder
int pow(int basis,int expo){ reurn pow(double(basis),double(expo));//pow(double) sei intrinsic oder als inline-asm definiert }
-
mapfoO schrieb:
super kommentar...du weisst genau wie ich das meine.
Nein, weiss ich aufgrund deines schwammig formulierten Satzes, welcher mir Zweifel an der Ernsthaftigkeit deines Anliegens kommen lässt, eben nicht. Ich habe angenommen, du wüsstest, was eine Potenzfunktion ist und hättest lediglich Probleme mit Funktionen in C++. Drück dich nächstes Mal klarer aus, dann wirst du auch ernst genommen.
-
volkard schrieb:
mapfoO schrieb:
super kommentar...du weisst genau wie ich das meine.
wie soll ich eine funktion erstellen die eine rechenoperation ausführt, welche überhaupt nicht definiert ist?
eine potenz lässt sich nicht mithilfe anderer rechenoperationen darstellen.Doch.
int pow(int basis,int expo){ for i=1 to expo result=*basis; }oder
int pow(int basis,int expo){ reurn pow(double(basis),double(expo));//pow(double) sei intrinsic oder als inline-asm definiert }ok danke. die erste variante verstehe ich nicht und die zweite ist ja einfach nur auf eine bekannte funktion zurückgeführt. das war das ich auch im kopf hatte allerdings wusste ich nicht wie.
nachdem ich herausgefunden habe was casten ist habe ich es jetzt einfach so gemacht, das funktioniert.
@nexus: das anliegen ist mir definitiv ernst^^
-
mapfoO schrieb:
ok danke. die erste variante verstehe ich nicht
Die war auch geschludert und ein wenig mit Basic drin.
Es wäre toll, wenn Du eine erste Variante auch hinkriegen könntest.
Also wie berechne ich als Mensch denn 3^5?
3^1=3//klar.
32=313=9
33=323=27
und so weiter.
Also eine Schleife.
Weil man "hoch 0" auch gerne erlauben will, fängt man an mit
3^0=1
und ab da macht man immer
result=result*3
und zwar so oft, wie der exponent angibt. und am Ende gibt man result zurück.Wenn DU das geschafft hast, ist Nexus auch wieder liebt. :xmas1:
-
haha ok^^
ich denke das habe ich verstanden
#include <iostream> #include <cmath> #include <fstream> using namespace std; ofstream out("test.txt"); class pcoord //ein punkt wird mit den argumenten der x und y koordinaten als class definiert { public: double x; double y; }; pcoord * flocke(pcoord*, int, double, int);//die funktion flocke wird definiert int main() { int rek=0;// die rekursionstiefe int anz=0;// die anzahl der vorgegebenen punkte double p=0.0;// der streckfaktor p cout<< "Willkommen!\nUm Ihre hoechst-eigene Schneeflocke zu erstellen, folgen sie den Anweisungen:\n\n" <<endl; while(1)//schleife zur eingabe der anzahl der punkte; so lange man weniger als 2 punkte angibt gehts nicht weiter { cout<< "Sie muessen mindestens zwei Punkte angeben!" <<endl; cout<< "Geben Sie eine Anzahl von Punkten ein: " <<endl; cin>> anz; if (anz<2) ; else break; } pcoord * B = new pcoord[anz];//das feld B wird deklariert welches alle angegebenen punkte enthaelt for(int i=0; i<anz; i++) { cout<< "Geben Sie die Koordinaten des " << i+1 << ". Punktes an:" <<endl;//die koordinaten der einzelnen punkte werden abgefragt cout<< "X-Koordinate: " <<endl; cin >> B[i].x; cout<< "Y-Koordinate: " <<endl; cin >> B[i].y; } cout<< "Geben Sie den Streckfaktor an: " <<endl;//sreckfaktor und rekursionstife werden abgefragt cin >> p; cout<< "Geben Sie die Rekursionstiefe an: " <<endl; cin >> rek; /*out << B[0].x << "\t" << B[0].y << endl;*/ for(int i=0; i+1<anz; i++)//hier soll die funktion auf die jeweils naechsten punkte angewendet werden und anschliessend auf den letzten und den ersten { pcoord * A = new pcoord[2]; A[0].x = B[i].x; A[0].y = B[i].y; A[1].x = B[i+1].x; A[1].y = B[i+1].y; flocke(A, rek, p, anz); pcoord *ergebnis = new pcoord[(int)(pow(4.0, rek)*(anz-1)+1)]; ergebnis = flocke(A, rek, p, anz); for (int i = 0; i < (int)(pow(4.0, rek)*(anz-1)+1); i++) { out << ergebnis[i].x << "\t" << ergebnis[i].y << endl; } } }//end main pcoord * flocke(pcoord *A, int rek, double p, int anz)//jetzt wird gesagt was in der funktion flocke geschehen soll { if(rek<1)//wenn die rekursionstiefe <=0 ist soll nichts passieren und einfach nur die ursprungspunke ausgegeben werden; { for(int i = 0; i <anz; i++) { out << A[i].x << "\t" << A[i].y << endl; } } else//andernfalls sollen die neuen punkte zwischen den ersten beiden ausgangspunkten berechnet werden: { pcoord *punkte = new pcoord[5];//deklarierung eines neuen punktefeldes in dem die koordinaten der entstehenden punkte stehen punkte[0].x = A[0].x;//der erste punkt bleibt punkte[0].y = A[0].y; punkte[1].x = A[0].x+(A[1].x-A[0].x)/3;//der zweite punkt liegt auf 1/3 der strecke S punkte[1].y = A[0].y+(A[1].y-A[0].y)/3; punkte[2].x = A[0].x+(A[1].x-A[0].x)/2+(A[0].y-A[1].y)*p/3*sqrt((p*p+1)/2)*sin(M_PI/3);//der dritte punkt liegt auf der haelfte der strecke S und ist um die laenge von H nach oben punkte[2].y = A[0].y+(A[1].y-A[0].y)/2+(A[1].x-A[0].x)*p/3*sqrt((p*p+1)/2)*sin(M_PI/3);//verschoben punkte[3].x = A[0].x+(A[1].x-A[0].x)*2/3;//der vierte punkt liegt auf 2/3 der strecke S punkte[3].y = A[0].y+(A[1].y-A[0].y)*2/3; punkte[4].x = A[1].x;//der fuenfte punkt ist der vorherige zweite punkt punkte[4].y = A[1].y; rek=rek-1; if(rek>=1) { for(int i=0; i<4; i++)//wenn die rekursionstiefe groesser als 1 ist fuehrt sich flocke erneut aus ansonsten endet sie hier da bei erneueter ausfuehrung mit rek= 1-1 =0 { // und sie sich so nach zeile 68 beendet A[0].x = punkte[i].x;//der erste punkt A[0] soll nun der erste neu berechnete punkt sein A[0].y = punkte[i].y; A[1].x = punkte[i+1].x;//der zweite punkt soll der zweite neu berechnete punkt sein A[1].y = punkte[i+1].y; flocke(A, rek, p, anz); } } return punkte; /*for(int i = 1; i < 5; i++) { out << punkte[i].x << "\t" << punkte[i].y << endl; }*/ } }mein programm sieht jetzt so aus lässt sich kompilieren und spuckt auch was aus.
er zeichnet mir auch tatsächlich eine flocke, wenn ich die punkte mit der ausgelassenen schleife ab zeile 102 berechne. allerdings "zeichnet er die punkte durch" und ich weiss sogar auch genau warum. anhand eines einfach gewählten beispieles (zb: punk1=(0,0); punkt2=(10,0); p=1; rek =2) und dem erstellten textdokument (am ende hängt er noch 4 punkte dran die da nicht sein sollten) lässt sich auch rel. leicht im zusammenhang mit der schleife feststellen, warum.
mit "return punkte" und der deklarierung der "ergebnis-funktion" funktioniert es bei 2 punkten und rek=1. alles andere spuckt nur wirre ergebnisse aus. ich weiss nicht genau warum. wenn man zb. das genannte beispiel wählt, sieht man, dass die ersten 5 punkte eigentlich die letzten sein müssten(was nach der rekursion auch sinn ergibt). alles was danach kommt macht kein sinn mehr und das kann ich nicht nachvollziehen.wenn da jetzt noch jemand eine idee hat wäre ich überglücklich
denn dann müsste ich so kurz vor dem ziel nicht aufgeben.mfg
-
achja das ergebnisfeld befindet sich in zeile 57 mit der grösse der anzahl der punkte die es am enge gibt (pow(4.0, rek)*(anz-1)+1) das bedeutet diese zahl.
-
gibt es eine funktion die schaut was ausgegeben wird und alles was doppent vorkommt rausschmeisst?
-
mapfoO schrieb:
gibt es eine funktion die schaut was ausgegeben wird und alles was doppent vorkommt rausschmeisst?
Klar:
http://www.cplusplus.com/reference/algorithm/unique/Aber versuch bitte wenigstens erstmal selbst raus zu bekommen, wie man das benutzt, anstatt gleich nach der Benutzung zu fragen.
-
ok das habe ich glaube etwas verstanden und es funktioniert sogar einigermassen.
aber das ist noch nicht exakt das was ich brauche.
ich brauche etwas, das quasi die zeilen des erstellen dokumentes durchgeht (eine zeile besteht aus 2 zahlen) und jede zeile die schon mal gesehen hat entfernt.denn mein programm funktioniert nur sind die doppelten zeilen nicht direkt hintereinander sondern haben einen grösseren abstand.
-
Dürfen die Einträge sortiert werden? Falls ja, mach das mit
std::sort()und wende anschliessendstd::unique()auf die Sequenz an. Alternativ kannst du den Containerstd::set(www.cplusplus.com) verwenden, der sorgt gerade dafür, dass keine Duplikate vorkommen.Falls die Originalreihenfolge beibehalten werden soll, musst du dir selbst was schreiben.
-
ES FUNKTIONIERT!!! YEAAAAAAAAAAAAH!!
das mit dem löschen habe ich noch nicht so richtig hinbekommen aber das hat auch erstmal keine grosse relevanz.
aber vll könnt ihr mir ja trotzdem sagen wie es geht#include <iostream> #include <cmath> #include <fstream> using namespace std; ofstream out("test.txt"); /*template <class ForwardIterator> ForwardIterator unique ( ForwardIterator first, ForwardIterator last ) { ForwardIterator result=first; while (++first != last) { if (!(*result == *first)) // or: if (!pred(*result,*first)) for the pred version *(++result)=*first; } return ++result; }*/ class pcoord //ein punkt wird mit den argumenten der x und y koordinaten als class definiert { public: double x; double y; }; pcoord * flocke(pcoord*, int, double, int);//die funktion flocke wird definiert int main() { int rek=0;// die rekursionstiefe int anz=0;// die anzahl der vorgegebenen punkte double p=0.0;// der streckfaktor p cout<< "Willkommen!\nUm Ihre hoechst-eigene Schneeflocke zu erstellen, folgen sie den Anweisungen:\n\n" <<endl; while(1)//schleife zur eingabe der anzahl der punkte; so lange man weniger als 2 punkte angibt gehts nicht weiter { cout<< "Sie muessen mindestens zwei Punkte angeben!" <<endl; cout<< "Geben Sie eine Anzahl von Punkten ein: " <<endl; cin>> anz; if (anz<2) ; else break; } pcoord * B = new pcoord[anz];//das feld B wird deklariert welches alle angegebenen punkte enthaelt for(int i=0; i<anz; i++) { cout<< "Geben Sie die Koordinaten des " << i+1 << ". Punktes an:" <<endl;//die koordinaten der einzelnen punkte werden abgefragt cout<< "X-Koordinate: " <<endl; cin >> B[i].x; cout<< "Y-Koordinate: " <<endl; cin >> B[i].y; } cout<< "Geben Sie den Streckfaktor an: " <<endl;//sreckfaktor und rekursionstife werden abgefragt cin >> p; cout<< "Geben Sie die Rekursionstiefe an: " <<endl; cin >> rek; for(int i=0; i+1<anz; i++)//hier soll die funktion auf die jeweils naechsten punkte angewendet werden und anschliessend auf den letzten und den ersten { pcoord * A = new pcoord[2]; A[0].x = B[i].x; A[0].y = B[i].y; A[1].x = B[i+1].x; A[1].y = B[i+1].y; flocke(A, rek, p, anz); } }//end main pcoord * flocke(pcoord *A, int rek, double p, int anz)//jetzt wird gesagt was in der funktion flocke geschehen soll { if(rek>0)//wenn die rekursionstiefe <=0 ist soll nichts passieren und einfach nur die ursprungspunke ausgegeben werden; { pcoord *punkte = new pcoord[5];//deklarierung eines neuen punktefeldes in dem die koordinaten der entstehenden punkte stehen punkte[0].x = A[0].x;//der erste punkt bleibt punkte[0].y = A[0].y; punkte[1].x = A[0].x+(A[1].x-A[0].x)/3;//der zweite punkt liegt auf 1/3 der strecke S punkte[1].y = A[0].y+(A[1].y-A[0].y)/3; punkte[2].x = A[0].x+(A[1].x-A[0].x)/2+(A[0].y-A[1].y)*p/3*sin(M_PI/3);//der dritte punkt liegt auf der haelfte der strecke S und ist um die laenge von H nach oben punkte[2].y = A[0].y+(A[1].y-A[0].y)/2+(A[1].x-A[0].x)*p/3*sin(M_PI/3);//verschoben punkte[3].x = A[0].x+(A[1].x-A[0].x)*2/3;//der vierte punkt liegt auf 2/3 der strecke S punkte[3].y = A[0].y+(A[1].y-A[0].y)*2/3; punkte[4].x = A[1].x;//der fuenfte punkt ist der vorherige zweite punkt punkte[4].y = A[1].y; rek=rek-1; if(rek>0) { for(int i=0; i<4; i++)//wenn die rekursionstiefe groesser als 1 ist fuehrt sich flocke erneut aus ansonsten endet sie hier da bei erneueter ausfuehrung mit rek= 1-1 =0 { // und sie sich so nach zeile 68 beendet A[0].x = punkte[i].x;//der erste punkt A[0] soll nun der erste neu berechnete punkt sein A[0].y = punkte[i].y; A[1].x = punkte[i+1].x;//der zweite punkt soll der zweite neu berechnete punkt sein A[1].y = punkte[i+1].y; flocke(A, rek, p, anz); } } else { for(int i = 0; i < 5; i++) { out << punkte[i].x << "\t" << punkte[i].y << endl; } } } }
-
mapfoO schrieb:
das mit dem löschen habe ich noch nicht so richtig hinbekommen aber das hat auch erstmal keine grosse relevanz.
aber vll könnt ihr mir ja trotzdem sagen wie es gehtGerne, aber dazu musst du konkretere Fragen stellen. Und wenn möglich nur relevanten, kurzen Code.
-
YES!
ich brauche es gar nicht mehr danke
es funktioniet jetzt auch so. es wird kein punkt mehr doppelt ausgegeben. aber um ehrlich zu sein weiss ich nicht genau warum, denn eigenltich habe ich nichts anders gemacht^^#include <iostream>//ich packe meinen koffer und secke ein: alle bibliotheken die ich brauche ;) #include <cmath> #include <fstream> using namespace std; ofstream out("flocke.txt");//hier wird der pfad der datei, ihr name und das format festgelegt class pcoord //ein punkt wird mit den argumenten der x und y koordinaten als class definiert { public: double x; double y; }; pcoord * flocke(pcoord*, int, double, int);//die funktion flocke wird definiert int main() { int rek=0;// die rekursionstiefe int anz=0;// die anzahl der vorgegebenen punkte double p=0.0;// der streckfaktor p cout<< "Willkommen!\nUm Ihre hoechst-eigene Schneeflocke zu erstellen, folgen sie den Anweisungen:\n\n" <<endl; while(1)//schleife zur eingabe der anzahl der punkte; so lange man weniger als 2 punkte angibt gehts nicht weiter { cout<< "Sie muessen mindestens zwei Punkte angeben!" <<endl; cout<< "Geben Sie eine Anzahl von Punkten ein: " <<endl; cin>> anz; if (anz<2) ; else break; } pcoord * B = new pcoord[anz];//das feld B wird deklariert welches alle angegebenen punkte enthaelt for(int i=0; i<anz; i++) { cout<< "Geben Sie die Koordinaten des " << i+1 << ". Punktes an:" <<endl;//die koordinaten der einzelnen punkte werden abgefragt cout<< "X-Koordinate: " <<endl; cin >> B[i].x; cout<< "Y-Koordinate: " <<endl; cin >> B[i].y; } cout<< "Geben Sie den Streckfaktor an: " <<endl;//streckfaktor und rekursionstife werden abgefragt cin >> p; cout<< "Geben Sie die Rekursionstiefe an: " <<endl; cin >> rek; out << B[0].x << "\t" << B[0].y << endl;//der erste punkt soll ausgegeben werden, da er aus mir unerklärlichen gründen wegfaellt for(int i=0; i+1<anz; i++)//hier soll die funktion auf die jeweils aufeinanderfolgenden punkte angewendet werden. also zunaechst auf den ersten und { //und zweiten, dann aud denn zweiten und dritten usw... pcoord * A = new pcoord[2];//ein punktefeld mit 2 elementen wird erstellt, da die funktion nur auf 2 punkte anwendbar ist A[0].x = B[i].x;//nach der reihe werden dann die angegebenen punkte durchgegangen A[0].y = B[i].y; A[1].x = B[i+1].x; A[1].y = B[i+1].y; flocke(A, rek, p, anz); delete[] A;//der benutzte speicher wird gelöscht } delete[] B;//der benutzte speicher wird gelöscht }//hier endet die main pcoord * flocke(pcoord *A, int rek, double p, int anz)//jetzt wird gesagt was in der funktion flocke geschehen soll { if(rek>0)//wenn die rekursionstiefe >0 ist sollen die neu-entstehenden punkte berechnet werdern. dies ist auch gleichzeitig die abbbruchbedingung { //für die funktion pcoord *punkte = new pcoord[5];//deklarierung eines neuen punktefeldes in dem die koordinaten der entstehenden punkte stehen punkte[0].x = A[0].x;//der erste punkt bleibt punkte[0].y = A[0].y; punkte[1].x = A[0].x+(A[1].x-A[0].x)/3;//der zweite punkt liegt auf 1/3 der strecke S punkte[1].y = A[0].y+(A[1].y-A[0].y)/3; punkte[2].x = A[0].x+(A[1].x-A[0].x)/2+(A[0].y-A[1].y)*p/3*sin(M_PI/3);//der dritte punkt liegt auf der haelfte der strecke S und ist um die laenge von h nach oben punkte[2].y = A[0].y+(A[1].y-A[0].y)/2+(A[1].x-A[0].x)*p/3*sin(M_PI/3);//verschoben punkte[3].x = A[0].x+(A[1].x-A[0].x)*2/3;//der vierte punkt liegt auf 2/3 der strecke S punkte[3].y = A[0].y+(A[1].y-A[0].y)*2/3; punkte[4].x = A[1].x;//der fuenfte punkt ist der vorherige zweite punkt punkte[4].y = A[1].y; rek=rek-1;//die rekursionstiefewird um 1 erniedrigt, damit sich flocke nur bis zu einem bestimmten grad wieder neu ausführt if(rek>0)//wenn die rekursionstiefe immernoch groesser als 1 ist fuehrt sich flocke erneut aus ansonsten endet die rekursion hier { for(int i=0; i<4; i++)//die funktion flocke soll sich nun auf die 4 neu entstandenen strecken ausführen { A[0].x = punkte[i].x;//der erste punkt A[0] soll nun der erste neu berechnete punkt sein A[0].y = punkte[i].y; A[1].x = punkte[i+1].x;//der zweite punkt soll der zweite neu berechnete punkt sein A[1].y = punkte[i+1].y; flocke(A, rek, p, anz); } } else//wenn die rekursionstiefe 0 ist werden die koordinaten der neu berechneten punkte ausgegeben { for(int i = 1; i < 5; i++) { out << punkte[i].x << "\t" << punkte[i].y << endl; } } delete[] punkte;//der benutzte speicher wird gelöscht } }naja wer sich mal ne flocke erstellen möchte...nur zu
