Rechnen mit Zeiger-Werten und "normalen" Werten



  • Hallo Leute,

    kann mir einer sagen warum VS mir hier sagt: " Kein "*"-Operator stimmt mit diesen Operanden überein." und " Kein "-"-Operator stimmt mit diesen Operanden überein. " ?

    int AnstiegundVerschiebung(int m, int n, Punkt *X1, Punkt *Y1, Punkt *X2, Punkt *Y2)
    {
    	m = 1.0 * (*Y2 - *Y1) / (*X2 - *X1);
    	n = *Y1 - (*X1 * m);
    	return m,n;
    }
    


  • Wie ist denn der Typ Punkt definiert?

    return m,n; macht nicht das, was du möchtest.
    Meinst du, das ein int der richtige Rückgabetyp für die Steigung ist?

    Nur lokal benutzte Variablen sollten nicht als Paramter der Funktion übergeben werden.



  • DirkB schrieb:

    Wie ist denn der Typ Punkt definiert?

    nur normale Int-Werte im Struct

    struct Punkt
    {
    	int X, Y;
    };
    

    return m,n; macht nicht das, was du möchtest.
    Meinst du, das ein int der richtige Rückgabetyp für die Steigung ist?

    hm stimmt, da würde vieleicht ein double besser sein, zwecks kommazahl usw.

    Nur lokal benutzte Variablen sollten nicht als Paramter der Funktion übergeben werden.

    wie meinst du das genau, sry bin gerade etwas begriffsstuzig



  • Du möchtest als eine struct multiplizieren. Was soll da raus kommen?

    Zudem hat die struct ja schon einen X und Y-Wert.
    Warum dann diese vielen Parameter?

    Was sollen m und n als Paramter?
    Welche Information kommt von außen in die Funktion.
    So wie du sie wervendest sind es lokale Variabeln.



  • DirkB schrieb:

    Du möchtest als eine struct multiplizieren. Was soll da raus kommen?

    Zudem hat die struct ja schon einen X und Y-Wert.
    Warum dann diese vielen Parameter?

    Was sollen m und n als Paramter?
    Welche Information kommt von außen in die Funktion.
    So wie du sie wervendest sind es lokale Variabeln.

    ich hab das ganze jetzt mal etwas umgeschrieben komme aber leider immer noch nicht weiter...

    mein Header:

    #pragma once
    #ifndef PUNKTEUNDLINIEN_H
    #define PUNKTEUNDLINIEN_H
    
    struct Punkt
    {
    	int X, Y;
    };
    
    double AnstiegundVerschiebung(Punkt Punkt1, Punkt Punkt2);
    
    #endif // !PUNKTEUNDLINIEN_H
    

    meine .cpp zum header:

    #include "PunkteundLinien.h"
    
    using namespace std;
    double AnstiegundVerschiebung(Punkt Punkt1, Punkt Punkt2)
    {
    	double m = 1.0 * (Punkt2.Y - Punkt1.Y) / (Punkt2.X - Punkt1.X);
    	double n = Punkt1.Y - (Punkt1.X * m);
    
    	return m, n;
    }
    

    und die main.cpp

    #include <iostream>
    #include "PunkteundLinien.h"
    using namespace std;
    
    int main() {
    
    	Punkt P1, P2;
    
    	cout << "Bitte ersten X-Wert eingeben: ";
    	cin >> P1.X;
    	cout << "Bitte ersten Y-Wert eingeben: ";
    	cin >> P1.Y;
    	do
    	{
    		cout << "Bitte zweiten X-Wert eingeben: ";
    		cin >> P2.X;
    		cout << "Bitte zweiten Y-Wert eingeben: ";
    		cin >> P2.Y;
    	} while ((P1.X == P2.X) || (P1.Y == P2.Y));
    
    	double AnstiegundVerschiebung(P1, P2);
    	system("pause");
    	return 0;
    }
    

    was ich im endeffekt möchte ist dass die steigung und die verschiebung einer geraden berechnet wird und mir ausgegeben wird, allerdings mit struct.



  • hab also jetzt mal den zeiger-kram rausgeschmissen, da werde ich mir später was überlegen, erstmal muss das mit der Rechnung und Ausgabe hinhauen.



  • Was sagt denn der Compiler zu Zeile 21?

    Du berechnest die Steigung falsch.

    Und was ist deine Frage?



  • DirkB schrieb:

    Was sagt denn der Compiler zu Zeile 21?

    naja dass keine passende Konvertierung von punkt zu double vorhanden ist, aber ich weis nicht wie ich das behebe.

    Du berechnest die Steigung falsch.

    das mit der steigung, kann ich später nochmal drüberschauen ist jetzt in soweit unwichtig

    Und was ist deine Frage?

    meine frage ist wie kann ich das nun so schreiben, dass ich meine n,m-werte bekomme?

    Würde es mir helfen wenn ich einen weiteren struc für die n,m-Werte erstelle?



  • ProjectCenix schrieb:

    meine frage ist wie kann ich das nun so schreiben, dass ich meine n,m-werte bekomme?

    Zunächst musst du erstmal den Rückgabewert der Funktion auch verarbeiten.
    Du kannst ihn einer Variablen zuweisen.

    ProjectCenix schrieb:

    Würde es mir helfen wenn ich einen weiteren struc für die n,m-Werte erstelle?

    Ja, das ist eine Möglichkeit, mehr als einen Wert aus einer Funktion zurück zu bekommen.



  • DirkB schrieb:

    ProjectCenix schrieb:

    meine frage ist wie kann ich das nun so schreiben, dass ich meine n,m-werte bekomme?

    Zunächst musst du erstmal den Rückgabewert der Funktion auch verarbeiten.
    Du kannst ihn einer Variablen zuweisen.

    ok stimmt hab ich total verpeilt danke 🙂

    ProjectCenix schrieb:

    Würde es mir helfen wenn ich einen weiteren struc für die n,m-Werte erstelle?

    Ja, das ist eine Möglichkeit, mehr als einen Wert aus einer Funktion zurück zu bekommen.

    hm dann muss ich doch die funktion zu einer struct-funktion umbauen oder?



  • Ich glaube mein knoten im Kopf ist gestern geplatzt,, glaube dass ich die lösung für mein Problem gefunden habe.
    Danke nochmal für die Hilfe.
    Hier mal der Code bisher:
    Header:

    #pragma once
    #ifndef PUNKTEUNDLINIEN_H
    #define PUNKTEUNDLINIEN_H
    
    struct Punkt
    {
    	double X, Y;
    };
    
    struct Gerade
    {
    	double m, n;
    };
    
    Gerade AnstiegundVerschiebung(Punkt Punkt1, Punkt Punkt2);
    
    Punkt Mittelbunktberechnung(Punkt Punkt1, Punkt Punkt2, Gerade Gerade1);
    
    Punkt Punktberechnung(Gerade Gerade1);
    
    Gerade Lotberechnung(Punkt Punkt3, Gerade Gerade1);
    
    Punkt Schnittpunktberechnung(Gerade Gerade1, Gerade Gerade2);
    
    #endif // !PUNKTEUNDLINIEN_H
    

    .cpp zum Header

    #include "PunkteundLinien.h"
    #include <iostream>
    
    using namespace std;
    
    Gerade AnstiegundVerschiebung(Punkt Punkt1, Punkt Punkt2)
    {
    	Gerade Gerade1;
    	Gerade1.m = (Punkt2.Y - Punkt1.Y) / (Punkt2.X - Punkt1.X);	// Anstieg der Geraden
    	Gerade1.n = Punkt1.Y - (Punkt1.X * Gerade1.m);				// Verschiebung der Geraden
    
    	return Gerade1;
    }
    
    Punkt Mittelbunktberechnung(Punkt Punkt1, Punkt Punkt2, Gerade Gerade1)
    {
    	Punkt Punkt12;
    	Punkt12.X = (Punkt1.X + Punkt2.X)*0.5;			//Mittel auf X-Achse
    	Punkt12.Y = Gerade1.m * Punkt12.X + Gerade1.n;	//Mittel auf y-Achse
    
    	return Punkt12;
    }
    
    Punkt Punktberechnung(Gerade Gerade1) //Berechnung eines/mehrerer Punkte auf der Geraden
    {
    	Punkt P;
    
    	do
    	{
    		cin >> P.X;
    		P.Y = Gerade1.m*P.X + Gerade1.n;
    		cout << P.Y << endl;
    	} while (!(P.X == 0.0));
    
    	return P;
    }
    
    Gerade Lotberechnung(Punkt Punkt3, Gerade Gerade1)
    {
    	Gerade Gerade2;
    
    	Gerade2.m = -1.0 / Gerade1.m;
    	Gerade2.n = Punkt3.Y - (Gerade2.m*Punkt3.X);
    
    	return Gerade2;
    }
    
    Punkt Schnittpunktberechnung(Gerade Gerade1, Gerade Gerade2)
    {
    	Punkt P4;
    
    	P4.X = (Gerade2.n - Gerade1.n) / (Gerade1.m - Gerade2.m); //Schnitt auf X-Achse 
    	P4.Y = Gerade1.m*P4.X + Gerade1.n;		//Schnitt auf Y-Achse 
    
    	return P4;
    }
    

    main

    #include <iostream>
    #include "PunkteundLinien.h"
    using namespace std;
    
    int main() {
    
    	Punkt P1, P2, P3, Schnittpunkt, P12, P;
    
    	Gerade G1, G2;
    
    	cout << "Bitte ersten X-Wert eingeben: ";
    	cin >> P1.X;
    	cout << "Bitte ersten Y-Wert eingeben: ";
    	cin >> P1.Y;
    	do												//Zur Vorbeugung vor Punkt auf Punkt
    	{
    		cout << "Bitte zweiten X-Wert eingeben: ";
    		cin >> P2.X;
    		cout << "Bitte zweiten Y-Wert eingeben: ";
    		cin >> P2.Y;
    	} while ((P1.X == P2.X) || (P1.Y == P2.Y));
    
    	G1 = AnstiegundVerschiebung(P1, P2);
    
    	cout << "Anstieg: " << G1.m << endl;
    	cout << "Verschiebung: " << G1.n << endl;
    
    	P12 = Mittelbunktberechnung(P1, P2, G1);
    
    	cout << "Mittelpunkt bei: X=" << P12.X << " und Y=" << P12.Y << endl;
    
    	cout << "Einzelne Punkte auf der Geraden berechnen. Mit X=0 beenden." << endl;
    
    	P = Punktberechnung(G1);
    
    	cout << "Eingabe zu P3: " << endl;
    	cin >> P3.X;
    	cin >> P3.Y;
    
    	cout << "Neuer Punkt P3 bei: (" << P3.X << "," << P3.Y << ")" << endl;
    
    	G2 = Lotberechnung(P3, G1);
    
    	cout << "Normale: y= " << G2.m << "*x+(" << G2.n << ")" << endl;
    
    	Schnittpunkt = Schnittpunktberechnung(G1, G2);
    
    	cout << "Schnittpunkt: (" << Schnittpunkt.X << ", " << Schnittpunkt.Y << ")" << endl;
    
    	system("pause");
    	return 0;
    }
    

Log in to reply