klasse wird nicht als typ erkannt - warum?

[mapfoO]

noch macht er ja gar nichts
von daher ja er macht nicht was ich will.

ich will die punkte plotten und das geht nicht wenn ich ihre koordinaten nicht irgendwie abspeichere. ich weiss aber nicht wie das geht.

ich mein klar:

ofstream ausgabe("..../daten.txt"); zb oder so
aber das reicht ja noch nicht es wird ja noch gar nicht gesagt WAS in die datei geschrieben werden soll. und das ist auch meine frage.

[drakon]

Och.. viel fehlt da nicht mehr.

int number = 2;
std::string text = "hmm";

std::ofstream out ("file.txt");
out << number << "\n";
out << text;

Aber das steht auch in den genannten Links.

Das mit dem plotten verstehe ich nicht ganz. Du hast die Daten ja intern, dann kannst du das doch auch plotten. (oder machst du das mit einem anderen Programm?)

[mapfoO]

aber was bedeutet das konkret für mein programm?
wo muss ich das hinschreiben? in die funktion?
in die rekursionsschleife?
und was wäre "number" in meinem fall?

ich weiss es wirklich nicht^^

ja ich soll das als dokument ausgeben damit es mit gnuplot geplottet werden kann.

[drakon]

Das sollest doch du wissen?!

Was willst du in dem File haben? Und wo wird das in deinem Programm berechnet? Jetzt kannst du mal raten, wo du etwas ins File ausgeben kannst.. Frühestesn dort, wo dus berechnet hast.. Vielleicht aber erst später, wenn du z.B die Daten noch sortieren musst oder was auch immer.

Da solltest du einfach mal ein wenig drüber nachdenken..

[mapfoO]

ich denke schon die ganze verdammte woche..und freitag muss das fertig sein. viel zeit habe ich also nicht mehr. und wie du schon gemerkt hast bin ich totaler anfänger. ich habe noch NIE vorher programmiert das is mein erstes programm. woher soll ich das denn alles wissen wenn ich es nicht erfrage?

es ist ja nicht so als ob ich nicht rumprobieren würde aber es klappt eben nicht.

[drakon]

Klar. Ich kann verstehen, dass es schwer für dich ist, aber grundsätzlich kannst du dich ja wirklich fragen, wo die Daten berechnet werden und dann da eine Ausgabe machen.
(ggf. Das file vorher öffnen und nicht jedes mal öffnen und schreiben)

[mapfoO]

http://img248.imageshack.us/img248/3579/bild1xy.jpg
http://img228.imageshack.us/img228/1651/bild2z.jpg

so jetzt weisst du genau was das programm machen soll und so sieht es zur zeit aus:

#include <iostream>
#include <cmath>
#include <fstream>
#include <vector>

using namespace std;

ofstream out(".../test.txt");

class pcoord
{
	public:
	double x;
	double y;
};

