www.matheraum.de
Das Matheforum.
Das Matheforum des MatheRaum.

Für Schüler, Studenten, Lehrer, Mathematik-Interessierte.
Hallo Gast! [ einloggen | registrieren ]
Startseite · Forum · Wissen · Kurse · Mitglieder · Team · Impressum
Forenbaum
^ Forenbaum
Status Mathe
  Status Schulmathe
    Status Primarstufe
    Status Mathe Klassen 5-7
    Status Mathe Klassen 8-10
    Status Oberstufenmathe
    Status Mathe-Wettbewerbe
    Status Sonstiges
  Status Hochschulmathe
    Status Uni-Analysis
    Status Uni-Lin. Algebra
    Status Algebra+Zahlentheo.
    Status Diskrete Mathematik
    Status Fachdidaktik
    Status Finanz+Versicherung
    Status Logik+Mengenlehre
    Status Numerik
    Status Uni-Stochastik
    Status Topologie+Geometrie
    Status Uni-Sonstiges
  Status Mathe-Vorkurse
    Status Organisatorisches
    Status Schule
    Status Universität
  Status Mathe-Software
    Status Derive
    Status DynaGeo
    Status FunkyPlot
    Status GeoGebra
    Status LaTeX
    Status Maple
    Status MathCad
    Status Mathematica
    Status Matlab
    Status Maxima
    Status MuPad
    Status Taschenrechner

Gezeigt werden alle Foren bis zur Tiefe 2

Navigation
 Startseite...
 Neuerdings beta neu
 Forum...
 vorwissen...
 vorkurse...
 Werkzeuge...
 Nachhilfevermittlung beta...
 Online-Spiele beta
 Suchen
 Verein...
 Impressum
Das Projekt
Server und Internetanbindung werden durch Spenden finanziert.
Organisiert wird das Projekt von unserem Koordinatorenteam.
Hunderte Mitglieder helfen ehrenamtlich in unseren moderierten Foren.
Anbieter der Seite ist der gemeinnützige Verein "Vorhilfe.de e.V.".
Partnerseiten
Mathe-Seiten:Weitere Fächer:

Open Source FunktionenplotterFunkyPlot: Kostenloser und quelloffener Funktionenplotter für Linux und andere Betriebssysteme
Startseite > MatheForen > C/C++ > konstruktoren; operatoren
Foren für weitere Schulfächer findest Du auf www.vorhilfe.de z.B. Philosophie • Religion • Kunst • Musik • Sport • Pädagogik
Forum "C/C++" - konstruktoren; operatoren
konstruktoren; operatoren < C/C++ < Programmiersprachen < Praxis < Informatik < Vorhilfe
Ansicht: [ geschachtelt ] | ^ Forum "C/C++"  | ^^ Alle Foren  | ^ Forenbaum  | Materialien

konstruktoren; operatoren: Erklärung
Status: (Frage) beantwortet Status 
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: }

        
Bezug
konstruktoren; operatoren: Antwort
Status: (Antwort) fertig Status 
Datum: 13:33 Mi 09.01.2013
Autor: Event_Horizon

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:




Bezug
                
Bezug
konstruktoren; operatoren: Erklärung
Status: (Frage) beantwortet Status 
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: }

Bezug
                        
Bezug
konstruktoren; operatoren: Antwort
Status: (Antwort) fertig Status 
Datum: 17:04 Do 10.01.2013
Autor: MathePower

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
Bezug
                                
Bezug
konstruktoren; operatoren: Rückfrage
Status: (Frage) beantwortet Status 
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

Bezug
                                        
Bezug
konstruktoren; operatoren: Antwort
Status: (Antwort) fertig Status 
Datum: 15:46 Fr 11.01.2013
Autor: MathePower

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
Bezug
                                                
Bezug
konstruktoren; operatoren: Endergebnis
Status: (Mitteilung) Reaktion unnötig Status 
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: }

Bezug
Ansicht: [ geschachtelt ] | ^ Forum "C/C++"  | ^^ Alle Foren  | ^ Forenbaum  | Materialien


^ Seitenanfang ^
www.matheforum.net
[ Startseite | Forum | Wissen | Kurse | Mitglieder | Team | Impressum ]