also meine Frage ist wie ich in Schleifen zählen kann wie oft sie durchgelaufen ist ich weis das es da was gab aber ich weis nicht mehr was. Und dann noch wie man zählen kann wie hoch die anzahl der geschriebenen werte ist. Hier der Code ich markier die stelle und schreib nen Kommentar.

#include <math.h>
#include <fstream>
#include <iostream> 
#include <string>
#include<vector>
#define sqr(x) ((x)*(x))
#define sin_d(x) (sin((x)*M_PI/180))
#define cos_d(x) (cos((x)*M_PI/180))
#define tan_d(x) (tan((x)*M_PI/180))
#define asin_d(x) (asin(x)*180/M_PI)
#define acos_d(x) (acos(x)*180/M_PI)
#define atan_d(x) (atan(x)*180/M_PI)
using namespace std;

int main()
{
  int x;
  int y;
  double r = 1.0;

    std::ofstream myFile;
    myFile.open ("c:/ErstellteKugel.vtk");
    myFile << "# vtk DataFile Version 2.0\n" << "Kugel example\n" << "ASCII\n" << "DATASET POLYDATA\n";
    myFile << "POINTS 308 float\n";   

    myFile << "0.000000 " << "0.000000 " << "1.000000\n";
    for( int phi = 10; phi < 180; phi += 10 )  // bei dieser schleife wie krieg ich raus das sie 308 mal durchläuft
    {
        for( int theta = 0; theta < 360; theta += 20 )
        {
            double x = r * cos_d(theta) * sin_d(phi);
             myFile << x <<" ";
            double y = r * sin_d(theta) * sin_d(phi);
             myFile << y << " ";
            double z = r * cos_d(phi);
             myFile << z << "\n";
        }
    }
      myFile << "0.000000 " << "0.000000 " << "-1.000000\n"; 
      myFile << "POLYGONS 612 2448\n";              

    for(x=1; x<= 17; x++)
    {                   
            myFile << 3 << " " << 0 << " " << x << " " <<  x + 1 << "\n";
    }
            myFile << 3 << " " << 0 << " " << 18 << " " << 1 << "\n";       

    for(x=1, y=19; x<=17&&y<=36; x++, y++)
    {
            myFile << 3 << " " << x << " " << y << " " << y + 1 << std::endl << 3 << " " << x << " " << x + 1 << " " << y + 1 << std::endl; 
    }

            myFile << 3 << " " << 18 << " " << 1 << " " << 19 << "\n";
            myFile << 3 << " " << 18 << " " << 36 << " " << 19 << "\n"; 

    for(x=19, y=36; x<=288&&y<=304; x++, y++)
    {
            myFile << 3 << " " << x << " " << y << " " << y + 1 << std::endl << 3 << " " << x << " " << x + 1 << " " << y + 1 << std::endl;

    }

            myFile << 3 << " " << 288 << " " << 305 << " " << 306 << "\n";
            myFile << 3 << " " << 288 << " " << 289 << " " << 306 << "\n";

    for(x=290, y=291; x<=305&&y<=306; x++, y++)
    {
         myFile << 3 << " " << 307 << " " << x << " " << y << "\n";

    }

    myFile << 3 << " " << 307 << " " << 289 << " " << 290 << "\n";
    myFile << 3 << " " << 307 << " " << 306 << " " << 289;

}

Danke schonmal

Wie war doch gleich die Frage?!

Aber ich würde gern wissen wie die Funktion geht also die zählt wie oft die Schleife durchläuft das die Frage.

@ Braunstein: Das sieht ja schon vielversprechend aus danke.

also ich solls so machen das spricht dagegen und das programm soll flexibel sein also ich muss die schritte verändern können und dann doch schnell wieder die anzahl bekommen. Deswegen ist es mit der Größen angabe sinvoller.

aber ich habs noch ned hinbekommen von nem Vektor schon aber ned von der schleife wenn ichs so mach wie oben krieg ich fehler.

aber ich habs noch ned hinbekommen von nem Vektor schon aber ned von der schleife wenn ichs so mach wie oben krieg ich fehler.

Naja, schade. Aber das wird schon noch.

mit counter ist mir klar aber das size blick ich nicht durch vorallem wenn man danach sucht gibts so viele treffer.

das size_t versteh ich nicht !!!

Wenn man über allozierte Felder iteriert, muß man immer size_t nehmen, da nur so garantiert ist, daß auch alle Elemente durchlaufen werden.
Es gilt z.B. auf einem 64Bit UNIX sizeof(int) == 4 und sizeof(size_t) == 8.
Im konkreten Fall ist es egal, aber als Stilübung ist es besser sich das zu merken.

danke.

Ich glaub ich hab jetzt ne Möglichkeit es besser zu beschreiben. Es gibt ne möglichkeit sich den Belegten Speicher anzeigen zu lassen der von der schleife verwendet wird. Das wär auch wichtig für mich.

könnte ich nicht den inhalt der schleife als vektor machen? und das kann ich mir dann anzeigen lasse wie viel es ist ? das weis ich dann wies geht

aber wie oft sie durchläuft weis ich immernoch nicht wie die funktion heist glaub was mit size aber des mit einen Zähler einbauen so soll ichs nicht machen naja.

Wenn wer die funktion weis wer ich ihm sehr verbunden.

