nur 1 Variable für 2 ähnliche Berechnungen verwenden



  • Du hast Funktionen noch nicht verstanden.

    inline double degtorad(double grad) { // Grad in Bogenmass umrechnen
    
        return  grad / 180.0 * 3.141592653589793238;
    }
    
    inline double radtodeg(double rad) { // Grad in Bogenmass umrechnen
    
        return  rad * 180.0 / 3.141592653589793238;
    }
    

    Der Aufruf geht dann z.B. mit

    sin(degtorad(Winkel_in_Grad))
    

    --------
    Du hast eine weitere Funktion

    int BerechneDach(Walmdach &Dach, int mitUeberstand)  // Baachte die Referenz
    { 
      Dach.mitUeberstand = mitUeberstand;
      Dach.DL[0] = (Dach.TL[1]+(Dach.DU[0]+Dach.DU[2])*Dach.mitUeberstand) * sin(Dach.DN[2] / sin 
    (Dach.SW);
    ....
    
    return 0;  // alles in Ordnung
    

    Ich beziehe mich jetzt auf deine structs von 15:56:06 20.12.2016:
    Der Aufruf erfolgt dann mit

    BerechneDach(ohneDachueberstand,0);
    //bzw.
      BerechneDach(mitDachueberstand,1);
    

    Genauso gibt es eine Funktion für die Ausgabe.

    void AusgabeDach(Walmdach Dach)
    { if (Dach.mitUeberstand) {
        cout << "Mit  Dachüberstand:\n\n";
      } else {
        cout << "Ohne Dachüberstand:\n\n";
      }
        cout << "Trauflaenge 1: " << Dach.TL[0] << endl;
        cout << "Trauflaenge 2: " << Dach.TL[1] << endl;
        cout << "Trauflaenge gesamt: " << Dach.TLges << endl; //Dachrinnenlänge berechnen
    ....
    }
    
    Ausgabe( mitDachueberstand);
      Ausgabe( OhneDachueberstand);
    


  • Du kannst auch alles mit einer struct-Variablen machen, indem du erst den einen Fall berechnest, dann ausgibst und danach dann den anderen Fall berechnest und ausgibst.

    Also statt

    a = tan(1);
    b = tan(2);
    cout << a << '\n';
    cout << b << '\n';
    

    dann

    a = tan(1);
    cout << a << '\n';
    a = tan(2);
    cout << a << '\n';
    

    ^
    tan() steht beispielhaft für eine Funktion^



  • Hallo DirkB,

    ich bin inzwischen etwas weiter vom Kenntnisstand her, aber fühle mich immer noch nicht wohl. Vielen Dank für deine bisherige Hilfe!
    Zum damaligen Zeitpunkt wusste ich weder was Referenzen sind noch wie ich Funktionen einsetzen kann. Auch Gültigkeitsbereiche waren mir praxisfremd.
    Von daher war es für mich unmöglich, nachzuvollziehen, worauf du dich beziehst.

    Ich habe im Dezember 2016 zwar das Programm hinbekommen und es hat das getan, was es soll. Allerdings wusste ich natürlich, dass es so extrem schlampig ist und nicht bleiben kann.

    Darum würde ich es nun gerne professionell umgestalten, so wie du es mir vorgeschlagen hast. Dort, wo noch unique steht, werde ich Dach einsetzen.
    Was mir noch fehlt, ist dieses ohneDachueberstand wegzubekommen (das ist die alte Struct-Variable).

    Mein Vorhaben:

    Eingabe in eine Funktion packen,
    Ausgabe in eine Funktion packen,
    Berechnungen in (eine) Funktion packen,
    Struct in die main() packen
    1 Struct-Variable verwenden
    alle Funktionsaufrufe in die main() packen

    Ist das so sinnvoll? Wie ist deine Meinung dazu?

    Hierzu habe ich den Code bereits etwas umgestaltet:

    #include <cstdlib>
    #include <cmath>
    #include <iostream>
    #include "Header.h"
    //#define PI 3.1415926535897932384626433832795 --> schlecht, da Standardfunktion nicht mit define überladen werden soll
    //#define cos(x) cos((x)*(PI/180))
    //#define sin(x) sin((x)*(PI/180))
    
    using namespace std;
    
    //Prototypen
    void EingabeDach(struct Walmdach Dach);
    int BerechneDach(struct Walmdach &Dach);
    void AusgabeDach(struct Walmdach Dach);
    
    //Hauptprogramm
    int main() {
    
    	//Structure
    	struct Walmdach
    	{	
    		//Variablen für die EIngabe
    		double TL[2]; //Trauflänge 
    		int DN[4]; //Dachneigung 
    		double DU[4]; //Dachüberstand 
    
    		double DL[4]; //Dachlänge 
    		double GSL[4]; //Gratsparrenlänge 
    		double hFirst; //Firsthöhe 
    		double GLDF[4]; //Grundlänge Dachfläche 
    		double DF[4]; //Dachfläche 
    		double DFges; //Dachfläche gesamt 
    		double TLges; //Trauflänge gesamt 
    		double GSLges; //Gratsparrenlänge gesamt 
    		int FW[4]; //Firstwinkel 
    		int SW; //Sparrenwinkel = Firstwinkel 1 + Firstwinkel 3 
    		double FL; //Firstlänge 
    		double TF[4; //Trauffläche 
    		double TFges; //Trauffläche gesamt 
    		int TW[4]; //Traufwinkel 
    		double TSt[4]; //Traufsturz 
    		double GSt[4]; //Gratsturz 
    		double hTraufe; //Traufhöhe 
    		int GW[4]; //Gratwinkel 
    		int Ueberstand; //wenn 0, dann ohne Überstand; wenn 1, dann mit Überstand
    	} Dach;
    
    	//Funktionsaufrufe
    	Eingabe(Dach);
    	BerechneDach(&Dach);
    	AusgabeDach(Dach);
    
    	system("pause");
    	return 0;
    }
    
    //Funktionen
    void EingabeDach(struct Walmdach Dach)
    {
    cout << "EINGABE DER WERTE\n" << endl;
    cout << "Hauslaenge: ";
    cin >> Dach.TL[1];
    cout << "Hausbreite: ";
    cin >> Dach.TL[2];
    cout << "Dachneigung 1: ";
    cin >> Dach.DN[1];
    cout << "Dachneigung 2: ";
    cin >> Dach.DN[2];
    cout << "Dachneigung 3: ";
    cin >> Dach.DN[3];
    cout << "Dachneigung 4: ";
    cin >> Dach.DN[4];
    cout << "Dachueberstand 1: ";
    cin >> Dach.DU[1];
    cout << "Dachueberstand 2: ";
    cin >> Dach.DU[2];
    cout << "Dachueberstand 3: ";
    cin >> Dach.DU[3];
    cout << "Dachueberstand 4: ";
    cin >> Dach.DU[4];
    }//ENDE DER EINGABE-FUNKTION
    
    int AllgBerechnungen(struct Walmdach &Dach) {
    
    	Dach.SW = 180 - (Dach.DN[0] + Dach.DN[2]);										//Sparrenwinkel ausrechnen (ist immer gleich, egal ob DÜ oder nicht)
    	Dach.TL[1] = Dach.DU[4] + ohneDachueberstand.TL[1] + Dach.DU[2];
    	Dach.TL[2] = Dach.DU[1] + ohneDachueberstand.TL[2] + Dach.DU[3];
    	Dach.FW[1] = 180 - (90 + Dach.DN[1]);												//Firstwinkel
    	Dach.FW[2] = 180 - (90 + Dach.DN[2]);
    	Dach.FW[3] = 180 - (90 + Dach.DN[3]);
    	Dach.FW[4] = 180 - (90 + Dach.DN[4]);
    
    	Dach.TSt[1] = (unique.DU[1] * sin(degtorad(90))) / sin(degtorad(unique.FW[1]));
    	Dach.TSt[2] = (unique.DU[2] * sin(degtorad(90))) / sin(degtorad(unique.FW[2]));
    	Dach.TSt[3] = (unique.DU[3] * sin(degtorad(90))) / sin(degtorad(unique.FW[3]));
    	Dach.TSt[4] = (unique.DU[4] * sin(degtorad(90))) / sin(degtorad(unique.FW[4]));
    }//ENDE ALLGEMEINE BERECHNUNGEN
    
    int BerechneDach(struct Walmdach &Dach)
    {
    
    	Dach.mitUeberstand = mitUeberstand; //welchen Sinn hat das, wenn Dach.mitUeberstand über den Funktionsaufruf 0 oder 1 zugewiesen bekommt?
    
    		Dach.DL[1] = (Dach.TL[2] + (Dach.DU[1] + Dach.DU[3])*Dach.mitUeberstand) * sin(Dach.DN[3] / sin
    		(Dach.SW);
    
    		Dach.TLges = (Dach.TL[1] + Dach.TL[2]) * 2;
    
    		Dach.DL[0] = Dach.TL[1] * sin(degtorad(unique.DN[2])) / sin(degtorad(unique.SW));
    		Dach.hFirst = (Dach.DL[0] * sin(degtorad(unique.DN[0]))) / sin(degtorad(90));
    		Dach.DL[1] = (Dach.hFirst * sin(degtorad(90))) / sin(degtorad(unique.DN[1]));
    		Dach.DL[2] = (sin(degtorad(unique.DN[0])) * Dach.TL[1]) / sin(degtorad(unique.SW));
    		Dach.DL[3] = (Dach.hFirst * sin(degtorad(90))) / sin(degtorad(unique.DN[3]));
    
    		Dach.hFirst = (Dach.DL[0] * sin(degtorad(unique.DN[0]))) / sin(degtorad(90));		//Länge für Stütze unter dem First ermitteln
    																													//Grundlängen der Dachflächen
    		Dach.GLDF[0] = (Dach.hFirst * sin(Dach.FW[0]))) / sin(Dach.DN[0]));
    		Dach.GLDF[1] = (Dach.hFirst * sin(Dach.FW[1]))) / sin(Dach.DN[1]));
    		Dach.GLDF[2] = (Dach.hFirst * sin(Dach.FW[2]))) / sin(Dach.DN[2]));
    		Dach.GLDF[3] = (Dach.hFirst * sin(Dach.FW[3]))) / sin(Dach.DN[3]));
    		//Länge der Firstdachsteine ermitteln
    		Dach.FL = Dach.TL[0] - (Dach.GLDF[1] + Dach.GLDF[3]); //dient nur zum Test, wurde ja schon bei OHNE DÜ berechnet!
    																									   //Länge der Gratdachsteine ermitteln
    		Dach.GSL[0] = sqrt(Dach.DL[0] * Dach.DL[0] + Dach.GLDF[0] * Dach.GLDF[0]);
    		Dach.GSL[1] = sqrt(Dach.DL[1] * Dach.DL[1] + Dach.GLDF[1] * Dach.GLDF[1]);
    		Dach.GSL[2] = sqrt(Dach.DL[2] * Dach.DL[2] + Dach.GLDF[2] * Dach.GLDF[2]);
    		Dach.GSL[3] = sqrt(Dach.DL[3] * Dach.DL[3] + Dach.GLDF[3] * Dach.GLDF[3]);
    		Dach.GSLges = Dach.GSL[0] + Dach.GSL[1] + Dach.GSL[2] + Dach.GSL[3]; //gesamt
    																																			  //Quadratmeter für Dachsteine ermitteln
    		Dach.DF[0] = ((Dach.TL[0] + unique.FL) * Dach.DL[0]) / 2;
    		Dach.DF[1] = (Dach.TL[1] * Dach.DL[1]) / 2;
    		Dach.DF[2] = ((Dach.TL[0] + unique.FL) * Dach.DL[2]) / 2;
    		Dach.DF[3] = (Dach.TL[1] * Dach.DL[3]) / 2;
    		Dach.DFges = Dach.DF[0] + Dach.DF[1] + Dach.DF[2] + Dach.DF[3];		//Quadratmeter für Unterspannbahn ermitteln
    
    		//Trauffläche
    		Dach.TF[0] = Dach.DF[0] - ohneDachueberstand.DF[0];
    		Dach.TF[1] = Dach.DF[1] - ohneDachueberstand.DF[1];
    		Dach.TF[2] = Dach.DF[2] - ohneDachueberstand.DF[2];
    		Dach.TF[3] = Dach.DF[3] - ohneDachueberstand.DF[3];
    		Dach.TFges = Dach.TF[0] + Dach.TF[1] + Dach.TF[2] + Dach.TF[3];
    
    		//Gratsturz
    		Dach.GSt[0] = Dach.GSL[0] - ohneDachueberstand.GSL[0];
    		Dach.GSt[1] = Dach.GSL[1] - ohneDachueberstand.GSL[1];
    		Dach.GSt[2] = Dach.GSL[2] - ohneDachueberstand.GSL[2];
    		Dach.GSt[3] = Dach.GSL[3] - Dach.GSL[3];
    
    		//
    		//OHNE DACHÜBERSTAND
    
    		//Trauflänge berechnen
    		ohneDachueberstand.TLges = (ohneDachueberstand.TL[0] + ohneDachueberstand.TL[1]) * 2;
    
    		ohneDachueberstand.DL[0] = (ohneDachueberstand.TL[1] * sin(degtorad(unique.DN[2]))) / sin(degtorad(unique.SW));
    		ohneDachueberstand.hFirst = (ohneDachueberstand.DL[0] * sin(degtorad(unique.DN[0]))) / sin(degtorad(90));
    		ohneDachueberstand.DL[1] = (ohneDachueberstand.hFirst * sin(degtorad(90))) / sin(degtorad(unique.DN[1]));
    		ohneDachueberstand.DL[2] = (sin(degtorad(unique.DN[0])) * ohneDachueberstand.TL[1]) / sin(degtorad(unique.SW));
    		ohneDachueberstand.DL[3] = (ohneDachueberstand.hFirst * sin(degtorad(90))) / sin(degtorad(unique.DN[3]));
    
    		ohneDachueberstand.hFirst = (ohneDachueberstand.DL[0] * sin(degtorad(unique.DN[0]))) / sin(degtorad(90));	//Länge für Stütze unter dem First ermitteln
    
    		//Grundlängen der Dachflächen
    		ohneDachueberstand.GLDF[0] = (ohneDachueberstand.hFirst * sin(degtorad(unique.FW[0]))) / sin(degtorad(unique.DN[0]));
    		ohneDachueberstand.GLDF[1] = (ohneDachueberstand.hFirst * sin(degtorad(unique.FW[1]))) / sin(degtorad(unique.DN[1]));
    		ohneDachueberstand.GLDF[2] = (ohneDachueberstand.hFirst * sin(degtorad(unique.FW[2]))) / sin(degtorad(unique.DN[2]));
    		ohneDachueberstand.GLDF[3] = (ohneDachueberstand.hFirst * sin(degtorad(unique.FW[3]))) / sin(degtorad(unique.DN[3]));
    
    		//Länge der Gratdachsteine ermitteln
    		ohneDachueberstand.GSL[0] = sqrt(ohneDachueberstand.DL[0] * ohneDachueberstand.DL[0] + ohneDachueberstand.GLDF[0] * ohneDachueberstand.GLDF[0]);
    		ohneDachueberstand.GSL[1] = sqrt(ohneDachueberstand.DL[1] * ohneDachueberstand.DL[1] + ohneDachueberstand.GLDF[1] * ohneDachueberstand.GLDF[1]);
    		ohneDachueberstand.GSL[2] = sqrt(ohneDachueberstand.DL[2] * ohneDachueberstand.DL[2] + ohneDachueberstand.GLDF[2] * ohneDachueberstand.GLDF[2]);
    		ohneDachueberstand.GSL[3] = sqrt(ohneDachueberstand.DL[3] * ohneDachueberstand.DL[3] + ohneDachueberstand.GLDF[3] * ohneDachueberstand.GLDF[3]);
    		ohneDachueberstand.GSLges = ohneDachueberstand.GSL[0] + ohneDachueberstand.GSL[1] + ohneDachueberstand.GSL[2] + ohneDachueberstand.GSL[3]; //gesamt
    
    		//Quadratmeter für Dachsteine ermitteln
    		ohneDachueberstand.DF[0] = ((ohneDachueberstand.TL[0] + unique.FL) * ohneDachueberstand.DL[0]) / 2;
    		ohneDachueberstand.DF[1] = (ohneDachueberstand.TL[1] * ohneDachueberstand.DL[1]) / 2;
    		ohneDachueberstand.DF[2] = ((ohneDachueberstand.TL[0] + unique.FL) * ohneDachueberstand.DL[2]) / 2;
    		ohneDachueberstand.DF[3] = (ohneDachueberstand.TL[1] * ohneDachueberstand.DL[3]) / 2;
    		ohneDachueberstand.DFges = ohneDachueberstand.DF[0] + ohneDachueberstand.DF[1] + ohneDachueberstand.DF[2] + ohneDachueberstand.DF[3];		//Quadratmeter für Unterspannbahn ermitteln
    
    	return 0;
    
    }//ENDE DER BERECHNUNGSFUNKTION
    
    void AusgabeDach(Walmdach Dach)
    {
    	if (Dach.mitUeberstand) {
    		cout << "Mit Dachueberstand:\n\n";
    	}
    	else { cout << "Ohne Dachueberstand: \n\n"; }
    
    	cout << "\n\n";
    	cout << "ALLE WERTE OHNE DACHUEBERSTAND\n" << endl;
    	cout << "Trauflaemge 1: " << ohneDachueberstand.TL[1] << endl;
    	cout << "Trauflaenge 2: " << ohneDachueberstand.TL[2] << endl;
    	cout << "Trauflaenge gesamt: " << ohneDachueberstand.TLges << endl; //Dachrinnenlänge berechnen
    
    	cout << "Dachlaenge 1: " << ohneDachueberstand.DL[1] << endl;
    	cout << "Dachlaenge 2: " << ohneDachueberstand.DL[2] << endl;
    	cout << "Dachlaenge 3: " << ohneDachueberstand.DL[3] << endl;
    	cout << "Dachlaenge 4: " << ohneDachueberstand.DL[4] << endl; //Sparrenlaenge berechnen
    
    	cout << "Grundlaenge Dachflaeche 1: " << ohneDachueberstand.GLDF[1] << endl;
    	cout << "Grundlaenge Dachflaeche 2: " << ohneDachueberstand.GLDF[2] << endl;
    	cout << "Grundlaenge Dachflaeche 3: " << ohneDachueberstand.GLDF[3] << endl;
    	cout << "Grundlaenge Dachflaeche 4: " << ohneDachueberstand.GLDF[4] << endl; //für weitere Berechnungen
    
    	cout << "Firstlaenge: " << Dach.FL << " Meter" << endl;		//Länge für Firstdachsteine ermitteln
    	cout << "Firsthoehe: " << ohneDachueberstand.hFirst << " Meter" << endl;	//Länge für Stütze unter dem First ermitteln
    
    	cout << "Gratsparrenlaenge 1: " << ohneDachueberstand.GSL[1] << endl;
    	cout << "Gratsparrenlaenge 2: " << ohneDachueberstand.GSL[2] << endl;
    	cout << "Gratsparrenlaenge 3: " << ohneDachueberstand.GSL[3] << endl;
    	cout << "Gratsparrenlaenge 4: " << ohneDachueberstand.GSL[4] << endl;
    	cout << "Gratsparrenlaenge gesamt: " << ohneDachueberstand.GSLges << endl; //Länge für Gratdachsteine ermitteln
    
    	cout << "Dachflaeche 1: " << ohneDachueberstand.DF[1] << endl;
    	cout << "Dachflaeche 2: " << ohneDachueberstand.DF[2] << endl;
    	cout << "Dachflaeche 3: " << ohneDachueberstand.DF[3] << endl;
    	cout << "Dachflaeche 4: " << ohneDachueberstand.DF[4] << endl;
    	cout << "Gesamtdachflaeche: " << ohneDachueberstand.DFges << endl;
    
    	cout << "\n" << endl;
    	cout << "ALLE WERTE MIT DACHUEBERSTAND\n" << endl;
    	cout << "Trauflaemge 1: " << Dach.TL[1] << endl;
    	cout << "Trauflaenge 2: " << Dach.TL[2] << endl;
    	cout << "Trauflaenge gesamt: " << Dach.TLges << endl; //Dachrinnenlänge berechnen
    
    	cout << "Dachlaenge 1: " << Dach.DL[1] << endl;
    	cout << "Dachlaenge 2: " << Dach.DL[2] << endl;
    	cout << "Dachlaenge 3: " << Dach.DL[3] << endl;
    	cout << "Dachlaenge 4: " << Dach.DL[4] << endl; //Sparrenlaenge berechnen
    
    	cout << "Grundlaenge Dachflaeche 1: " << Dach.GLDF[1] << endl;
    	cout << "Grundlaenge Dachflaeche 2: " << Dach.GLDF[2] << endl;
    	cout << "Grundlaenge Dachflaeche 3: " << Dach.GLDF[3] << endl;
    	cout << "Grundlaenge Dachflaeche 4: " << Dach.GLDF[4] << endl; //für weitere Berechnungen
    
    	cout << "Firstlaenge: " << Dach.FL << " Meter" << endl;		//Länge für Firstdachsteine ermitteln
    	cout << "Firsthoehe: " << Dach.hFirst << " Meter" << endl;	//Länge für Stütze unter dem First ermitteln
    
    	cout << "Gratsparrenlaenge 1: " << Dach.GSL[1] << endl;
    	cout << "Gratsparrenlaenge 2: " << Dach.GSL[2] << endl;
    	cout << "Gratsparrenlaenge 3: " << Dach.GSL[3] << endl;
    	cout << "Gratsparrenlaenge 4: " << Dach.GSL[4] << endl;
    	cout << "Gratsparrenlaenge gesamt: " << Dach.GSLges << endl; //Länge für Gratdachsteine ermitteln
    
    	cout << "Dachflaeche 1: " << Dach.DF[1] << endl;
    	cout << "Dachflaeche 2: " << Dach.DF[2] << endl; //Quadratmeter Folie Innenausbau
    	cout << "Dachflaeche 3: " << Dach.DF[3] << endl;
    	cout << "Dachflaeche 4: " << Dach.DF[4] << endl;
    	cout << "Dachflaeche gesamt: " << Dach.DFges << endl; //Quadratmeter Gipskartonbauplatten
    
    	cout << "Differenz aus Dachflaeche1 mit Dachueberstand - \nDachflaeche1 ohne Dachueberstand (=Traufflaeche 1): " << Dach.TF[1] << endl;
    	cout << "Traufflaeche 2: " << Dach.TF[2] << endl;
    	cout << "Traufflaeche 3: " << Dach.TF[3] << endl;
    	cout << "Traufflaeche 4: " << Dach.TF[4] << endl;
    	cout << "Gesamte Traufflaeche: " << Dach.TFges << endl; //Quadratmeter Untersichtsbretter
    
    	cout << "Differenz aus Dachlaenge1 mit Dachueberstand - \nDachlaenge1 ohne Dachueberstand (=Traufsturz 1): " << Dach.TSt[1] << endl;
    	cout << "Traufsturz 2: " << Dach.TSt[2] << endl;
    	cout << "Traufsturz 3: " << Dach.TSt[3] << endl;
    	cout << "Traufsturz 4: " << Dach.TSt[4] << endl; //Laenge Stichsparren ermitteln
    
    	cout << "Differenz aus Grundlaenge Dachflaeche1 mit Dachueberstand - \nGrundlaenge Dachflaeche1 ohne Dachueberstand: " << Dach.DU[1] << endl;
    	cout << "Differenz aus Grundlaenge Dachflaeche2 mit Dachueberstand - \nGrundlaenge Dachflaeche2 ohne Dachueberstand: " << Dach.DU[2] << endl;
    	cout << "Differenz aus Grundlaenge Dachflaeche3 mit Dachueberstand - \nGrundlaenge Dachflaeche3 ohne Dachueberstand: " << Dach.DU[3] << endl;
    	cout << "Differenz aus Grundlaenge Dachflaeche4 mit Dachueberstand - \nGrundlaenge Dachflaeche4 ohne Dachueberstand: " << Dach.DU[4] << endl; //Quadratmeter Untersichtsbretter (Binderdach)
    
    	cout << "Differenz aus Gratsparrenlaenge1 mit Dachueberstand - \nGratsparrenlaenge1 ohne Dachueberstand (=Gratsturz 1): " << Dach.GSt[1] << endl;
    	cout << "Gratsturz 2: " << Dach.GSt[2] << endl;
    	cout << "Gratsturz 3: " << Dach.GSt[3] << endl;
    	cout << "Gratsturz 4: " << Dach.GSt[4] << endl;
    	cout << "\n\n";
    }//ENDE AUSGABE-FUNKTION
    

    Ich verstehe leider noch nicht, wie ich zwischen ohneÜberstand und mitÜberstand unterscheiden kann...deshalb ist die alte ohneUeberstand-Structvariable noch da, die soll weg.



  • DirkB schrieb:

    Archy schrieb:

    Die Winkelmaße habe ich mit

    #define sin(x) sin((x)*(PI/180))
    

    Es ist ganz schlecht eine Standardfunktion per define zu "überladen".

    Was passiert dabei überhaupt? Landet der Präprozessor in einer Endlosrekursion?



  • Die struct Walmdach solltest du schon außerhalb von main definieren. Das muss noch vor den Prototypen passieren, damit der Compiler den Typ bei den Deklarationen schon kennt.

    Die struct -Variable Dach bleibt aber in main !

    Archy schrieb:

    Ich verstehe leider noch nicht, wie ich zwischen ohneÜberstand und mitÜberstand unterscheiden kann...deshalb ist die alte ohneUeberstand-Structvariable noch da, die soll weg.

    Entweder machst du zwei Funktionen (eine mit, die andere ohne Überstand) oder du machst nur eine Funktion, die beides berechnen kann.
    Was berechnet wird, übergibst du mit einem zweiten Parameter oder durch Auswertubg von Dach.Ueberstand

    Bei der Ausgabe machst du es ähnlich. Du musst entsprechend "ohne" durch "mit" ersetzen.
    Das kannst du aber mit einem String-Array machen.

    Du musst nach der Eingabe die Berechnung ohne Überstand machen und danach gleich die Ausgabe.
    Dann machst du die Berechnung mit Überstand und danach gleich die Ausgabe.

    Und benenne deine Makros in sin_d und cos_d (d für degree) um.

    Und irgendwie kommst du mit den Rerferenzen immer noch durcheinander.


  • Mod

    Der Präprozessor kann überhaupt keine Rekursion.

    Trotzdem eine ganz schlechte Idee. Sogar ausdrücklich undefiniertes Verhalten.



  • Andromeda schrieb:

    DirkB schrieb:

    Archy schrieb:

    Die Winkelmaße habe ich mit

    #define sin(x) sin((x)*(PI/180))
    

    Es ist ganz schlecht eine Standardfunktion per define zu "überladen".

    Was passiert dabei überhaupt? Landet der Präprozessor in einer Endlosrekursion?

    Der Präprozessor erstzt nur einmal.
    Aber, der Compiler darf, wenn bei Standardfunktionen das Ergebnis zur Compiletime feststeht, dieses einsetzen.
    Zudem verwirrt es, da man davon ausgeht, dass die Winkelfunktonen Bogenmass erfordern.



  • Archy schrieb:

    Hallo DirkB,

    ich bin inzwischen etwas weiter vom Kenntnisstand her, aber fühle mich immer noch nicht wohl. Vielen Dank für deine bisherige Hilfe!
    Zum damaligen Zeitpunkt wusste ich weder was Referenzen sind noch wie ich Funktionen einsetzen kann.

    So richtig gut verstanden hast du Referenzen aber immer noch nicht. Ein paar Kommentare inline.

    Mein Vorhaben:

    Eingabe in eine Funktion packen,
    Ausgabe in eine Funktion packen,
    Berechnungen in (eine) Funktion packen,
    Struct in die main() packen
    1 Struct-Variable verwenden
    alle Funktionsaufrufe in die main() packen

    Ist das so sinnvoll? Wie ist deine Meinung dazu?

    Hört sich soweit erstmal ok an.

    Hierzu habe ich den Code bereits etwas umgestaltet:

    #include <cstdlib>
    #include <cmath>
    #include <iostream>
    #include "Header.h"
    //#define PI 3.1415926535897932384626433832795 --> schlecht, da Standardfunktion nicht mit define überladen werden soll
    //#define cos(x) cos((x)*(PI/180))
    //#define sin(x) sin((x)*(PI/180))
    

    Wofür der Header cstdlib? Was tut dein "Header.h"? Die drei auskommentierten Zeilen einfach löschen, sonst kommt noch jemand auf die Idee, das so weiter zu verwenden!

    //Prototypen
    void EingabeDach(struct Walmdach Dach);
    int BerechneDach(struct Walmdach &Dach);
    void AusgabeDach(struct Walmdach Dach);
    

    Wer hat dir das "struct" beigebracht? Das gehört da nicht hin. Warum nimmt "EingabeDach" keine Referenz? Wie soll die Eingabe denn Funktionieren, wenn du sie auf einer Kopie tätigst? Also: void EingabeDach(Walmdach &dach);
    Eine Alternative könnte sein: Walmdach EingabeDach();

    Und deine Ausgabe sollte als Signatur

    void AusgabeDach(const Walmdach& dach);
    

    haben. Die bessere Alternative wäre, den operator<< zu überladen (ist aber erstmal egal).

    Die Variable "Dach" schreibt nach nach gängigen Konventionen klein (also dach).

    Damit du "Walmdach dach" ohne struct scheiben kannst, muss struct Walmdach natürlich schon vorher bekannt sein. Eine Klasse/ein Struct definiert man nicht innerhalb von main! Du kannst das struct Walmdach also an den Anfang deiner Programms (hinter die Header) verschieben. Wenn dann mal alles größer wird, tust du das Walmdach in den Header "Walmdach.h" und includest diesen. Ein Header namens "Header.h" ist so schrecklich nichtssagend.

    //Funktionsaufrufe
    	Eingabe(Dach);
    	BerechneDach(&Dach);
    	AusgabeDach(Dach);
    

    Wie passt BerechneDach(&Dach) jetzt zur Signatur? Du hast da nicht "Walmdach *" drin stehen, sondern nimmst eine Referenz.



  • Mein Vorhaben:

    Eingabe in eine Funktion packen,
    Ausgabe in eine Funktion packen,
    Berechnungen in (eine) Funktion packen,
    Struct in die main() packen
    1 Struct-Variable verwenden
    alle Funktionsaufrufe in die main() packen
    Ist das so sinnvoll? Wie ist deine Meinung dazu?

    wob schrieb:

    Hört sich soweit erstmal ok an.

    Anscheinend ist das nicht ok, wenn die struct nicht in die main-Funktion gepackt werden darf. Ich habe allerdings ein Problem damit, dass die struct global ist.
    Gibt es eine Möglichkeit, die struct nur für die bisher definierten Funktionen gültig zu machen und für später hinzukommende Funktionen auszuschließen?
    Vermutlich müsste ich sie dann mitsamt der bisherigen Funktionen in eine Klasse packen, oder? Wenn ich sie in einen Header packe und inkludiere, ist sie ja auch global innerhalb der main.cpp gültig, richtig?

    wob schrieb:

    Hierzu habe ich den Code bereits etwas umgestaltet:

    C++:
    #include <cstdlib>
    #include <cmath>
    #include <iostream>
    #include "Header.h"
    //#define PI 3.1415926535897932384626433832795 --> schlecht, da Standardfunktion nicht mit define überladen werden soll
    //#define cos(x) cos((x)(PI/180))
    //#define sin(x) sin((x)
    (PI/180))

    Wofür der Header cstdlib? Was tut dein "Header.h"? Die drei auskommentierten Zeilen einfach löschen, sonst kommt noch jemand auf die Idee, das so weiter zu verwenden!

    Habe die drei kommentierten Zeilen und die cstdlib herausgenommen.
    Wollte sie eigentlich nur für den Lerneffekt stehen lassen.

    Der Header.h (jetzt umbenannt nach "DegConv.h") rechnet über Inline-Funktionen von Gradmaß nach Bogenmaß um (&vice versa) und gibt das Ergebnis als double-Wert zurück (Winkelfunktionen in mathematischen Bibliotheken für Programmiersprachen und in Programmen zur Tabellenkalkulation verwenden stets das Bogenmaß; Gradangaben müssen umgerechnet werden):

    inline double radian(double degree) { // Grad in Bogenmaß umrechnen
    
        return  degree / 180.0 * 3.141592653589793238;
    }
    
    inline double degree(double rad) { // Bogenmaß in Grad umrechnen
    
        return  rad * 180.0 / 3.141592653589793238;
    }
    

    Hier wird eigentlich nur die erste Variante benötigt, um die Sinusfunktion nutzen zu können.

    wob schrieb:

    Zitat:
    C++:
    //Prototypen
    void EingabeDach(struct Walmdach Dach);
    int BerechneDach(struct Walmdach &Dach);
    void AusgabeDach(struct Walmdach Dach);

    Wer hat dir das "struct" beigebracht? Das gehört da nicht hin. Warum nimmt "EingabeDach" keine Referenz? Wie soll die Eingabe denn Funktionieren, wenn du sie auf einer Kopie tätigst? Also: void EingabeDach(Walmdach &dach);
    Eine Alternative könnte sein: Walmdach EingabeDach();

    Das struct hatten wir in der Schule noch gar nicht. Wir sind bis jetzt erst am Anfang von Funktionen. Wir haben gelernt, dass der Prototyp immer den Datentyp enthalten muss. Dementsprechend habe ich "struct" vorangestellt.

    Ich habe es nun so abgeändert:
    void Eingabe(Walmdach &dach);
    int Berechne(Walmdach &dach);
    void Ausgabe(Walmdach &dach);

    wob schrieb:

    Also: void Eingabe(Walmdach &dach);
    Eine Alternative könnte sein: Walmdach Eingabe();

    Das verstehe ich nicht. Wie kann der struct-Name hier als Rückgabetyp verwendet werden? Was wird dann zurückgegeben?

    wob schrieb:

    Und deine Ausgabe sollte als Signatur
    C++:
    void AusgabeDach(const Walmdach& dach);

    Wieso nehme ich hier eine Konstante?
    Welchen Zweck erfüllt das bzw. was passiert/kann passieren, wenn ich die Konstante weglasse?

    Das Programm sieht jetzt so aus:

    #include <cmath>
    #include <iostream>
    #include "DegConv.h"
    
    using namespace std;
    
    //Structure
    struct Walmdach
    {
    	//Variablen für die EIngabe
    	double TL[2]; //Trauflänge
    	int DN[4]; //Dachneigung
    	double DU[4]; //Dachüberstand
    
    	double DL[4]; //Dachlänge
    	double GSL[4]; //Gratsparrenlänge
    	double hFirst; //Firsthöhe
    	double GLDF[4]; //Grundlänge Dachfläche
    	double DF[4]; //Dachfläche
    	double DFges; //Dachfläche gesamt
    	double TLges; //Trauflänge gesamt
    	double GSLges; //Gratsparrenlänge gesamt
    	int FW[4]; //Firstwinkel
    	int SW; //Sparrenwinkel = Firstwinkel 1 + Firstwinkel 3
    	double FL; //Firstlänge
    	double TF[4; //Trauffläche
    	double TFges; //Trauffläche gesamt
    	int TW[4]; //Traufwinkel
    	double TSt[4]; //Traufsturz
    	double GSt[4]; //Gratsturz
    	double hTraufe; //Traufhöhe
    	int GW[4]; //Gratwinkel
    	int Ueberstand; //wenn 0, dann ohne Überstand; wenn 1, dann mit Überstand
    } dach;
    
    //Prototypen
    void Eingabe(Walmdach &dach);
    int AllgBerechnungen(Walmdach &dach);
    int Berechne(Walmdach &dach);
    void Ausgabe(Walmdach &dach);
    
    //Hauptprogramm
    int main() {
    
    	//Funktionsaufrufe
    	Eingabe(Walmdach &dach);
    	Berechne(Walmdach &dach);
    	Ausgabe(Walmdach &dach);
    
    	system("pause");
    	return 0;
    }
    
    //Funktionen
    void Eingabe(Walmdach &dach)
    {
    cout << "EINGABE DER WERTE\n" << endl;
    cout << "Hauslaenge: ";
    cin >> dach.TL[1];
    cout << "Hausbreite: ";
    cin >> dach.TL[2];
    cout << "Dachneigung 1: ";
    cin >> dach.DN[1];
    cout << "Dachneigung 2: ";
    cin >> dach.DN[2];
    cout << "Dachneigung 3: ";
    cin >> dach.DN[3];
    cout << "Dachneigung 4: ";
    cin >> dach.DN[4];
    cout << "Dachueberstand 1: ";
    cin >> dach.DU[1];
    cout << "Dachueberstand 2: ";
    cin >> dach.DU[2];
    cout << "Dachueberstand 3: ";
    cin >> dach.DU[3];
    cout << "Dachueberstand 4: ";
    cin >> dach.DU[4];
    }//ENDE DER EINGABE-FUNKTION
    
    int AllgBerechnungen(Walmdach &dach) {
    
    	dach.SW = 180 - (dach.DN[0] + dach.DN[2]);								//SW = Sparrenwinkel ausrechnen (ist immer gleich, egal ob DÜ oder nicht)
    	/*dach.TL[1] = dach.DU[4] + ohneDachueberstand.TL[1] + dach.DU[2];
    	dach.TL[2] = dach.DU[1] + ohneDachueberstand.TL[2] + dach.DU[3]; */		//ohneDachueberstand muss noch behandelt werden!
    	dach.FW[1] = 180 - (90 + dach.DN[1]);									//FW = Firstwinkel
    	dach.FW[2] = 180 - (90 + dach.DN[2]);
    	dach.FW[3] = 180 - (90 + dach.DN[3]);
    	dach.FW[4] = 180 - (90 + dach.DN[4]);
    
    	dach.TSt[1] = (dach.DU[1] * sin(radian(90))) / sin(radian(dach.FW[1])); //radian ist das Bogenmaß und wird im Header ConvDeg berechnet!
    	dach.TSt[2] = (dach.DU[2] * sin(radian(90))) / sin(radian(dach.FW[2]));
    	dach.TSt[3] = (dach.DU[3] * sin(radian(90))) / sin(radian(dach.FW[3]));
    	dach.TSt[4] = (dach.DU[4] * sin(radian(90))) / sin(radian(dach.FW[4]));
    
    	return 0;
    }//ENDE ALLGEMEINE BERECHNUNGEN
    
    int BerechneDach(Walmdach &dach)
    {		//Muss noch überarbeitet werden, weil mitUeberstand nicht mehr existiert!
    		/*dach.DL[1] = (dach.TL[2] + (dach.DU[1] + dach.DU[3])*dach.mitUeberstand) * sin(dach.DN[3] / sin
    		(dach.SW);*/
    
    		dach.TLges = (dach.TL[1] + dach.TL[2]) * 2;
    
    		dach.DL[0] = dach.TL[1] * sin((dach.DN[2])) / sin(radian(dach.SW));
    		dach.hFirst = (dach.DL[0] * sin(radian(unique.DN[0]))) / sin(radian(90));
    		dach.DL[1] = (dach.hFirst * sin(radian(90))) / sin(radian(dach.DN[1]));
    		dach.DL[2] = (sin(radian(dach.DN[0])) * dach.TL[1]) / sin(radian(dach.SW));
    		dach.DL[3] = (dach.hFirst * sin(radian(90))) / sin(radian(dach.DN[3]));
    
    		dach.hFirst = (dach.DL[0] * sin(radian(dach.DN[0]))) / sin(radian(90));		//Länge für Stütze unter dem First ermitteln
    
    		dach.GLDF[0] = (dach.hFirst * sin(dach.FW[0]))) / sin(dach.DN[0]));			//GLDF = Grundlängen der Dachflächen
    		dach.GLDF[1] = (dach.hFirst * sin(dach.FW[1]))) / sin(dach.DN[1]));
    		dach.GLDF[2] = (dach.hFirst * sin(dach.FW[2]))) / sin(dach.DN[2]));
    		dach.GLDF[3] = (dach.hFirst * sin(dach.FW[3]))) / sin(dach.DN[3]));
    
    		//Länge der Firstdachsteine ermitteln
    		dach.FL = dach.TL[0] - (dach.GLDF[1] + dach.GLDF[3]); //dient nur zum Test, wurde ja schon bei OHNE DÜ berechnet!
    
    		//Länge der Gratdachsteine ermitteln
    		dach.GSL[0] = sqrt(dach.DL[0] * dach.DL[0] + dach.GLDF[0] * dach.GLDF[0]);
    		dach.GSL[1] = sqrt(dach.DL[1] * dach.DL[1] + dach.GLDF[1] * dach.GLDF[1]);
    		dach.GSL[2] = sqrt(dach.DL[2] * dach.DL[2] + dach.GLDF[2] * dach.GLDF[2]);
    		dach.GSL[3] = sqrt(dach.DL[3] * dach.DL[3] + dach.GLDF[3] * dach.GLDF[3]);
    		dach.GSLges = dach.GSL[0] + dach.GSL[1] + dach.GSL[2] + dach.GSL[3]; //gesamt
    
    		//Quadratmeter für Dachsteine ermitteln
    		dach.DF[0] = ((dach.TL[0] + dach.FL) * dach.DL[0]) / 2;
    		dach.DF[1] = (dach.TL[1] * dach.DL[1]) / 2;
    		dach.DF[2] = ((dach.TL[0] + dach.FL) * dach.DL[2]) / 2;
    		dach.DF[3] = (dach.TL[1] * dach.DL[3]) / 2;
    		dach.DFges = dach.DF[0] + dach.DF[1] + dach.DF[2] + dach.DF[3];	//Quadratmeter für Unterspannbahn ermitteln
    
    		/*
    		//WIRD IN EINE SEPARATE FUNKTION GEPACKT
    
    		//Trauffläche
    		dach.TF[0] = dach.DF[0] - ohneDachueberstand.DF[0];
    		dach.TF[1] = dach.DF[1] - ohneDachueberstand.DF[1];
    		dach.TF[2] = dach.DF[2] - ohneDachueberstand.DF[2];
    		dach.TF[3] = dach.DF[3] - ohneDachueberstand.DF[3];
    		dach.TFges = dach.TF[0] + dach.TF[1] + dach.TF[2] + dach.TF[3];
    
    		//Gratsturz
    		dach.GSt[0] = dach.GSL[0] - ohneDachueberstand.GSL[0];
    		dach.GSt[1] = dach.GSL[1] - ohneDachueberstand.GSL[1];
    		dach.GSt[2] = dach.GSL[2] - ohneDachueberstand.GSL[2];
    		dach.GSt[3] = dach.GSL[3] - dach.GSL[3];
    
    		//OHNE DACHÜBERSTAND
    
    		//Trauflänge berechnen
    		ohneDachueberstand.TLges = (ohneDachueberstand.TL[0] + ohneDachueberstand.TL[1]) * 2;
    
    		ohneDachueberstand.DL[0] = (ohneDachueberstand.TL[1] * sin(degtorad(unique.DN[2]))) / sin(degtorad(unique.SW));
    		ohneDachueberstand.hFirst = (ohneDachueberstand.DL[0] * sin(degtorad(unique.DN[0]))) / sin(degtorad(90));
    		ohneDachueberstand.DL[1] = (ohneDachueberstand.hFirst * sin(degtorad(90))) / sin(degtorad(unique.DN[1]));
    		ohneDachueberstand.DL[2] = (sin(degtorad(unique.DN[0])) * ohneDachueberstand.TL[1]) / sin(degtorad(unique.SW));
    		ohneDachueberstand.DL[3] = (ohneDachueberstand.hFirst * sin(degtorad(90))) / sin(degtorad(unique.DN[3]));
    
    		ohneDachueberstand.hFirst = (ohneDachueberstand.DL[0] * sin(degtorad(unique.DN[0]))) / sin(degtorad(90));	//Länge für Stütze unter dem First ermitteln
    
    		//Grundlängen der Dachflächen
    		ohneDachueberstand.GLDF[0] = (ohneDachueberstand.hFirst * sin(degtorad(unique.FW[0]))) / sin(degtorad(unique.DN[0]));
    		ohneDachueberstand.GLDF[1] = (ohneDachueberstand.hFirst * sin(degtorad(unique.FW[1]))) / sin(degtorad(unique.DN[1]));
    		ohneDachueberstand.GLDF[2] = (ohneDachueberstand.hFirst * sin(degtorad(unique.FW[2]))) / sin(degtorad(unique.DN[2]));
    		ohneDachueberstand.GLDF[3] = (ohneDachueberstand.hFirst * sin(degtorad(unique.FW[3]))) / sin(degtorad(unique.DN[3]));
    
    		//Länge der Gratdachsteine ermitteln
    		ohneDachueberstand.GSL[0] = sqrt(ohneDachueberstand.DL[0] * ohneDachueberstand.DL[0] + ohneDachueberstand.GLDF[0] * ohneDachueberstand.GLDF[0]);
    		ohneDachueberstand.GSL[1] = sqrt(ohneDachueberstand.DL[1] * ohneDachueberstand.DL[1] + ohneDachueberstand.GLDF[1] * ohneDachueberstand.GLDF[1]);
    		ohneDachueberstand.GSL[2] = sqrt(ohneDachueberstand.DL[2] * ohneDachueberstand.DL[2] + ohneDachueberstand.GLDF[2] * ohneDachueberstand.GLDF[2]);
    		ohneDachueberstand.GSL[3] = sqrt(ohneDachueberstand.DL[3] * ohneDachueberstand.DL[3] + ohneDachueberstand.GLDF[3] * ohneDachueberstand.GLDF[3]);
    		ohneDachueberstand.GSLges = ohneDachueberstand.GSL[0] + ohneDachueberstand.GSL[1] + ohneDachueberstand.GSL[2] + ohneDachueberstand.GSL[3]; //gesamt
    
    		//Quadratmeter für Dachsteine ermitteln
    		ohneDachueberstand.DF[0] = ((ohneDachueberstand.TL[0] + unique.FL) * ohneDachueberstand.DL[0]) / 2;
    		ohneDachueberstand.DF[1] = (ohneDachueberstand.TL[1] * ohneDachueberstand.DL[1]) / 2;
    		ohneDachueberstand.DF[2] = ((ohneDachueberstand.TL[0] + unique.FL) * ohneDachueberstand.DL[2]) / 2;
    		ohneDachueberstand.DF[3] = (ohneDachueberstand.TL[1] * ohneDachueberstand.DL[3]) / 2;
    		ohneDachueberstand.DFges = ohneDachueberstand.DF[0] + ohneDachueberstand.DF[1] + ohneDachueberstand.DF[2] + ohneDachueberstand.DF[3];		//Quadratmeter für Unterspannbahn ermitteln
    		*/
    
    	return 0;
    
    }//ENDE DER BERECHNUNGSFUNKTION
    
    void Ausgabe(const Walmdach &dach) //ohneDachueberstand muss noch behandelt werden!
    {
    	cout << "\n\n";
    	cout << "ALLE WERTE OHNE DACHUEBERSTAND\n" << endl;
    	/*cout << "Trauflaemge 1: " << ohneDachueberstand.TL[1] << endl;
    	cout << "Trauflaenge 2: " << ohneDachueberstand.TL[2] << endl;
    	cout << "Trauflaenge gesamt: " << ohneDachueberstand.TLges << endl; //Dachrinnenlänge berechnen
    
    	cout << "Dachlaenge 1: " << ohneDachueberstand.DL[1] << endl;
    	cout << "Dachlaenge 2: " << ohneDachueberstand.DL[2] << endl;
    	cout << "Dachlaenge 3: " << ohneDachueberstand.DL[3] << endl;
    	cout << "Dachlaenge 4: " << ohneDachueberstand.DL[4] << endl; //Sparrenlaenge berechnen
    
    	cout << "Grundlaenge Dachflaeche 1: " << ohneDachueberstand.GLDF[1] << endl;
    	cout << "Grundlaenge Dachflaeche 2: " << ohneDachueberstand.GLDF[2] << endl;
    	cout << "Grundlaenge Dachflaeche 3: " << ohneDachueberstand.GLDF[3] << endl;
    	cout << "Grundlaenge Dachflaeche 4: " << ohneDachueberstand.GLDF[4] << endl; //für weitere Berechnungen
    
    	cout << "Firstlaenge: " << dach.FL << " Meter" << endl;		//Länge für Firstdachsteine ermitteln
    	cout << "Firsthoehe: " << ohneDachueberstand.hFirst << " Meter" << endl;	//Länge für Stütze unter dem First ermitteln
    
    	cout << "Gratsparrenlaenge 1: " << ohneDachueberstand.GSL[1] << endl;
    	cout << "Gratsparrenlaenge 2: " << ohneDachueberstand.GSL[2] << endl;
    	cout << "Gratsparrenlaenge 3: " << ohneDachueberstand.GSL[3] << endl;
    	cout << "Gratsparrenlaenge 4: " << ohneDachueberstand.GSL[4] << endl;
    	cout << "Gratsparrenlaenge gesamt: " << ohneDachueberstand.GSLges << endl; //Länge für Gratdachsteine ermitteln
    
    	cout << "Dachflaeche 1: " << ohneDachueberstand.DF[1] << endl;
    	cout << "Dachflaeche 2: " << ohneDachueberstand.DF[2] << endl;
    	cout << "Dachflaeche 3: " << ohneDachueberstand.DF[3] << endl;
    	cout << "Dachflaeche 4: " << ohneDachueberstand.DF[4] << endl;
    	cout << "Gesamtdachflaeche: " << ohneDachueberstand.DFges << endl;
    	*/
    	cout << "\n" << endl;
    	cout << "ALLE WERTE MIT DACHUEBERSTAND\n" << endl;
    	cout << "Trauflaemge 1: " << dach.TL[1] << endl;
    	cout << "Trauflaenge 2: " << dach.TL[2] << endl;
    	cout << "Trauflaenge gesamt: " << dach.TLges << endl; //Dachrinnenlänge berechnen
    
    	cout << "Dachlaenge 1: " << dach.DL[1] << endl;
    	cout << "Dachlaenge 2: " << dach.DL[2] << endl;
    	cout << "Dachlaenge 3: " << dach.DL[3] << endl;
    	cout << "Dachlaenge 4: " << dach.DL[4] << endl; //Sparrenlaenge berechnen
    
    	cout << "Grundlaenge Dachflaeche 1: " << dach.GLDF[1] << endl;
    	cout << "Grundlaenge Dachflaeche 2: " << dach.GLDF[2] << endl;
    	cout << "Grundlaenge Dachflaeche 3: " << dach.GLDF[3] << endl;
    	cout << "Grundlaenge Dachflaeche 4: " << dach.GLDF[4] << endl; //für weitere Berechnungen
    
    	cout << "Firstlaenge: " << dach.FL << " Meter" << endl;		//Länge für Firstdachsteine ermitteln
    	cout << "Firsthoehe: " << dach.hFirst << " Meter" << endl;	//Länge für Stütze unter dem First ermitteln
    
    	cout << "Gratsparrenlaenge 1: " << dach.GSL[1] << endl;
    	cout << "Gratsparrenlaenge 2: " << dach.GSL[2] << endl;
    	cout << "Gratsparrenlaenge 3: " << dach.GSL[3] << endl;
    	cout << "Gratsparrenlaenge 4: " << dach.GSL[4] << endl;
    	cout << "Gratsparrenlaenge gesamt: " << dach.GSLges << endl; //Länge für Gratdachsteine ermitteln
    
    	cout << "Dachflaeche 1: " << dach.DF[1] << endl;
    	cout << "Dachflaeche 2: " << dach.DF[2] << endl; //Quadratmeter Folie Innenausbau
    	cout << "Dachflaeche 3: " << dach.DF[3] << endl;
    	cout << "Dachflaeche 4: " << dach.DF[4] << endl;
    	cout << "Dachflaeche gesamt: " << dach.DFges << endl; //Quadratmeter Gipskartonbauplatten
    
    	cout << "Differenz aus Dachflaeche1 mit Dachueberstand - \nDachflaeche1 ohne Dachueberstand (=Traufflaeche 1): " << dach.TF[1] << endl;
    	cout << "Traufflaeche 2: " << dach.TF[2] << endl;
    	cout << "Traufflaeche 3: " << dach.TF[3] << endl;
    	cout << "Traufflaeche 4: " << dach.TF[4] << endl;
    	cout << "Gesamte Traufflaeche: " << dach.TFges << endl; //Quadratmeter Untersichtsbretter
    
    	cout << "Differenz aus Dachlaenge1 mit Dachueberstand - \nDachlaenge1 ohne Dachueberstand (=Traufsturz 1): " << dach.TSt[1] << endl;
    	cout << "Traufsturz 2: " << dach.TSt[2] << endl;
    	cout << "Traufsturz 3: " << dach.TSt[3] << endl;
    	cout << "Traufsturz 4: " << dach.TSt[4] << endl; //Laenge Stichsparren ermitteln
    
    	cout << "Differenz aus Grundlaenge Dachflaeche1 mit Dachueberstand - \nGrundlaenge Dachflaeche1 ohne Dachueberstand: " << dach.DU[1] << endl;
    	cout << "Differenz aus Grundlaenge Dachflaeche2 mit Dachueberstand - \nGrundlaenge Dachflaeche2 ohne Dachueberstand: " << dach.DU[2] << endl;
    	cout << "Differenz aus Grundlaenge Dachflaeche3 mit Dachueberstand - \nGrundlaenge Dachflaeche3 ohne Dachueberstand: " << dach.DU[3] << endl;
    	cout << "Differenz aus Grundlaenge Dachflaeche4 mit Dachueberstand - \nGrundlaenge Dachflaeche4 ohne Dachueberstand: " << dach.DU[4] << endl; //Quadratmeter Untersichtsbretter (Binderdach)
    
    	cout << "Differenz aus Gratsparrenlaenge1 mit Dachueberstand - \nGratsparrenlaenge1 ohne Dachueberstand (=Gratsturz 1): " << dach.GSt[1] << endl;
    	cout << "Gratsturz 2: " << dach.GSt[2] << endl;
    	cout << "Gratsturz 3: " << dach.GSt[3] << endl;
    	cout << "Gratsturz 4: " << dach.GSt[4] << endl;
    	cout << "\n\n";
    }//ENDE AUSGABE-FUNKTION
    

    Zu den Arrays: Innerhalb der struct zählt man von 1 hoch. Wenn ich also 2 Trauflängen (TL) haben möchte, mache ich TL[2].
    Das hatte ich falsch, da ich davon ausging, dass von 0 hochgezählt wird.
    Wie ist es nun aber bei den Berechnungen und in der Ausgabe?
    Wird hier dann bei TL[0] begonnen oder auch bei TL[1], wenn ich den ersten Wert haben möchte?! Verwirrend! 😕



  • Hallo,

    egal an welcher Stelle du auf das Array zugreifst. Es ist und bleibt immer 0-basiert. Das heißt, dass du auch immer mit Index 0 beginnen musst. - Index 4 gibt es in deinen Arrays eigentlich garnicht mehr.



  • Archy schrieb:

    Anscheinend ist das nicht ok, wenn die struct nicht in die main-Funktion gepackt werden darf. Ich habe allerdings ein Problem damit, dass die struct global ist.

    Der Aufbau der struct muss allen Funktionen bekannt sein, die darauf zugreifen.
    Darum muss diese Definition ausserhalb jeder Funktion gemacht werden. (main ist auch eine Funktion)
    Das ist wie ein neuer Variablentyp (int, float, char)

    Die Variable selber bleibt nur in main.

    Wenn du die Definition der struct nur in einer .cpp-Datei lässt, dann ist es auch nur in dieser Datei bekannt.

    Archy schrieb:

    Das struct hatten wir in der Schule noch gar nicht. Wir sind bis jetzt erst am Anfang von Funktionen. Wir haben gelernt, dass der Prototyp immer den Datentyp enthalten muss. Dementsprechend habe ich "struct" vorangestellt.

    Das ist in C++ nicht nötig (in C jedoch schon). Und es gibt noch typedef .

    Archy schrieb:

    Das verstehe ich nicht. Wie kann der struct-Name hier als Rückgabetyp verwendet werden? Was wird dann zurückgegeben?

    Da wird die ganze struct zurück gegeben. Diese musst du dann noch einer passenden Variable zuweisen.

    Archy schrieb:

    Wieso nehme ich hier eine Konstante?
    Welchen Zweck erfüllt das bzw. was passiert/kann passieren, wenn ich die Konstante weglasse?

    Das ist keine Konstante.
    Damit versicherst du (als Programmiere) dem Compiler, dass in der Funktion nichts an der Variablen geändert wird.
    Ist ja nur die Ausgabe.

    Archy schrieb:

    Das Programm sieht jetzt so aus:

    Schau dir nochmal die Handhabung (definition und Aufruf) von Referenzen an.
    Schalte unbedingt die Compilerwarnungen auf Maximum.
    Beachte die Warnungen und beseitige deren Ursache.
    (behandele sie wie Fehler)

    Der Index von Arrays fängt in C++ immer bei 0 an. Immer.
    ^(Es sei denn, du machst irgendwelche komischen Kunstgriffe)^



  • Eine andere Sache noch:

    Du hast jetzt:

    struct Walmdach {
       // ... deine Variablen
    } dach;
    

    Damit erzeugst du gleich eine Variable namens dach. Aber da solltest du diese noch gar nicht erzeugen! Das sollte erst im main passieren.

    Also:

    struct Walmdach {
       // ... deine Variablen
    };
    
    // hier alles weitere
    
    int main() {
        Walmdach dach;
        // ...
    }
    


  • DirkB schrieb:

    Der Index von Arrays fängt in C++ immer bei 0 an. Immer.

    Das kenne ich auch so. Bei der Arraydeklaration ist das aber nicht so:
    DL[4]; bedeutet, dass ich 4 Werte habe und nicht 5. Hier ist also die Null noch nicht dabei. Bei der Berechnung und Ausgabe muss ich allerdings DL[0] nehmen, um den ersten der 4 Werte anzusprechen. Die Verwendung von DL[4] wäre somit nicht möglich.



  • wob schrieb:

    Eine andere Sache noch:

    Du hast jetzt:

    struct Walmdach {
       // ... deine Variablen
    } dach;
    

    Damit erzeugst du gleich eine Variable namens dach. Aber da solltest du diese noch gar nicht erzeugen! Das sollte erst im main passieren.

    Also:

    struct Walmdach {
       // ... deine Variablen
    };
    
    // hier alles weitere
    
    int main() {
        Walmdach dach;
        // ...
    }
    

    Ach so!!! Jetzt verstehe ich auch, was DirkB meinte. Ich wusste nicht, dass das geht, vielen Dank!
    Damit hat sich dann auch mein Problem mit dem Gültigkeitsbereich behoben.



  • Bei der Definition der Array-Variable gibst du auch die Anzahl der Elemente vom Array an.
    Da ist das kein Index.


Anmelden zum Antworten