C++ Klassenbedingtes Problem mit Datenübergabe

[Chippo]

Oh Mann, wo fange ich an?
Ich bin blutiger Anfänger was C++ angeht. Habe zwar einen Dozenten, der allerdings sehr sprunghaft beim erklären ist und nur einmal in der Woche aufkreuzt. Um sich dann gleichzeitig mit Netzwerkern und Kaufleuten rumzuplagen. Und jetzt komme ich als Softwareentwickler noch dazu. Armer Kerl.

Jedenfalls versuche ich erst einmal das Problem zu skizzieren und hänge denn Code noch ein. Schon mal im Voraus: Wer lacht, stirbt!


Das Programm besteht aus denn Teilen Main, Eingabe, Ausgabe, Daten und Verarbeitung (der letzte Part ist zur Zeit noch unwichtig) und ihren Headern.
Eingabe und Ausgabe sind klassenlos während Daten Klasse ist und entsprechend anzusprechen sind. E/A sind vor allem deswegen klassenlos, weil ich Probleme hatte diese Teil von Main aus als Klasse anzusprechen.
Über Main werden E/A und Verarbeitung einzeln aufgerufen, Main dient also als Hub.

Wie später aus dem Code zu erlesen geht es um die Eingabe und Verarbeitung von IPs bzw. Subnet-Adressen. Für IP und SN wird die gleiche Eingabe-Routine verwendet. Die Unterscheidung beim übergeben der IPs in die Datenbank wird über ein Parameter entschieden der von Main mit dem Funktions/Methodenaufruf gesendet wird.


Jetzt zum Problem (stellt euch vor, ich komme zum Punkt^^):
Ich kann lediglich nur von Eingabe auf die Datenbank (also Daten) zugreifen. Schreiben und Lesen ist kein Problem. Von daher die Tunnel die ins privat führen sind funktionstüchtig. Über Ausgabe und selbst von Main aus komme ich nicht an die Daten ran...
Mir ist eigentlich klar, warum. Und andererseits auch nicht.
Das Problem liegt in der Zeile, in der ich von Daten die Variablen definiere:
Also Daten ip1, ip2, ip3, ip4; (IPx sind die übrigens die Oketten).

Das Problem ist nur, einerseits sind es doch nur Labels, damit der Compiler weiß was wozu gehört. Daher ich habe es schon mal mit Affen versucht, geht trotzdem
Aber zusätzlich ist die Zuordnung nicht global. Was auch dumm wäre weil es die Haupteigenschaft von Klassen unterminieren würde. Andererseits muss ich in jedem Programmteil diese Definieren erneut durchführen um überhaupt von dort aus (bsp. Ausgabe) auf die Datenabruffunktionen zugreifen zu können).
Technisch ist das weniger ein Problem, da - sowie ich das verstehe -diese Definition nur die Voraussetzung schafft, damit Daten überhaupt fließen können, ohne Wertung und überhaupt Daten fließen dürfen.