aber wie oft sie durchläuft weis ich immernoch nicht wie die funktion heist glaub was mit size aber des mit einen Zähler einbauen so soll ichs nicht machen naja.

waszumgeierwillstdukennstdupunktundkommasowiegrossundkleinschreibungodernichtnaja?

In Ernst: Was für eine Funktion sollte es geben, um die Durchläufe einer Schleife zu zählen? Lass einen Zähler mitlaufen, wenn das Schleifenende unbestimmt ist, ansonsten rechne es aus. Es gibt keine "funktion glaub irgendwas mit size", die "Schleifendurchläufe" "zählt".

Mag jetzt an mir liegen, aber geht die schleife nicht maximal 17 mal?

Und selbst wenn verstehe ich das problem mit dem mitzählen nicht. was soll denn daran so schlimm sein?

Ok dann gibts das nicht.

Aber ich kann doch sicher auslesen, dass die Schleife 308 werte drin stehen hat? Ohne es auszurechen, in dem ich den Speicher oder so abfrage?

Und mir dann den Wert 308 ausgeben lasse weil die Schleife 308 Werte drin stehen hat, geht das?

int counter =0;
for( int phi = 10; phi < 180; phi += 10 )  // bei dieser schleife wie krieg ich raus das sie 308 mal durchläuft
    {
        for( int theta = 0; theta < 360; theta += 20 )
        {
            double x = r * cos_d(theta) * sin_d(phi);
             myFile << x <<" ";
            double y = r * sin_d(theta) * sin_d(phi);
             myFile << y << " ";
            double z = r * cos_d(phi);
             myFile << z << "\n";
           counter ++;  
        }

    }

cout << "Schleifeiterationen: " << counter << " "  ;
system("pause");

Da kommt jetzt 306 raus was richtig ist, da es 306 Punkte sind. Die beiden Letzten Punkte sind ganz oben und ganz unten zum eintragen. Damit hab ich meine 308.

Was die 308 betrifft meinte ich ja das sie 306 mal durchläuft und immer 3 Werte reinschreibt. Und die letzten 2 Werte schreib ich dann manuell rein.

Und man kann das echt nicht anderster rauskriegen die 306?

...die letzten 2 Werte schreib ich dann Manuel rein....

Was kann der arme Manuel denn dafür ?

Gruß,

Simon2.

Und man kann das echt nicht anderster rauskriegen die 306?

Nunja, dir wurden bisher zwei Moeglichkeiten genannt:

a) Zehler mitlaufen lassen, dann weisst dus hinterher.
b) Wenn alle Bedingungen vorher bekannt sind (wie in deinem Fall hier), einfach ausrechnen wie oft die Schleife durchaufen wird. In deinem Fall sinds geschachtelte Zaehlschleifen, die Zaehlvariable wird nicht geaendert, also ist die jeweilige Anzahl der Durchlaeufe nur abhaengig vom Startwert, Endwert und der Schrittweite. Die Rechnung dazu ist folgene:

int min, max, step; //startwert, endwert, schrittweite
int nloop = (max - min - 1)/step + 1;
if (nloop < 1) nloop = 1;

Die letzte Abfrage tritt nur in Kraft, wenn max < min ist, sonst wuerden da negative Werte rauskommen, was nicht gut moeglich ist. Die Schleife wird schliesslich mindestens einmal durchlaufen.
Jetzt berechnet man nloop fuer die innere und aeussere Schleife und mitlipliziert das ganze miteinander. Spezialisiert auf deinen Fall, wo ja nur die Schrittweite fuer phi und theta veraenderbar sind, kommt dann folgendes bei raus:

int step_phi, step_theta;
int nloop, nloop_phi, nloop_theta;
step_phi = /*20*/;
step_theta = /*10*/;

nloop_phi = 359/step_phi + 1; // = 17 + 1 = 18
nloop_theta = (179-step_theta)/step_theta + 1; // = 16 + 1 = 17
nloop = nloop_theta + nloop_phi; // = 17 * 18 = 306

//deine Schleife:
for( int theta = step_theta; theta < 180; theta += step_theta )  
    {
        for( int phi = 0; phi < 360; phi += ste_phi )
        {
        //...
        }
    }

Ich hab mir mal die Freiheit rausgenommen, die Kugelkoordinaten theta und phi so zu benutzen wie sie normalerweise benutzt werden, wie ich oben schon geschrieben hatte hast du das vertauscht

Verscuh meinen Fetzen mal mit anderen Werten fuer step_theta und step_phi, du wirst sehn dass genau die richtige Zahl an loops bei rauskommt, wenn du den counter noch drinlaesst.

Ok das probier ich aus! Aber wenigstens ists mir beim lesen jetzt schon klar.

Du hast dich da verschrieben

nloop = nloop_theta + nloop_phi; // = 17 * 18 = 306

ist * nicht +

double x = radius * cos(theta) * sin(phi);

double y = radius * sin(theta) * sin(phi);

double z = radius * cos(phi);

bzw.

x = r * cos_d(0) * sin_d(180);

y = r * sin_d(0) * sin_d(180);

z = r * cos_d(180);

muss ich dann die werte in den Klammern tauschen?
dann kommen aber andere ergebnisse raus die dann keien Kugel mehr ergeben bzw. ein Punkt ist anders.

$z = r \cos(\vartheta)\qquad y = r \sin(\vartheta)\sin(\varphi)\qquad x = r \sin(\vartheta)\cos(\varphi)$