pcoord * flocke(std::vector<pcoord>&, int, double);
int main()
{
	int rek;
	int anz;
	double p;
    while(1)
    {
              cout<< "Sie müssen mindestens zwei Punkte angeben!" <<endl;
   	          cout<< "Geben Sie eine Anzahl von Punkten ein: " <<endl;
   	          cin>>anz;
   	          if (anz<2)
   	              ;
              else
                  break;
    } 
    std::vector<pcoord> A(anz);       
    for(int i=0; i<anz; i++)
    {
            cout<< "Geben Sie die Koordinaten des " << i+1 << ". Punktes an:" <<endl;
            cout<< "X-Koordinate: " <<endl;
            cin >> A[i].x;
            cout<< "Y-Koordinate: " <<endl;
            cin >> A[i].y;
    }
cout<< "Geben Sie den Streckfaktor an: " <<endl;
cin >> p;
cout<< "Geben Sie die Rekursionstiefe an: " <<endl;
cin >> rek;
for(int i=0; i<anz; i++)
        {
                A[0].x = A[i].x;
                A[0].y = A[i].y;
                A[1].x = A[i+1].x;
                A[1].y = A[i+1].y;
                flocke(A, rek, p);
        }
}
pcoord * flocke(std::vector<pcoord>& A, int rek, double p)
{       
        double BetrS = sqrt(A[1].x*A[1].x - 2*A[0].x*A[1].x + A[0].x*A[0].x + A[1].y*A[1].y - 2*A[0].y*A[1].y + A[0].y*A[0].y);
        double BetrH = sqrt(A[1].y*A[1].y - 2*A[0].y*A[1].y + A[0].y*A[0].y + A[0].x*A[0].x - 2*A[0].x*A[1].x + A[1].x*A[1].x);
        std::vector<pcoord> punkte(5);
        punkte[0].x = A[0].x;
        punkte[0].y = A[0].y;
        punkte[1].x = (A[1].x-A[0].x)/3+A[0].x;
        punkte[1].y = (A[1].y-A[0].y)/3+A[0].x;
        punkte[2].x = (A[1].x-A[0].x)/2+(A[1].y-A[0].y)*p*BetrS/BetrH*sqrt((p*p+1)/2)*sin(60)+A[0].x;
        punkte[2].y = (A[1].y-A[0].y)/2+(A[0].x-A[1].x)*p*BetrS/BetrH*sqrt((p*p+1)/2)*sin(60)+A[0].y;
        punkte[3].x = (A[1].x-A[0].x)*2/3+A[0].x;
        punkte[3].y = (A[1].y-A[0].y)*2/3+A[0].y;
        punkte[4].x = A[1].x;
        punkte[4].y = A[1].y;			

        for(int i=0; i<4; i++)
        {
                A[0].x = punkte[i].x;
                A[0].y = punkte[i].y;
                A[1].x = punkte[i+1].x;
                A[1].y = punkte[i+1].y;
                flocke(A, rek-1, p);
                if(rek==0)
                          break;
        }
        out << punkte << "\n";
}

aber die rekursion ist nicht richtig weil ich nichts mit dem rückgabewert mache. und das mit dem "out.." funktioniert sowieso nicht. ich weiss nicht weiter

[SeppJ]

mapfoO schrieb:

es ist ja nicht so als ob ich nicht rumprobieren würde aber es klappt eben nicht.

Das ist (wie ich schon oben gesagt habe) genau das Problem. Einfach mal rumprobieren bis etwas compiliert funktioniert nicht. Da kommt IMMER Mist bei raus. Du musst mal gründlich darüber nachdenken wie dein Programm ablaufen soll, dann klappt das auch mit der Umsetzung.

Da wir aber natürlich nicht genau wissen, wie dein Programm ablaufen soll, können wir nur rein technische Hilfestellungen geben.

edit: Ich sehe, dass du inzwischen die genauen Spezifikationen deines Programms genannt hast.

Deine Flocke Funktion ist ziemlich unübersichtlich, aber wenn ich mir das richtig zusammenreime, ist deine Funktion ziemlich falsch, da die berechneten Daten einfach im Nichts verschwinden. Du solltest dir mal Gedanken darüber machen, was dein A machen soll und was es tatsächlich macht. Wenn du sprechendere Variablennamen als 'A' verwenden würdest, hätte sich dieses Problem vermutlich gar nicht erst ergeben.

edit2: Es ist übrigens sehr gut möglich, dass sich die Übungsgruppenleiter zu einer solchen Übung in diesem Forum herumtreiben.

[drakon]

so jetzt weisst du genau was das programm machen soll und so sieht es zur zeit aus:

Öhmm. Nein weiss ich nicht. Ich sehe nur ein Haufen Code, der nirgends erklärt wird. Aber ich muss den Code ja nicht verstehen, um dir zu helfen.

Wo ist denn jetzt noch genau dein Problem? Ich sehe, dass du ofstream eingebaut hast und ich denke, dass das schon korrekt sein kann. Kommt halt drauf an, was du willst.

Das Problem im Moment ist bestimmt, dass du keinen std::vector einfach so ausgeben kannst, ohne zu sagen, wie das geschen soll. Also diese Zeile hier wird einen Compile Fehler erzeugen:

out << punkte << "\n";

Sprich du solltest wohl besser eine Funktion schreiben, die das ausgeben eines vectors übernimmt. Dann gibst du da einfach jeden einzelnen Wert aus, wie du möchtest.

[mapfoO]

ja und ich weiss ja gar nicht wie man mit einem vektor umgeht ich wollte das ja gar nicht so machen...

mir wurde gesagt ich darf mir durchaus hilfe von anderen leuten holen und fragen wie die es machen bzw machen würden. ich erstelle ja kein plagiat oder soetwas.