Damit Eingabe.cpp überhaupt funktioniert wurde die Definierung global vollzogen (oder zu mindestens in Rahmen von Eingabe.cpp. Funktioniert auch ausgezeichnet, nur eben nur von dort.
Die eigentlich Frage ist, wie bekomme ich denn Compiler dazu, zu begreifen das Daten theoretisch von überall aufrufbar ist, aber praktisch nur wenn ich es sage?
Um das Problem mal mit Hilfe Auto (es sind immer Autos...) zu versinnbildlichen.
Mein Auto kann bremsen, aber nur wenn ich zuvor eine scharfe Rechtskurve gefahren bin...
und da gibt es Leute die sich nur über verschobene Fußmatten aufregen.

Ich habe schon versucht selbst eine Lösung zu finden. Mit Hilfe von Try and Fail, stundenlanges googlen (wobei nicht auszuschließen ist, das ich nichts fand, da ich immer noch Probleme habe die Frage zu formulieren), meinen Dozenten und dessen eigens gewartete Ilias.
Die Lernplattform an sich ist nicht schlecht, aber wie schon angedeutet, wie mein Dozent erklärt, so schreibt er auch. Sehr sprunghaft.

"Ich werde jetzt darauf nicht näher eingehen"

und

"das warum muss Sie nicht interessieren"

sind sehr häufig anzutreffen.
Ilias ist ein schöner Name, aber Odyssee würde mehr zutreffen.




Ich schieb jetzt mal denn Quelltext rein. Das Programm wurde über die Entwicklerumgebung MS Visual Studio 2010 geschrieben.


Mist. Mir wäre lieber denn Code über diese Spoilerfunktion hier einzuhängen. Sonst bekommt der werte Leser einen Scroll-Koller.
Wie macht man das? Dumme Frage, aber ich weiß es wirklich nicht

 

[Kinkaku-ji]

Mist. Mir wäre lieber denn Code über diese Spoilerfunktion hier einzuhängen. Sonst bekommt der werte Leser einen Scroll-Koller.
Wie macht man das? Dumme Frage, aber ich weiß es wirklich nicht

https://www.computerbase.de/forum/help/bb-codes/

 

[Chippo]

Uhm, eigentlich meinte ich damit wie man dies erreicht. Ich nehme an der Syntax ist so wie Beispielsweise der von "[CODE/CODE]"


Ah, danke.
Main

Spoiler

#include "stdafx.h"
#include <stdio.h>
#include <iostream>
#include <string>
#include <sstream>

#include "Eingabe.h"
#include "Ausgabe.h"
#include "Verarbeitung.h"
#include "Daten.h"
using namespace std;

int _tmain(int argc, _TCHAR* argv[])
{

Daten ip1, ip2, ip3, ip4;

cout << "\nEingabe IP\n";
Eingabe_IP(1); // Eingabe IP
cout << "\nEingabe SN\n";
Eingabe_IP(0); // Eingabe SN
cout << "\nAusgabe\n";
Ausgabe_IP(0);



return 0;
}

Eingabe.h

Spoiler

#pragma once
void Eingabe_IP(int overload);
//class Eingabe
//{

//public:
// Eingabe(void);
// ~Eingabe(void);


//};

Eingabe.cpp

Spoiler

#include "stdafx.h"
#include <stdio.h>
#include <iostream>
#include <string>
#include <sstream>

#include "Eingabe.h"
#include "Ausgabe.h"
#include "Verarbeitung.h"
#include "Daten.h"
using namespace std;



//Eingabe::Eingabe(void)
//{
//}
Daten ip1, ip2, ip3, ip4;
Daten sn1, sn2, sn3, sn4;

void Okt_Func_ip (int y, int wert)
{

if (y ==0) {ip1.setip(wert);} // Bestücke Daten_IP_Oktetten
if (y ==1) {ip2.setip(wert);}
if (y ==2) {ip3.setip(wert);}
if (y ==3) {ip4.setip(wert);}
cout <<"\nDaten wurden in Okt_Func_IP Oktette" << y+1 <<" geschrieben\n";
}




void Okt_Func_sn (int y, int wert)
{

if (y ==0) {sn1.setsn(wert);} // Bestücke Daten_SN_Oktetten
if (y ==1) {sn2.setsn(wert);}
if (y ==2) {sn3.setsn(wert);}
if (y ==3) {sn4.setsn(wert);}
cout <<"\nDaten wurden in Okt_Func_SN Oktette " << y+1 <<" geschrieben\n";
}





void Eingabe_IP(int wahl)
{
int a;
int pz;
int resultat;
int fc;
string ip;
string seldata;
string temp;



start:

pz = -1;
resultat = 0;
fc = 0;
ip = "";
seldata = "";
temp = "";


cout << "\nIP eingeben:"; cin >> ip; // Eingabe IP

jp1: // Hat IP 3 Punkte?
resultat=ip.find(".", resultat+1);
pz ++;
if (resultat >= 0) {goto jp1;}
if (pz != 3) {cout << "Fehler #1:IP-Struktur entspricht nicht der Norm.\n"; fc = 1;}



temp += "." +ip; // gebe ip an temp mit vorlaufenden Punkt

for (int x = 0; x <4;x++)
{
// Bestücke IP_Oktetten
resultat=temp.find(".", resultat+1); // Finde die Sprungmarke
seldata = temp.substr(resultat+1,3); // Selektiere Teile der IP
a = atoi (seldata.c_str ()); // wandle Teilstring in int


if ((a >= 256) || (a < 0)) {cout << "Fehler #3: Oktette " << x+1 << " entspricht nicht der Norm.\n";fc = 1;} // Entspricht Oktette der Norm?
if ((a < 1) && (x == 0)) {cout << "Fehler #2: 1. Oktett darf nicht 0 sein."; fc = 1;} // Ist 1. Oktette nicht != 1?


if (fc >= 1) {cout <<"\nFehler gefunden.";goto start;}


if (wahl == 1) {Okt_Func_ip(x,a);}
else {
Okt_Func_sn(x,a);}

};



//////////////////////////////////////
////////// Erfolgskontrolle //////////
//////////////////////////////////////

cout <<"\nEingabe.cpp\nIP-Oktetten:\n";
cout << ip1.getip() <<".";
cout << ip2.getip() <<".";
cout << ip3.getip() <<".";
cout << ip4.getip();
cout << "\n\nSN_Oktetten:\n";
cout << sn1.getsn() <<".";
cout << sn2.getsn() <<".";
cout << sn3.getsn() <<".";
cout << sn4.getsn();


;}




//Eingabe::~Eingabe(void)
//{
//}

Daten.h

Spoiler

#pragma once

class Daten
{
private:
int ip_oktette;
int sn_oktette;



public:

Daten(void);
void setip(int a);
void setsn(int a);
int getip(void);
int getsn(void);
~Daten(void);
};

Daten.cpp

Spoiler

#include "stdafx.h"
#include <stdio.h>
#include <iostream>
#include <string>
#include <sstream>

#include "Daten.h"

using namespace std;


// Konstruktor
Daten:aten(void)
{
}


// Destruktor
Daten::~Daten(void)
{
}

void Daten::setip(int a)
{
ip_oktette = a;
}

void Daten::setsn(int a)
{
sn_oktette = a;
}

int Daten::getip(void)
{
return ip_oktette;
}

int Daten::getsn(void)
{
return sn_oktette;
}

Ausgabe.h

Spoiler

#pragma once
void Ausgabe_IP(int a);
//class Ausgabe
//{
//public:
// Ausgabe(void);
// ~Ausgabe(void);
//};

Ausgabe.cpp

Spoiler

#include "stdafx.h"
#include <stdio.h>
#include <iostream>
#include <string>
#include <sstream>

#include "Eingabe.h"
#include "Ausgabe.h"
#include "Verarbeitung.h"
#include "Daten.h"
using namespace std;

//Ausgabe::Ausgabe(void)
//{
//}




void Ausgabe_IP(int a)
{

Daten ip1, ip2, ip3, ip4;
Daten sn1, sn2, sn3, sn4;
cout <<"\nAusgabe.cpp\n";
cout << ip1.getip() <<".";
cout << ip2.getip() <<".";
cout << ip3.getip() <<".";
cout << ip4.getip();
}


//Ausgabe::~Ausgabe(void)
//{
//}

Die Verarbeitung spare ich mir, da ich noch nicht soweit bin.

Die Konstruktor / Destruktor werde ich wohl noch benötigen. Bei meinem vielen Versuchen hing mal Daten ip1, ip2, ip3, ip4; im Konstruktor, hat aber auch nicht viel gebracht. Solange ich nicht die korrekte Syntax für das gegenwärtige Problem kenne, halte ich mich davon fern.
Ich habe bemerkt, das es keine gute Idee ist eine weitere Komponente einzubringen wenn man noch mit essentiellen Problemen zu kämpfen hat. Sonst weiß man am Ende nicht was was ausgelöst hat.
Wenn übrigens etwas ohne klaren Grund plötzlich (wieder) funktioniert nervt das mich übrigens mehr als wenn etwas an sich nicht mehr funktioniert^^

Jedenfalls halt ich mich jetzt mit Schreiben zurück und warte auf Rückfragen.


PS.: Wie gesagt, nicht lachen.

 

[blackst0rm]

Wo sind die sourcen? Aus deiner Beschreibung werde ich nicht schlau.

 

[DaZpoon]

Ich werd aus garnix schlau.

Bevor man anfängt zu codieren sollte man ein grobes Modell im Kopf/auf Papier entwickeln wie man sein Problem in Teilprobleme zerlegt. In diesem Falle sollte man sich erstmal klar machen WELCHE Klasse WAS machen soll.

Das ganze ist kein C++ Problem, sondern eins höher: Die Objektorientierte Modellanalyse.

 

[Chippo]

Würde ich gern machen, wenn mein Dozent mal 5 Minuten für mich hätte.
Die Projektbeschreibung meines Dozenten beruhte auf 3 Notizzettel die ungefähr so aussehen:

A 0
B 10
C 110
D 1110
E 11110

Ich glaube das sind Netzwerkklassen oder?

Dann murmelte er noch was von aufgebohrtes Subnet und verschwand...
Von daher das Projekt in Teilprobleme zu zerlegen wird dadurch unmöglich, da ich nicht mal weiß worauf mein Dozent raus will!
Allerdings glaube ich das er es nichtmal merken würde wenn mein Code so aussehen würde:

cin >> IP;
cin >> SN;
cout << "Subnet ist aufgebohrt (was auch immer)";

Es gibt übrigens nur eine Klasse und was sie machen soll, ist eigentlich klar


PS.: Meine Frage hat auch eigentlich nichts mit dem Projekt zu tun. Es handelt sich mehr um eine Detailfrage. Das ist ungefähr so, als ob ich dir sagen würde, baue ein Haus. Du bekommst die Ressourcen, die Blueprints + Statikdaten (in meinem Fall drei Zettel mit zusammhangslosen Gekritzel), aber kein Werkzeug.

 

[blackst0rm]

Um das mal ganz hart zu sagen, du hast objektorientierung nicht verstanden.
Dabei geht es um Datenkapselung.
Ich würde zum Beispiel eine Klasse einführen die eine IP-Adresse kapselt.
In etwa so:

Spoiler

class IP
{
private:
unsigned char oct1; //unsigned chars reichen da Wertebereich 0-255
unsigned char oct2;
unsigned char oct3;
unsigned char oct4;

public:
IP(unsigned char oct1,
unsigned char oct2,
unsigned char oct3,
unsigned char oct4); // Konstruktor der ein Objekt der IP-Klasse mithilfe der 4 explizit übergebenen
// oktetten initialisiert
IP(const char* ip_string); // Konstruktor der ein Objekt mithilfe eines strings initialisiert (String-funktionen)
~IP(); // Destruktor nur der Form halber. Wir haben keinen speicher auf dem heap
// angefordert also gibt es nichts aufzuräumen
void print(); // Die Funktion kann die IP ausgeben
}

das währe zum Beispiel eine Definition einer (sehr einfachen) IP-Klasse die Informationen über eien IP-Adresse kapselt und Methoden zur Verfügung stellt um mit den gekapselten Daten zu arbeiten.

um jetzt eine subnetzklasse einzuführen könntest du diese hier erweitern (Vererbung)

hab schon eine Weile nicht mehr in C++ programmiert und bin Java verwöhnt
können sich also syntaktische Fehler eingeschlichen haben

Ich hoffe das hat dir geholfen.

PS: ich will [source]-tags TT
PPS: toll meine ganze tolle formatierung is hin ich hab mir sone mühe gegeben

 

[Chippo]

Da fällt mir ein, mein Dozent hat mich mal als prozedurale Schwein bezeichnet (natürlich nur scherzeshalber). Ich habe mit C64-Basic angefangen und habe bei Quickbasic aufgehört. Von daher entschuldige bitte wenn ich (noch) nicht Objektorientiert denken kann. Zumal ich nicht weiß, ob man einen 30 jährigen Baum noch versetzen kann

Jedenfalls stellt mein Code (danke das keiner gelacht hat, zumindest nicht laut) einen Spagat dar.
Eigentlich habe ich doch schon die IP/SN-Daten gekapselt. Der Syntax für die Methoden um an die Daten ran zu kommen ist auch korrekt. Zu mindestens soweit das es was Eingabe.CPP angeht, funktioniert.

Was das eigentlich Modell angeht. Dafür musste ich etwas improvisieren. Ich adaptierte das was ich hier gelernt habe.
Wie du siehst geht es hier mehr direkt von Main zu denn Programmteil was die Klasse und Methode enthält, als über eine Subroutine, wie bei mir.
Also Main --> Box
während bei mir Main --> Eingabe --> Daten.

Von daher Daten habe ich gesondert gelagert, um sie bei Bedarf direkt ansprechen zu können. Der Zweck des ganzen wahr, das ich damit flexibler bin.

Die Lösung ist eigentlich ganz nah, da ich schon verstanden habe, was Sache ist.
Das Problem ist, ich bin nicht so gut mit Worten, von daher kann ich jetzt nicht sagen wie das ganze in meinem Geist aussieht.
Habe Mitleid mit einem alten prozedurale Schwein^^

PS: ich will [source]-tags TT
PPS: toll meine ganze tolle formatierung is hin ich hab mir sone mühe gegeben

Keine Sorge, ich sehe schon wie es bei dir aussehen sollte


PS.: Besonders lustig fand ich die oft erläuterte Erklärung was das tolle an Klassen ist. Ich zitiere:
Klassen eignen sich besonders dafür Code zu verstecken und denn Programmierer davon abzuhalten denn versteckten Code zu analysieren.
Um, ok. Das ist ungefähr so, als ob ich versuchen würde, denn Schlüssel zu meinem Safe vor mir selbst zu verstecken.
Zu mal, wenn ich mich selbst davor bewahre, meinen eigenen Code zu analysieren, wie soll ich dann die Fehler finden?

 

[blackst0rm]

Also Main --> Box
während bei mir Main --> Eingabe --> Daten.

auch sowas kann man kapseln.
da würde ich allerdings der einfachkeit halber keine klasse für verwenden sondern eine einfache funktion der art:

IP* read_ip_from_kb()
{
       char ip_octs[4];

       for (int i = 0; i < 4; i++)
            cin >> octs[i];

      return new IP(ip_octs[0], ip_octs[1], ip_octs[2], ip_octs[3]); 
}

Achtung! keine Fehlerbehandlung im Code und vor alle musst du in jedem Fall das objekt wieder freigeben wenn du es nicht mehr brauchst.

 

[antred]

auch sowas kann man kapseln.
da würde ich allerdings der einfachkeit halber keine klasse für verwenden sondern eine einfache funktion der art:

IP* read_ip_from_kb()
{
       char ip_octs[4];

       for (int i = 0; i < 4; i++)
            cin >> octs[i];

      return new IP(ip_octs[0], ip_octs[1], ip_octs[2], ip_octs[3]); 
}

Achtung! keine Fehlerbehandlung im Code und vor alle musst du in jedem Fall das objekt wieder freigeben wenn du es nicht mehr brauchst.

Oder du gibst gleich ein auf dem Stack liegendes Objekt zurück und sparst dir diese Sorge.

IP read_ip_from_kb()
{
       char ip_octs[4];

       for (int i = 0; i < 4; i++)
            cin >> octs[i];

      return IP(ip_octs[0], ip_octs[1], ip_octs[2], ip_octs[3]); 
}

 

[blackst0rm]

Oder du gibst gleich ein auf dem Stack liegendes Objekt zurück und sparst dir diese Sorge.

IP read_ip_from_kb()
{
       char ip_octs[4];

       for (int i = 0; i < 4; i++)
            cin >> octs[i];

      return IP(ip_octs[0], ip_octs[1], ip_octs[2], ip_octs[3]); 
}

das ist aber von der effizienz her nicht so toll, weil da nen deep copy durchgeführt werden muss.
außerdem muss dann nen copy-konstruktor implementiert sein

 

[antred]

das ist aber von der effizienz her nicht so toll, weil da nen deep copy durchgeführt werden muss.
außerdem muss dann nen copy-konstruktor implementiert sein

Das ist auf jeden Fall 10 mal effizienter als deine freestore-Variante.

1. Freestore-Allozierungen sind TEUER!
2. Deep-copy eines Objekts, das 4 Member vom Typ unsigned char hat (plus eventuell ein paar Padding-bytes). Pfft. Drauf gesch****.
3. Der default-copy constructor ist in diesem Falle völlig ausreichend.
4. Ein gescheit optimierender Compiler kann die Kopie sogar vollkommen eliminieren.

 

[blackst0rm]

touché

wie schon gesagt ich bin echt Java-verwöhnt

 

[antred]

PS.: Besonders lustig fand ich die oft erläuterte Erklärung was das tolle an Klassen ist. Ich zitiere:
Klassen eignen sich besonders dafür Code zu verstecken und denn Programmierer davon abzuhalten denn versteckten Code zu analysieren.
Um, ok. Das ist ungefähr so, als ob ich versuchen würde, denn Schlüssel zu meinem Safe vor mir selbst zu verstecken.
Zu mal, wenn ich mich selbst davor bewahre, meinen eigenen Code zu analysieren, wie soll ich dann die Fehler finden?

Das ist natürlich Unsinn. Die Idee ist, Nutzern der Klasse eine schmale, klar definierte Schnittstelle (die public Methoden der Klasse) zu bieten, so daß sie sich nicht um das, was unter der Haube abgeht, kümmern müssen (alles was als private deklariert ist). Dieses "Verstecken" von Implementierungsdetails wird (unter anderem) auch als Kapselung bezeichnet. Wenn ein Programmierer sich dennoch für die Details interessiert, hält ihn natürlich nix davon ab, sich den Code in voller Schönheit zu Gemüte zu führen.

 

[Chippo]

Mann, bin ich stolz auf mich das ich zumindest die Hälfte von dem was ihr gerade geschrieben habt, verstanden habe^^
Nochmal, bin blutiger Anfänger. Ehrlich gesagt, zu einer gescheiten Speicherverwaltung komme ich noch.
Zumindest weiß ich was Pointer und Structure ist, mein Dozent meinte, nachdem ich mich mit Variablen in allen Formen und String-Operatoren beschäftigt habe, mach mal was mit Klassen...
Redete irgendwas von Pointern, Vorteile gegenüber Structure, etc. Grummel. Daran, das er mir das VORHER beibringen oder zumindest darauf verweisen sollte, viel ihm irgendwie recht spät ein.

Zurück zum Thema:
Und da haben wir das Problem: Aber er WILL seine Klasse! Und da auch noch gekapselt. Zumindest die Datenbank sollte gekapselt sein, sonst frisst er mich noch. Zumal wenn ich denn Rest auch noch Kapseln und verklassenfizieren (meine damit Klassen dort einzusetzen wo Dozent es will, aber keinen Sinn macht) würde... hab ich mal versucht, aber aufgrund von Problemen denke ich ist es besser, klein anzufangen. Oder?

Letzten Donnerstag war er wie schon gesagt da. Klatschte irgendwas hin, was für mich ehr an eine Möbius-Schleife erinnerte als Code. Verschachtelte Klassen und Dinge die jeder Beschreibung spotten. Als er dann VS hat kompilieren lassen, gab es jede Menge Fehler von denen er meinte ich solle Sie ignorieren. Zwar funktionierte der Code, aber WARUM?
Wisst schon "das warum muss Sie nicht interessieren" ist sein Lieblingssatz. Aber gerade das warum ist nicht nur für mich wichtig, sondern das gerade verlockende daran.

Denn Code denn ihr beide mir hier reingestellt habt, ist übrigens schön. Mein Dozent meint immer das wäre Steinzeitcode. Ich denke das liegt daran das es extrem kompakter Code ist und er bildet lieber lange Ketten.
Also

cin >> okts[1];
cin >> okts[2];

Weiß garnicht was er hat. Ich denke gern in Schleifen. Ich kann mir die Abläufe bzw. in meinem Code viel besser vorstellen (denke in Routinen und Bildern, weniger in Worten) als sein OOP-Zeugs. Sagt bitte nicht, das auch ich für OOP Endloscodes produzieren muss!? Büdde büdde!


Übrigens:
Was sind padding-bytes?
Und deep-copy ist wenn man ein Objekt von einem Objekt von einem Objekt macht, oder?
Allerdings sieht der Code mir nicht danach aus?
Ich denke, in Falle einer richtigen Einschätzung hätte ich das lieber auch auf dem Stack.


PS.: Ich habe bemerkt das ich am besten lerne, wenn ich einen Code habe, denn ich zerruppen kann um dann in seinen Eingeweiden zu lesen. Ergo, ich provoziere Fehler um dann aus der Reaktion Rückschlüsse auf dessen Funktion schließen zu können.

 

[blackst0rm]

Hm komisch mein Prof würde michhauen wenn ich das nicht in einer Schleife machen würde.
Padding-bytes sind wie der Name schon sagt Füllbytes damit der speicher hübsch strukturiert ist, darauf müssen wir jetztnnicht genauer eingehen.

Deep-copy bedutet, dass diie werte der eigenschaften eines objekts zu der neuen instanz kopiert werde anstatt eine eferenz auf ein bestehendes objekt zu verwenden.

PS:Ich bitte Tippfehler zu verzeihen, da ich gerade auf meinem smartphone(leider recht lahm) unterwegs bin und vom (Black) Metal Satammtisch komme

 

[DonnyDepp]

witziger thread
hast dein problem eigentlich gelöst?
dein code da ganz oben kann gar nicht funktionieren, weil die Daten-klassen in jedem scope neu erzeugt werden.

ansonsten musste mal kürzere sätze und prägnantere aussagen formulieren. (short and pregnant xD)
oder du gibst das programmieren auf und wirst it-berater. da muss man viel quatschen, um es vor dem kunden komplexer aussehen zu lassen, als es in wirklichkeit ist.

 

[Chippo]

Ich habs nicht so mit sprechen. Wie gesagt ich denke in Bildern. Von daher ich muss ab und an Dinge umschreiben. Der einzige mit dem ich mich in Kurzform unterhalten kann, ist mein Bruder und mein Computer^^. Irgendwie sind die telepathisch.

dein code da ganz oben kann gar nicht funktionieren, weil die Daten-klassen in jedem scope neu erzeugt werden.

Die Frage ist - kurz und prägnant - wie erzeuge ich die Daten-Klasse übergreifend?
Wenn ich das in Main mache, aber nicht in Eingabe, bekommt Eingabe nichts ab von dem Segen. Und bleibt die von mir gewünscht Kapslung der Daten erhalten?


Man ein weitere Frage:
Ich habe des öfteren gelesen, das im Rahmen der Weiterentwicklung von C++ einige Befehle entfernt werden. Meines Erachtens ist das Unsinn, da man bestimmt daran interessiert ist, das ein Compiler aus dem Jahre 2010, auch Code kompilieren kann der 1995 geschrieben wurde. Ist das nur eines von diesen "Fakten", die bei genauer Betrachtung keine Substanz haben?

 

[Fortatus]

Die Frage ist - kurz und prägnant - wie erzeuge ich die Daten-Klasse übergreifend?
Wenn ich das in Main mache, aber nicht in Eingabe, bekommt Eingabe nichts ab von dem Segen. Und bleibt die von mir gewünscht Kapslung der Daten erhalten?

Prinzipiell _könntest_ du die Variablen außerhalb jeder Funktion definieren und dann kann jeder Teil des Programms drauf zugreifen ("Globale Variable"). Sofern sich das vermeiden lässt, sollte man sowas aber nicht tun, da es den Hauptvorteil von Objektorientierter Programmierung auflöst, nämlich die Datenkapselung.

Zur zweiten Frage: Mit C++11 wurden einige wenige und weniger wichtige Teile fallen gelassen bzw. einfach durch neue, bessere Varianten ersetzt. Die Frage ist 1. ob die Compiler sie nicht doch weiter unterstützen und 2. inwiefern es sinnvoll war dies zu tun. Das Standardkomitee ist _sehr_ auf Rückwärtskompatibilität bedacht. Eigentlich sollten die meisten 15 Jahre alten C++-Programme mit kleinen Änderungen auch heute noch kompilieren. (Sofern keine externen Bibliotheken benutzt wurden)


P.S.: Da du ja noch ein Problem hast dir die Objektorientierte Programmierung bildlich vorzustellen, hab ich mal kurz was in Google reingeworfen. Hilft das? http://www.coberweis.de/OOPmitJava_1.ppt

 

[Chippo]

Sofern sich das vermeiden lässt, sollte man sowas aber niemals tun, da es den Hauptvorteil von Objektorientierter Programmierung auflöst, nämlich die Datenkapselung.

Das ist mir auch klar. Es geht um die generelle Möglichkeit über jeden Programmteil an die Daten zu kommen. Einfach aus dem Grund weil es bestimmt ein Scenario gibt wo dies praktisch wäre. Ergo, theoretisch kann jedes Programmteil auf die Daten zugreifen, praktisch hat aber sagen wir mal von 10 Programmteilen 2 denn Schlüssel.
Du hast bsp. eine Cloud. Theoretisch können 7 Milliarden Menschen drauf zugreifen, aber nur du und deine Schwester haben Zugang. Du verstehst?


Was das OOPmitJava-Ding angeht. Mit was für ein Programm ruf ich die Datei auf?
Ist es eine Art Diagram?


Ich habe es jetzt hinbekommen, indem ich die Datenklasse in Main erzeugte und mit extern an die Programmteile weitergab. Zumal, wenn ich die dafür notwendige Zeile in Programmteilen, die mit der Datenbank nichts am Hut haben, auch nicht einsetzen.
Jetzt versuche ich mal Main auszuschließen und woanders zu Klasse zu erzeugen. Main hat ja eigentlich nichts weiter zu tun als die einzelnen Programmteile aufzurufen. Und das kann es auch ohne zu wissen was es da tut.

Edit: Ok, funktioniert. Danke an euch