konstruktoren; operatoren < C/C++ < Programmiersprachen < Praxis < Informatik < Vorhilfe
|
| Status: |
(Frage) beantwortet  | | Datum: | 22:39 Di 08.01.2013 | | Autor: | pina7 |
| Aufgabe | Erzeugen Sie eine Klasse „Vector“, die einen dreidimensionalen Vektor repräsentieren soll, indem Sie die „Hinzufügen“-Funktion von Visual Studio nutzen.
Verändern Sie die Klasse so, dass der Standardkonstruktor die Koordinaten x, y und z, die Sie als Membervariablen mit den entsprechenden Namen im protected mode zu der Klasse hinzufügen sollen, mit Null initialisiert.
Ergänzen Sie die Klasse um einen Standardkonstruktor, mit dem Sie die Koordinaten x, y und z direkt beim Erzeugen selbst definieren können.
Ergänzen Sie die Klasse um einen Copykonstruktor.
Schreiben Sie eine Funktion length(), die Ihnen die Länge des Vektors zurückgibt.
Schreiben Sie nun die Operatoren + und – um einfache Rechenoperationen zu ermöglichen.
Schreiben Sie einen Operator *, der das Skalarprodukt der beiden Vektoren berechnen soll.
Schreiben Sie einen Operator ^, der das Kreuzprodukt der beiden Vektoren berechnen soll.
Experimentieren Sie in dem Hauptprogramm mit den neuen Funktionen.
Extraaufgaben:
•Können Sie den Abstand zwischen einer Geraden und einem Punkt berechnen lassen? (Mathematik I Vorlesung oder Wikipedia)
•Können Sie den Winkel ausgeben lassen zwischen einem Vektor, den der Benutzer eingegeben hat, und allen Vektoren auf dem Einheitskreis im Abstand von 1 Grad, beginnend mit der x-Achse? |
Hallo. Also bei dieser Aufgabe benötige ich bitte einiges an Erklärungen. Zum einen sind die Konstruktoren noch recht unverständlich für mich und zum anderen fehlt mir ein explizites Beispiel für überladene Operatoren. Ich habe einen noch recht unvollständigen Code, vielleicht kann ich hierzu bitte Eklärung und Hilfestellung bekommen. Vielen Dank dafür!
| 1: |
| | 2: | #pragma once
| | 3: | class Vector
| | 4: | {
| | 5: | protected:
| | 6: | double m_x;
| | 7: | double m_y;
| | 8: | double m_z;
| | 9: |
| | 10: | public:
| | 11: | double x;
| | 12: | double y;
| | 13: | double z;
| | 14: |
| | 15: | Vector::Vector(); //Standardkonstruktor 1
| | 16: | Vector::Vector(double x, double y, double z); //Standardkonstruktor 2
| | 17: | Vector::Vector(const Vector &a); //Copy-Konstruktor
| | 18: |
| | 19: | double getLength();
| | 20: |
| | 21: | Vector operator+ (const Vector& b); //Operatoren überladen
| | 22: | };
| | 23: |
| | 24: |
| | 25: | #include "stdafx.h"
| | 26: | #include <iostream>
| | 27: | #include "Vector.h"
| | 28: | #define _USE_MATH_DEFINES
| | 29: | #include <math.h>
| | 30: |
| | 31: | using namespace std;
| | 32: |
| | 33: | Vector::Vector() //Standardkonstruktor zum initialisieren auf Null
| | 34: | {
| | 35: | m_x = x;
| | 36: | m_y = y;
| | 37: | m_z = z;
| | 38: |
| | 39: | x = 0.0;
| | 40: | y = 0.0;
| | 41: | z = 0.0;
| | 42: | }
| | 43: |
| | 44: | Vector::Vector(double x, double y, double z) //Standardkonstruktor zum definieren der Variablen
| | 45: | {
| | 46: | cout << "Eingabe von x: " << endl << endl;
| | 47: | cin >> x;
| | 48: | cout << "Eingabe von y: " << endl << endl;
| | 49: | cin >> y;
| | 50: | cout << "Eingabe von z: " << endl << endl;
| | 51: | cin >> z;
| | 52: | }
| | 53: |
| | 54: | //Copykonstruktor hier noch nennen?
| | 55: |
| | 56: | //wie geht das mit den Operatoren?
| | 57: |
| | 58: | double Vector::getLength()
| | 59: | {
| | 60: | double Length = 0.0;
| | 61: |
| | 62: | Length = sqrt((pow(m_x,2.0) + pow(m_y,2.0) + pow(m_z,2.0)));
| | 63: |
| | 64: | return Length;
| | 65: | }
| | 66: |
| | 67: | int _tmain(int argc, _TCHAR* argv[])
| | 68: | {
| | 69: | Vector MyVector1;
| | 70: |
| | 71: | Vector MyVector2; //so oder wird Vektor Nr 2 durch Copykonstruktor erzeugt?
| | 72: |
| | 73: | Vector::Vector(MyVector1);
| | 74: |
| | 75: | Vector::Vector(MyVector2);
| | 76: |
| | 77: | // Vector::Vector(double x, double y, double z) wie richtig?
| | 78: |
| | 79: | cout << "Eine Vektorklasse" << endl << endl;
| | 80: |
| | 81: | MyVector1.getLength();
| | 82: |
| | 83: | MyVector2.getLength();
| | 84: |
| | 85: | system("pause");
| | 86: | return 0;
| | 87: | }
|
|
|
| |
|
Hallo!
| 1: |
| | 2: | > #pragma once
| | 3: | > class Vector
| | 4: | > {
| | 5: | > protected:
| | 6: | > double m_x;
| | 7: | > double m_y;
| | 8: | > double m_z;
| | 9: | >
| | 10: | > public:
| | 11: | > double x;
| | 12: | > double y;
| | 13: | > double z;
| | 14: |
|
x, y, z brauchst du nicht.
| 1: |
| | 2: | > Vector::Vector() //Standardkonstruktor zum initialisieren
| | 3: | > auf Null
| | 4: | > {
| | 5: | > m_x = x;
| | 6: | > m_y = y;
| | 7: | > m_z= z;
| | 8: | >
| | 9: | > x = 0.0;
| | 10: | > y = 0.0;
| | 11: | > z = 0.0;
| | 12: | > }
| | 13: |
|
deshalb hier die unteren drei Anweisungen entfernen, und in die oberen drei direkt =0.0 schreiben.
| 1: |
| | 2: |
| | 3: | >
| | 4: | > Vector::Vector(double x, double y, double z)
| | 5: | > //Standardkonstruktor zum definieren der Variablen
| | 6: | > {
| | 7: | > cout << "Eingabe von x: " << endl << endl;
| | 8: | > cin >> x;
| | 9: | > cout << "Eingabe von y: " << endl << endl;
| | 10: | > cin >> y;
| | 11: | > cout << "Eingabe von z: " << endl << endl;
| | 12: | > cin >> z;
| | 13: | > }
| | 14: |
|
Hier heißt es einfach:
| 1: |
| | 2: | Vector::Vector(double x, double y, double z)
| | 3: | //Standardkonstruktor zum definieren der Variablen
| | 4: | {
| | 5: | m_x=x;
| | 6: | m_y=y;
| | 7: | m_z=z;
| | 8: | }
| | 9: |
|
weil die Zahlenwerte werden dem Konstruktor ja in x, y und z übergeben. Die mußt du in die internen Variablen packen.
>
> //Copykonstruktor hier noch nennen?
Ja, das macht Sinn. Das geht so:
| 1: |
| | 2: | Vector(Vector &Vec){
| | 3: | m_x=Vec.m_x;
| | 4: | //...
| | 5: | }
|
d.h. du muß sämtliche Werte von Variablen aus dem übergebenen Vektor in die entsprechen Variablen der eigenen Instanz kopieren.
> //wie geht das mit den Operatoren?
Im Prinzip willst du später sowas schreiben können wie
A=B+C;
wobei alle drei Variablen Vektoren sind. Das geht dann so:
| 1: |
| | 2: | Vector operator+(Vector C){
| | 3: | Vector ergebnis;
| | 4: |
| | 5: | //Hier steht Code, der die vektorielle Summe von dieser Instanz (das wäre B) sowie der übergebenen (C) berechnet und in ergebnis ablegt
| | 6: |
| | 7: | return ergebnis;
| | 8: | }
| | 9: |
|
|
|
|
| |
|
| Status: |
(Frage) beantwortet | | Datum: | 21:35 Mi 09.01.2013 | | Autor: | pina7 |
Hallo und vielen Dank für deine Erklärungen.
Ich bin nun ein bisschen weitergekommen. In meinem nachstehenden Code sind meine Fragen/Probleme auskommentiert. Ich würde mich freuen, wenn ich hier wieder Erklärung zu bekommen kann. Danke 
| 1: |
| | 2: | Vector.h
| | 3: | #pragma once
| | 4: | class Vector
| | 5: | {
| | 6: | protected:
| | 7: | double m_x;
| | 8: | double m_y;
| | 9: | double m_z;
| | 10: |
| | 11: | public:
| | 12: | Vector::Vector(); //Standardkonstruktor 1
| | 13: | Vector::Vector(double x, double y, double z); //Standardkonstruktor 2
| | 14: | Vector::Vector(Vector &Vec); //Copy-Konstruktor; noch fehlerhaft zumindest in .cpp --> wie richtig?
| | 15: |
| | 16: | double getLength();
| | 17: |
| | 18: | Vector Vector::operator+ (const Vector& C) //Operatoren; ist das so richtig? Steht das in der Klasse?
| | 19: | {
| | 20: | Vector Ergebnis;
| | 21: |
| | 22: | Ergebnis.m_x = m_x + C.m_x;
| | 23: | Ergebnis.m_y = m_y + C.m_y;
| | 24: | Ergebnis.m_z = m_z + C.m_z;
| | 25: |
| | 26: | return Ergebnis;
| | 27: | }
| | 28: | };
| | 29: |
| | 30: | EineVektorklasse.cpp
| | 31: | #include "stdafx.h"
| | 32: | #include <iostream>
| | 33: | #include "Vector.h"
| | 34: | #define _USE_MATH_DEFINES
| | 35: | #include <math.h>
| | 36: |
| | 37: | using namespace std;
| | 38: |
| | 39: | Vector::Vector() //Standardkonstruktor zum initialisieren auf Null
| | 40: | {
| | 41: | m_x = 0.0;
| | 42: | m_y = 0.0;
| | 43: | m_z = 0.0;
| | 44: | }
| | 45: |
| | 46: | Vector::Vector(double x, double y, double z) //Standardkonstruktor zum definieren der Variablen
| | 47: | {
| | 48: | m_x = x;
| | 49: | m_y = y;
| | 50: | m_z = z;
| | 51: | }
| | 52: |
| | 53: | Vector(Vector &Vec) //Copykonstruktor; noch fehlerhaft
| | 54: | //Error: Diese Deklaration hat keine Speicherklasse oder keinen Typspezifizierer.
| | 55: | {//Error: Es wurde eine Deklaration erwartet.
| | 56: | m_x = Vec.m_x;
| | 57: | m_y = Vec.m_y;
| | 58: | m_z = Vec.m_z;
| | 59: | }
| | 60: |
| | 61: | double Vector::getLength()
| | 62: | {
| | 63: | double Length = 0.0;
| | 64: |
| | 65: | Length = sqrt((pow(m_x,2.0) + pow(m_y,2.0) + pow(m_z,2.0)));
| | 66: |
| | 67: | return Length;
| | 68: | }
| | 69: |
| | 70: | int _tmain(int argc, _TCHAR* argv[])
| | 71: | {
| | 72: | Vector A; //Objekt A wird erzeugt
| | 73: | Vector B; //Objekt B wird erzeugt
| | 74: |
| | 75: | double x; //muss, kann, soll ich die hier aufführen oder soll der Benutzer die Werte gar nicht eingeben?
| | 76: | double y;
| | 77: | double z;
| | 78: |
| | 79: | cout << "Eingabe von x: " << endl << endl;
| | 80: | cin >> x;
| | 81: | cout << "Eingabe von y: " << endl << endl;
| | 82: | cin >> y;
| | 83: | cout << "Eingabe von z: " << endl << endl;
| | 84: | cin >> z;
| | 85: |
| | 86: | Vector::Vector(A);
| | 87: | Vector::Vector(B);
| | 88: |
| | 89: | cout << "Eine Vektorklasse" << endl << endl;
| | 90: |
| | 91: | cout << "Laenge des Vektors A: " << A.getLength() << endl << endl;
| | 92: | cout << "Laenge des Vektors B: " << B.getLength() << endl << endl;
| | 93: |
| | 94: |
| | 95: | system("pause");
| | 96: | return 0;
| | 97: | }
|
|
|
|
| |
|
Hallo pina7,
> Hallo und vielen Dank für deine Erklärungen.
> Ich bin nun ein bisschen weitergekommen. In meinem
> nachstehenden Code sind meine Fragen/Probleme
> auskommentiert. Ich würde mich freuen, wenn ich hier
> wieder Erklärung zu bekommen kann. Danke
>
> | 1: |
| | 2: | > Vector.h
| | 3: | > #pragma once
| | 4: | > class Vector
| | 5: | > {
| | 6: | > protected:
| | 7: | > double [mm]m_x;[/mm]
| | 8: | > double [mm]m_y;[/mm]
| | 9: | > double [mm]m_z;[/mm]
| | 10: | >
| | 11: | > public:
| | 12: | > Vector::Vector(); //Standardkonstruktor 1
| | 13: | > Vector::Vector(double x, double y, double z);
| | 14: | > //Standardkonstruktor 2
| | 15: | > Vector::Vector(Vector &Vec); //Copy-Konstruktor; noch
| | 16: | > fehlerhaft zumindest in .cpp --> wie richtig?
| | 17: | >
| | 18: | > double getLength();
| | 19: | >
| | 20: | > Vector Vector::operator+ (const Vector& C) //Operatoren;
| | 21: | > ist das so richtig? Steht das in der Klasse?
| | 22: | > {
| | 23: | > Vector Ergebnis;
| | 24: | >
| | 25: | > [mm] Ergebnis.m_x[/mm] = [mm]m_x[/mm] + [mm]C.m_x;[/mm]
| | 26: | > [mm] Ergebnis.m_y[/mm] = [mm]m_y[/mm] + [mm]C.m_y;[/mm]
| | 27: | > [mm] Ergebnis.m_z[/mm] = [mm]m_z[/mm] + [mm]C.m_z;[/mm]
| | 28: | >
| | 29: | > return Ergebnis;
| | 30: | > }
| | 31: | > };
| | 32: | >
| | 33: | > EineVektorklasse.cpp
| | 34: | > #include "stdafx.h"
| | 35: | > #include <iostream>
| | 36: | > #include "Vector.h"
| | 37: | > #define _USE_MATH_DEFINES
| | 38: | > #include <math.h>
| | 39: | >
| | 40: | > using namespace std;
| | 41: | >
| | 42: | > Vector::Vector() //Standardkonstruktor zum initialisieren
| | 43: | > auf Null
| | 44: | > {
| | 45: | > [mm] m_x[/mm] = 0.0;
| | 46: | > [mm] m_y[/mm] = 0.0;
| | 47: | > [mm] m_z[/mm] = 0.0;
| | 48: | > }
| | 49: | >
| | 50: | > Vector::Vector(double x, double y, double z)
| | 51: | > //Standardkonstruktor zum definieren der Variablen
| | 52: | > {
| | 53: | > [mm] m_x[/mm] = x;
| | 54: | > [mm] m_y[/mm] = y;
| | 55: | > [mm] m_z[/mm] = z;
| | 56: | > }
| | 57: | >
| | 58: | > Vector(Vector &Vec) //Copykonstruktor; noch fehlerhaft
| | 59: | > //Error: Diese Deklaration hat keine Speicherklasse oder
| | 60: | > keinen Typspezifizierer.
| | 61: | > {//Error: Es wurde eine Deklaration erwartet.
| | 62: | > [mm] m_x[/mm] = [mm]Vec.m_x;[/mm]
| | 63: | > [mm] m_y[/mm] = [mm]Vec.m_y;[/mm]
| | 64: | > [mm] m_z[/mm] = [mm]Vec.m_z;[/mm]
| | 65: | > }
| | 66: | >
| | 67: | > double Vector::getLength()
| | 68: | > {
| | 69: | > double Length = 0.0;
| | 70: | >
| | 71: | > Length = [mm]sqrt((pow(m_x,2.0)[/mm] + [mm]pow(m_y,2.0)[/mm] +
| | 72: | > [mm]pow(m_z,2.0)));[/mm]
| | 73: | >
| | 74: | > return Length;
| | 75: | > }
| | 76: | >
| | 77: | > int _tmain(int argc, _TCHAR* argv[])
| | 78: | > {
| | 79: | > Vector A; //Objekt A wird erzeugt
| | 80: | > Vector B; //Objekt B wird erzeugt
| | 81: | >
| | 82: | > double x; //muss, kann, soll ich die hier aufführen oder
| | 83: | > soll der Benutzer die Werte gar nicht eingeben?
| | 84: | > double y;
| | 85: | > double z;
| | 86: | >
| | 87: | > cout << "Eingabe von x: " << endl << endl;
| | 88: | > cin >> x;
| | 89: | > cout << "Eingabe von y: " << endl << endl;
| | 90: | > cin >> y;
| | 91: | > cout << "Eingabe von z: " << endl << endl;
| | 92: | > cin >> z;
| | 93: | >
| | 94: | > Vector::Vector(A);
| | 95: | > Vector::Vector(B);
| | 96: | >
| | 97: | > cout << "Eine Vektorklasse" << endl << endl;
| | 98: | >
| | 99: | > cout << "Laenge des Vektors A: " << A.getLength() << endl
| | 100: | > << endl;
| | 101: | > cout << "Laenge des Vektors B: " << B.getLength() << endl
| | 102: | > << endl;
| | 103: | >
| | 104: | >
| | 105: | > system("pause");
| | 106: | > return 0;
| | 107: | > }
| | 108: | > |
Der Copy-Konstruktor muss doch so lauten:
Vector::Vector(const Vector &Vec);
Da die Referenz nicht verändert werden soll.
Die Deklaration von operator+ ist richtig.
Deren Quellcode kann sowohl in der Header-Datei
als auch in der cpp-Datei stehen.
Willst Du die Vektoren A und B initialisieren,
so sind die Variablen x,y,z im main-Programm aufzuführen.
Gruss
MathePower
|
|
|
| |
|
| Status: |
(Frage) beantwortet | | Datum: | 20:25 Do 10.01.2013 | | Autor: | pina7 |
Hallo. Und danke. Hier der neue code:
| 1: |
| | 2: | class Vector
| | 3: | {
| | 4: | protected:
| | 5: | double m_x;
| | 6: | double m_y;
| | 7: | double m_z;
| | 8: |
| | 9: | public:
| | 10: | Vector::Vector(); //Standardkonstruktor 1
| | 11: | Vector::Vector(double x, double y, double z); //Standardkonstruktor 2
| | 12: | Vector::Vector(const Vector &Vec) //Copy-Konstruktor
| | 13: | {
| | 14: | m_x = Vec.m_x;
| | 15: | m_y = Vec.m_y;
| | 16: | m_z = Vec.m_z;
| | 17: | }
| | 18: |
| | 19: | double getLength();
| | 20: |
| | 21: | Vector Vector::operator+ (const Vector& C)
| | 22: | {
| | 23: | Vector Ergebnis;
| | 24: |
| | 25: | Ergebnis.m_x = m_x + C.m_x;
| | 26: | Ergebnis.m_y = m_y + C.m_y;
| | 27: | Ergebnis.m_z = m_z + C.m_z;
| | 28: |
| | 29: | return Ergebnis;
| | 30: | }
| | 31: | };
| | 32: |
| | 33: | #include "stdafx.h"
| | 34: | #include <iostream>
| | 35: | #include "Vector.h"
| | 36: | #define _USE_MATH_DEFINES
| | 37: | #include <math.h>
| | 38: |
| | 39: | using namespace std;
| | 40: |
| | 41: | Vector::Vector() //Standardkonstruktor zum initialisieren auf Null
| | 42: | {
| | 43: | m_x = 0.0;
| | 44: | m_y = 0.0;
| | 45: | m_z = 0.0;
| | 46: | }
| | 47: |
| | 48: | Vector::Vector(double x, double y, double z) //Standardkonstruktor zum definieren der Variablen
| | 49: | {
| | 50: | m_x = x;
| | 51: | m_y = y;
| | 52: | m_z = z;
| | 53: | }
| | 54: |
| | 55: | double Vector::getLength()
| | 56: | {
| | 57: | double Length = 0.0;
| | 58: |
| | 59: | Length = sqrt((pow(m_x,2.0) + pow(m_y,2.0) + pow(m_z,2.0)));
| | 60: |
| | 61: | return Length;
| | 62: | }
| | 63: |
| | 64: | int _tmain(int argc, _TCHAR* argv[])
| | 65: | {
| | 66: | Vector A; //Objekt A wird erzeugt
| | 67: | Vector B; //Objekt B wird erzeugt
| | 68: |
| | 69: | double x;
| | 70: | double y;
| | 71: | double z;
| | 72: |
| | 73: | cout << "Eingabe von x: " << endl << endl;
| | 74: | cin >> x;
| | 75: | cout << "Eingabe von y: " << endl << endl;
| | 76: | cin >> y;
| | 77: | cout << "Eingabe von z: " << endl << endl;
| | 78: | cin >> z;
| | 79: |
| | 80: | Vector::Vector(A); //was genau passiert hier?
| | 81: | Vector::Vector(B);
| | 82: |
| | 83: | cout << "Eine Vektorklasse" << endl << endl;
| | 84: |
| | 85: | cout << "Laenge des Vektors A: " << A.getLength() << endl << endl;
| | 86: | cout << "Laenge des Vektors B: " << B.getLength() << endl << endl;
| | 87: |
| | 88: | cout << "Vektor A + B = " << // Wie rufe ich nun den Operator auf?
| | 89: |
| | 90: | system("pause");
| | 91: | return 0;
| | 92: | }
|
Hier meine Fragen
1) Das Programm gibt als Länge der Vektoren Null als Ergebnis (bei x=1, y=2 und z = 3 getestet). Warum?
2) Haben dann die Vektoren A und B die gleichen Variablen mit den gleichen Werten? Was kann ich tun, damit die beiden verschiedene Werte bekommen?
3) Kann ich den Kopierkonstruktor nur in der .h Klassendatei definieren? Wenn man das auch in der .cpp machen kann, wie?
4) Muss ich den Kopierkonstruktor der in der Klasse definiert wurde in ,cpp aufrufen? Oder in main?
5) Habe ich das aus der Aufgabe richtig verstanden, dass die Variablen durch den Benutzer eingegeben werden sollen oder was genau ist mit definieren beim Erzeugen gemeint?
6) In der main bei Vector::Vector(A); was passiert da genau?
7) Habe ich noch was in der main vergessen?
8) Wie rufe ich den Operator auf also dass auch wirklich A und B addiert werden?
Ich danke sehr für die Antworten! Grüße, Pina
|
|
|
| |
|
Hallo pina7,
> Hallo. Und danke. Hier der neue code:
>
> | 1: |
| | 2: | > class Vector
| | 3: | > {
| | 4: | > protected:
| | 5: | > double [mm]m_x;[/mm]
| | 6: | > double [mm]m_y;[/mm]
| | 7: | > double [mm]m_z;[/mm]
| | 8: | >
| | 9: | > public:
| | 10: | > Vector::Vector(); //Standardkonstruktor 1
| | 11: | > Vector::Vector(double x, double y, double z);
| | 12: | > //Standardkonstruktor 2
| | 13: | > Vector::Vector(const Vector &Vec) //Copy-Konstruktor
| | 14: | > {
| | 15: | > [mm] m_x[/mm] = [mm]Vec.m_x;[/mm]
| | 16: | > [mm] m_y[/mm] = [mm]Vec.m_y;[/mm]
| | 17: | > [mm] m_z[/mm] = [mm]Vec.m_z;[/mm]
| | 18: | > }
| | 19: | >
| | 20: | > double getLength();
| | 21: | >
| | 22: | > Vector Vector::operator+ (const Vector& C)
| | 23: | > {
| | 24: | > Vector Ergebnis;
| | 25: | >
| | 26: | > [mm] Ergebnis.m_x[/mm] = [mm]m_x[/mm] + [mm]C.m_x;[/mm]
| | 27: | > [mm] Ergebnis.m_y[/mm] = [mm]m_y[/mm] + [mm]C.m_y;[/mm]
| | 28: | > [mm] Ergebnis.m_z[/mm] = [mm]m_z[/mm] + [mm]C.m_z;[/mm]
| | 29: | >
| | 30: | > return Ergebnis;
| | 31: | > }
| | 32: | > };
| | 33: | >
| | 34: | > #include "stdafx.h"
| | 35: | > #include <iostream>
| | 36: | > #include "Vector.h"
| | 37: | > #define _USE_MATH_DEFINES
| | 38: | > #include <math.h>
| | 39: | >
| | 40: | > using namespace std;
| | 41: | >
| | 42: | > Vector::Vector() //Standardkonstruktor zum initialisieren
| | 43: | > auf Null
| | 44: | > {
| | 45: | > [mm] m_x[/mm] = 0.0;
| | 46: | > [mm] m_y[/mm] = 0.0;
| | 47: | > [mm] m_z[/mm] = 0.0;
| | 48: | > }
| | 49: | >
| | 50: | > Vector::Vector(double x, double y, double z)
| | 51: | > //Standardkonstruktor zum definieren der Variablen
| | 52: | > {
| | 53: | > [mm] m_x[/mm] = x;
| | 54: | > [mm] m_y[/mm] = y;
| | 55: | > [mm] m_z[/mm] = z;
| | 56: | > }
| | 57: | >
| | 58: | > double Vector::getLength()
| | 59: | > {
| | 60: | > double Length = 0.0;
| | 61: | >
| | 62: | > Length = [mm]sqrt((pow(m_x,2.0)[/mm] + [mm]pow(m_y,2.0)[/mm] +
| | 63: | > [mm]pow(m_z,2.0)));[/mm]
| | 64: | >
| | 65: | > return Length;
| | 66: | > }
| | 67: | >
| | 68: | > int _tmain(int argc, _TCHAR* argv[])
| | 69: | > {
| | 70: | > Vector A; //Objekt A wird erzeugt
| | 71: | > Vector B; //Objekt B wird erzeugt
| | 72: | >
| | 73: | > double x;
| | 74: | > double y;
| | 75: | > double z;
| | 76: | >
| | 77: | > cout << "Eingabe von x: " << endl << endl;
| | 78: | > cin >> x;
| | 79: | > cout << "Eingabe von y: " << endl << endl;
| | 80: | > cin >> y;
| | 81: | > cout << "Eingabe von z: " << endl << endl;
| | 82: | > cin >> z;
| | 83: | >
| | 84: | > Vector::Vector(A); //was genau passiert hier?
| | 85: | > Vector::Vector(B);
| | 86: | >
| | 87: | > cout << "Eine Vektorklasse" << endl << endl;
| | 88: | >
| | 89: | > cout << "Laenge des Vektors A: " << A.getLength() << endl
| | 90: | > << endl;
| | 91: | > cout << "Laenge des Vektors B: " << B.getLength() << endl
| | 92: | > << endl;
| | 93: | >
| | 94: | > cout << "Vektor A + B = " << // Wie rufe ich nun den
| | 95: | > Operator auf?
| | 96: | >
| | 97: | > system("pause");
| | 98: | > return 0;
| | 99: | > }
| | 100: | > |
> Hier meine Fragen
> 1) Das Programm gibt als Länge der Vektoren Null als
> Ergebnis (bei x=1, y=2 und z = 3 getestet). Warum?
Weil beim Erzeugen eines Objektes der Klasse Vector,
dieser mit den Standardwerten x=y=z=0 initialisiert wurde.
> 2) Haben dann die Vektoren A und B die gleichen Variablen
Nein.
> mit den gleichen Werten? Was kann ich tun, damit die beiden
> verschiedene Werte bekommen?
Den Benutzer nochmal auffordern, Werte für x, y und z einzugeben.
> 3) Kann ich den Kopierkonstruktor nur in der .h
> Klassendatei definieren? Wenn man das auch in der .cpp
> machen kann, wie?
In der Header-Datei geht das so: Vector(const Vector &Vec)
In der Cpp-Datei so: Vector::Vector(const Vector &Vec)
> 4) Muss ich den Kopierkonstruktor der in der Klasse
> definiert wurde in ,cpp aufrufen? Oder in main?
In main.
main steht doch in der cpp-Datei.
> 5) Habe ich das aus der Aufgabe richtig verstanden, dass
> die Variablen durch den Benutzer eingegeben werden sollen
> oder was genau ist mit definieren beim Erzeugen gemeint?
> 6) In der main bei Vector::Vector(A); was passiert da
> genau?
Da das Objekt A der Klasse Vektor schon einmal erzeugt wurde,
meldet der Compiler einen Fehler.
> 7) Habe ich noch was in der main vergessen?
> 8) Wie rufe ich den Operator auf also dass auch wirklich A
> und B addiert werden?
Erzeuge ein Objekt C der Klasse Vektor.
Dann lautet die Befehlszeil: C=A+B;
Willst Du den Vektor so ausgeben: cout << C << endl,
dann ist eine eigene Ausgaberoutine zu schreiben.
>
> Ich danke sehr für die Antworten! Grüße, Pina
>
Gruss
MathePower
|
|
|
| |
|
| Status: |
(Mitteilung) Reaktion unnötig  | | Datum: | 22:41 Fr 11.01.2013 | | Autor: | pina7 |
Vielen Dank! Dank eurer Hilfe und Nachhilfestunde habe ich es recht gut verstanden. Der endgültige code sieht nun so aus:
| 1: |
| | 2: | class Vector
| | 3: | {
| | 4: | protected:
| | 5: | double m_x;
| | 6: | double m_y;
| | 7: | double m_z;
| | 8: |
| | 9: | public:
| | 10: | Vector(void); //Standardkonstruktor 1
| | 11: | Vector(double nx, double ny, double nz); //Standardkonstruktor 2
| | 12: | Vector(Vector &v); //Copy-Konstruktor
| | 13: |
| | 14: | double getLength();
| | 15: | void print(); //Ausgabe der Werte
| | 16: |
| | 17: | Vector operator+ (const Vector& C);
| | 18: | Vector operator- (const Vector& C);
| | 19: | double operator* (const Vector& C); //Skalarprodukt zweier Vektoren
| | 20: | Vector operator^ (const Vector& C); //Kreuzprodukt zweier Vektoren
| | 21: | };
| | 22: |
| | 23: | #include "stdafx.h"
| | 24: | #include <iostream>
| | 25: | #include "Vector.h"
| | 26: | #define _USE_MATH_DEFINES
| | 27: | #include <math.h>
| | 28: |
| | 29: | using namespace std;
| | 30: |
| | 31: | Vector::Vector(void) //Standardkonstruktor zum initialisieren auf Null
| | 32: | : m_x(0), m_y(0), m_z(0)
| | 33: | {
| | 34: | }
| | 35: |
| | 36: | Vector::Vector(double nx, double ny, double nz) //Standardkonstruktor zum definieren der Variablen
| | 37: | : m_x(nx), m_y(ny), m_z(nz)
| | 38: | {
| | 39: | }
| | 40: |
| | 41: | Vector::Vector(Vector &v) //Copykonstruktor
| | 42: | : m_x(v.m_x), m_y(v.m_y), m_z(v.m_z)
| | 43: | {
| | 44: | }
| | 45: |
| | 46: | double Vector::getLength()
| | 47: | {
| | 48: | double Length = 0.0;
| | 49: | Length = sqrt((pow(m_x,2.0) + pow(m_y,2.0) + pow(m_z,2.0)));
| | 50: | return Length;
| | 51: | }
| | 52: |
| | 53: | void Vector::print()
| | 54: | {
| | 55: | cout << "x: " << m_x << " y: " << m_y << " z: " << m_z << endl << endl;
| | 56: | }
| | 57: |
| | 58: | Vector Vector::operator+ (const Vector& C)
| | 59: | {
| | 60: | Vector Ergebnis;
| | 61: | Ergebnis.m_x = m_x + C.m_x;
| | 62: | Ergebnis.m_y = m_y + C.m_y;
| | 63: | Ergebnis.m_z = m_z + C.m_z;
| | 64: | return Ergebnis;
| | 65: | }
| | 66: |
| | 67: | Vector Vector::operator- (const Vector& C)
| | 68: | {
| | 69: | Vector Ergebnis;
| | 70: | Ergebnis.m_x = m_x - C.m_x;
| | 71: | Ergebnis.m_y = m_y - C.m_y;
| | 72: | Ergebnis.m_z = m_z - C.m_z;
| | 73: | return Ergebnis;
| | 74: | }
| | 75: |
| | 76: | double Vector::operator* (const Vector& C) //Skalarprodukt zweier Vektoren
| | 77: | {
| | 78: | double Skalarprodukt;
| | 79: | Skalarprodukt = m_x * C.m_x + m_y * C.m_y + m_z * C.m_y;
| | 80: | return Skalarprodukt;
| | 81: | }
| | 82: |
| | 83: | Vector Vector::operator^ (const Vector& C)
| | 84: | {
| | 85: | Vector Ergebnis;
| | 86: | Ergebnis.m_x = m_y * C.m_z - m_z * C.m_y;
| | 87: | Ergebnis.m_y = m_z * C.m_x - m_x * C.m_z;
| | 88: | Ergebnis.m_z = m_x * C.m_y - m_y * C.m_x;
| | 89: | return Ergebnis;
| | 90: | }
| | 91: |
| | 92: | int _tmain(int argc, _TCHAR* argv[])
| | 93: | {
| | 94: | double x;
| | 95: | double y;
| | 96: | double z;
| | 97: |
| | 98: | cout << "Eine Vektorklasse" << endl << endl;
| | 99: |
| | 100: | x = 1;
| | 101: | y = 0;
| | 102: | z = 0;
| | 103: | Vector A(x,y,z);
| | 104: |
| | 105: | x = 0;
| | 106: | y = 1;
| | 107: | z = 0;
| | 108: | Vector B(x,y,z);
| | 109: |
| | 110: | cout << "Vektor A = ";
| | 111: | A.print();
| | 112: |
| | 113: | cout << "Vektor B = ";
| | 114: | B.print();
| | 115: |
| | 116: | cout << endl << "Laenge des Vektors A: " << A.getLength() << endl << endl;
| | 117: | cout << endl << "Laenge des Vektors B: " << B.getLength() << endl << endl;
| | 118: |
| | 119: | Vector C = A + B;
| | 120: | cout << "Vektor A + B = ";
| | 121: | C.print();
| | 122: |
| | 123: | Vector D = A - B;
| | 124: | cout << "Vektor A - B = ";
| | 125: | D.print();
| | 126: |
| | 127: | cout << "Skalarprodukt aus A und B = " << A * B << endl << endl;
| | 128: |
| | 129: | Vector E = A ^ B;
| | 130: | cout << "Das Kreuzprodukt aus A und B lautet: ";
| | 131: | E.print();
| | 132: |
| | 133: | system("pause");
| | 134: | return 0;
| | 135: | }
|
|
|
|
|