@drakon: ja ich weiss doch wo die daten berechnet werden. in der funktion und speziell in der forschleife für die rekursion in der fuktion. aber ich habe keinen schimmer wie ich da jetzt die ausgabe reinbauen soll vor allem wenn es um vektoren geht von denen ich sowieso nicht weiss was sie sind.

verstet denn überhaupt jemand mein programm?

[drakon]

Das Problem liegt ja nicht an deinem Programm nehme ich an. Das sollte ja gehen.

Für std::vector kannst du hier schauen:
http://www.cplusplus.com/reference/stl/vector/

Da hats afaik zu jeder Funktion ein komplettes Beispielprogramm. Hier eine kleine Einführung:

#include <iostream>
#include <vector>

int main ()
{
  std::vector<int> v; // erstellen, v ist leer, enthält also keine elemente
  v.push_back ( 2 ); // 2 einfügen
  v.push_back ( 5 ); // 5 einfügen

  v[1] = 222; // zweites Element, also die 5 mit 222 überschreiben

  std::vector<int>::iterator end = v.end (); // end iterator holen
  for (std::vector<int>::iterator it = v.begin (); // begin iterator holen
        it != end; ++it)
  {
    std::cout << *it << "\n"; //ausgabe von jedem element nacheinander
  }
}

Das sollte eigentlich für ein Programm reichen. Beachte, dass du nicht ausserhalb von den Grenzen zugreifen kannst. (in dem obigen Beispiel gehen die von 0 bis 1, da ja nur 2 Elemente enthalten sind.
Ich weiss nicht, ob du Iteratoren schon kennst, die kannst du dir aber so in etwa wie einen Zeiger in einem Array vorstellen. Wo du in einem Array einen Zeiger hast, hast du in einem std::vector einen Iterator. Und du kannst dir einen solchen Zeiger auf den Anfang mit ::begin holen und auf das Ende mit ::end().

Ich hoffe, dass dir das in etwa hilft.
Lies aber auf jeden Fall zumindest für diese paar Funktionen die Beiträge in der Referenz durch und schau dir die Beispiele dort an. vector ist prinzipiell ganz einfach zu benutzen und bieten weit mehr komfort, als native Arrays.

[uhsuhz]

Schaut mal die Bedingungen, es wird verlangt dass er sich selber um das Speichermanagment kümmert, Vectoren sind also nicht erlaubt, dann muss er es mit Arrays lösen, er muss selber Speicher anfordern und wieder freigeben, außerdem kontrollieren sie ob alles von ihm kommt...

[drakon]

uhsuhz schrieb:

Schaut mal die Bedingungen, es wird verlangt dass er sich selber um das Speichermanagment kümmert, Vectoren sind also nicht erlaubt, dann muss er es mit Arrays lösen, er muss selber Speicher anfordern und wieder freigeben, außerdem kontrollieren sie ob alles von ihm kommt...

Was für Bedingungen, wo?

[uhsuhz]

http://img248.imageshack.us/img248/3579/bild1xy.jpg
http://img228.imageshack.us/img228/1651/bild2z.jpg

Bild 1 ist Aufgabe
Bild 2 ist Bedingungen

[drakon]

Achos.. das habe ich wohl übersehen. Dachte, dass das Ausgaben sind, welche er gemacht hat.

Naja.. Ich finde die Aufgabe komisch gestellt. Warum sollten die in der Physik nicht die Programmmitel benutzen, welche gegeben sind?! Der Sinn der Aufgabe ist, wie ich das sehe ja nicht unbedingt die Implementierung von einer Datenstruktur.. -.-

Naja. Dann muss er das halt auch noch von Hand machen..

[SeppJ]

drakon schrieb:

Achos.. das habe ich wohl übersehen. Dachte, dass das Ausgaben sind, welche er gemacht hat.

Naja.. Ich finde die Aufgabe komisch gestellt. Warum sollten die in der Physik nicht die Programmmitel benutzen, welche gegeben sind?! Der Sinn der Aufgabe ist, wie ich das sehe ja nicht unbedingt die Implementierung von einer Datenstruktur.. -.-

Ich glaube, dass ist ein typischer Fall von: Aufgabensteller weiß gar nicht, dass es auch anders geht. Der will wahrscheinlich nur nicht, dass man ein statisches Array mit 999999 Elementen reserviert und hofft, dass die reicht.

Naja. Dann muss er das halt auch noch von Hand machen..

Oha, und das bis Freitag. Klingt nach einer langen Nacht...

[mapfoO]

#include <iostream>
#include <cmath>
#include <fstream>

using namespace std;

ofstream out("E:/Neuer Ordner (2)/Marius/UNI/Computer/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);//die funktion flocke wird definiert

int main(int argc, char * const argv[])
{
	int rek=0;// die rekursionstiefe
	int anz=0;// die anzahl der vorgegebenen punkte
	double p=0.0;// der streckfaktor p

    while(1)//schleife zur eingabe der anzahl der punkte; so lange man weniger als 2 punkte angibt gehts nicht weiter
    {
          cout<< "Sie müssen 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 enthält       
    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;
    for(int i=0; i<anz; i++)//hier soll die funktion auf die jeweils nächsten punkte angewendet werden und anschließend auf den letzten und den ersten
    {                       //ich bin mir nicht sicher ob das so geht allerdings konnte ich es auch nie testen..
          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[0], rek, p);
    }
    pcoord * A = new pcoord[2];
    A[0].x = B[anz-1].x;
    A[0].y = B[anz-1].y;
    A[1].x = B[0].x;
    A[1].y = B[0].y;
    flocke(A[0], rek, p);
}//end main 

pcoord * flocke(pcoord A[0], int rek, double p)//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;
        {
                 return A;//wie das mit dem ausgeben geht weiss ich allerdings nicht wirklich
        }
        else//andernfalls sollen die neuen punkte zwischen den ersten beiden ausgangspunkten berechnet werden:
        {    
                double BetrS = sqrt(A[1].x*A[1].x - 2*A[0].x*A[1].x + A[0].x*A[0].x + A[1].y*A[1].y - 2*A[0].y*A[1].y + A[0].y*A[0].y);//berechnung der länge |S| zwischen zwei punkten
                double BetrH = sqrt(A[1].y*A[1].y - 2*A[0].y*A[1].y + A[0].y*A[0].y + A[0].x*A[0].x - 2*A[0].x*A[1].x + A[1].x*A[1].x);//berechnung der länge |H| eines senkrecht auf S stehenden vektors

                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[1].x-A[0].x)/3+A[0].x;//der zweite punkt liegt auf 1/3 der strecke S
                punkte[1].y = (A[1].y-A[0].y)/3+A[0].x;
                punkte[2].x = (A[1].x-A[0].x)/2+(A[1].y-A[0].y)*p*BetrS/(BetrH*3)*sqrt((p*p+1)/2)*sin(60)+A[0].x;//der dritte punkt liegt auf der hälfte der strecke S und ist um die länge von H nach oben 
                punkte[2].y = (A[1].y-A[0].y)/2+(A[0].x-A[1].x)*p*BetrS/(BetrH*3)*sqrt((p*p+1)/2)*sin(60)+A[0].y;//verschoben
                punkte[3].x = (A[1].x-A[0].x)*2/3+A[0].x;//der vierte punkt liegt auf 2/3 der strecke S
                punkte[3].y = (A[1].y-A[0].y)*2/3+A[0].y;
                punkte[4].x = A[1].x;//der fünfte punkt ist der vorherige zweite punkt
                punkte[4].y = A[1].y;

        	    return punkte;//die punkte sollen ausgegeben werden so klappt es wahrscheinlich nicht

                for(int i=0; i<4; i++)//wenn die rekursionstiefe grösser als 1 ist führt sich flocke erneut aus ansonsten endet sie hier da bei erneueter ausführung mit rek= 1-1 =0
                {                     // und sie sich so nach zeile 66 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[0], rek-1, p);
                }
        }
}

so sieht es jetzt aus und das sind die einzigen fehlermeldungen die ich noch habe:

[Linker error] undefined reference to flocke(pcoord, int, double)' [Linker error] undefined reference toflocke(pcoord, int, double)'
ld returned 1 exit status

[SeppJ]

Deine Funktionssignaturen für flocke passen allesamt nicht zusammen.

[mapfoO]

was sind funktionssignaturen?

[drakon]

Das ist die Funktionsdeklaration. Also wie die Funktion heisst, welche Parameter sie übernimmt und von welchen Typen die sind.