klasse wird nicht als typ erkannt - warum?

[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.

[mapfoO]

wie berechne ich pow(int, int)?

[SeppJ]

mapfoO schrieb:

wie berechne ich pow(int, int)?

Das musst du dir selber programmieren oder casten.

Der Grund, warum das nicht im Standard enthalten ist, ist glaube ich, dass das Ergebnis einer solchen Funktion zu oft zu einem Überlauf führen würde.

[mapfoO]

also muss ich mir eine eigene funktion bauen?
wie soll das gehen?

[Nexus]

mapfoO schrieb:

also muss ich mir eine eigene funktion bauen?
wie soll das gehen?

Du weisst doch hoffentlich, wie man eine Funktion in C++ schreibt, oder? Ansonsten solltest du nochmals hinter die Bücher.

[mapfoO]

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.

[volkard]

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
}

[Nexus]

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.

[mapfoO]

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^^