mikrocontroller.net

Forum: PC-Programmierung Klassen in funktionen nutzen c++


Autor: SiO2 (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Wie kann ich in einer eigenen Funktion auf Funktionen einer klasse
zugreifen, von der ich ein Objekt in der main() angelegt habe?
Mit zeigern auf das Objekt hab ich probleme. ich weiss nicht wie ich
die funktion definieren muss.
fkt(ifstream *zeiger) gehts nich.

danke

Autor: Tobi H. (tobi-) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
In Main:
ifstream *fs = new ...
fkt( fs );
oder
ifstream if(..);
fkt( &if );

Funktion:
fkt( ifstream* fs ) ...
fs->FunktionInKlasse(...

Desweiteren empfehle ich ein beliebiges C++-Buch/Tutorial
z.b: http://www.cplusplus.com/doc/tutorial/

Autor: Ulrich (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ich würde keine Zeiger übergeben sondern direkt die Objekte und dann mit
referenzen arbeiten....

Autor: SiO2 (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@Tobi. Danke, ich werds heut mal testen.

@Ulrich. Könntest du mir Bitte mal nen bsp.Code Posten. Auf die Idee
bin ich auch schon gekommen, aber man muss doch afaik, immer den typ
angeben, welcher übergeben wird, und das hab ich nicht hinbekommen.

Autor: Karl heinz Buchegger (kbucheg)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
zeig doch mal an einem konkreten, möglichst kompletten,
möglichst kleinem Beispiel, was du nicht hinbekommen hast.
Dann könnten wir Dir helfen, Deine Sprachprobleme zu lösen.

Autor: Rolf Magnus (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> @Ulrich. Könntest du mir Bitte mal nen bsp.Code Posten. Auf die
> Idee bin ich auch schon gekommen, aber man muss doch afaik, immer
> den typ angeben, welcher übergeben wird, und das hab ich nicht
> hinbekommen.

Das mußt du doch bei Zeigern auch.

> fkt(ifstream *zeiger) gehts nich.

Da fehlt ein Rückgabetyp.

Autor: SiO2 (Gast)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
Im Anhang mal der Code (bitte nicht über goto meckern ;) )
Dies ist die Fehlermeldung die kommt (zeile 66 ist die Zeile
derFunktion printx() )

hiv.cpp: In function `void printx(std::ifstream*)':
hiv.cpp:66: warning: cannot pass objects of non-POD type `class
std::streampos' through `...'; call will abort at runtime

Ich hab auch verschiedene andre sachen probiert, aber immer wieder
Fehlermeldungen. Ich bin mir sicher, das es nur ein winziger Fehler
ist, aber welcher?
Auch der Zugriff FileObject->tellg() liefert -1, seit ich mit nem
Zeiger auf das Objekt artbeite, vorher mit
ifstream FileObject;
FileObject.tellg();
lief es richtig.


@Rolf: wozu brauche ich nen Rückgabewert? Ich arbeite doch mit nem
Zeiger auf das Objekt.


Danke SiO2

Autor: SiO2 (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Upps, hab noch vergessen, Die Meldung kommt von GCC unter GNU/LINUX

Autor: SiO2 (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hmm.Bin schon etwas weitergekommen. Mit Borland unter w2k  läufts,
obwohls dergleiche Code ist. arghh

Autor: Karl heinz Buchegger (kbucheg)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hmm
Ich denke in der Tat, dass du einen Compilerfehler
entdeckt hast. Ist zwar nur eine Warnung und der gcc
erzeugt trotzdem Code, aber immerhin.

Nebenbei:
Warum erzeugtst du das ifstream object dynamisch
zur Laufzeit mittels new. In diesem Program gibt
es keinen Grund dafuer und du hast dir da einen
Logikfehler dadurch eingefangen.

> // Datei oeffnen
> FileObject->open(argv[1],ios::in | ios::binary);
>
> // Datei nichtexistent
>   if (!FileObject){
>   cout << "\nFile nicht ladbar\n" << endl;
>   exit(1);
> }

Das wolltest du ganz sicher so nicht haben.
Du wolltest mit Sicherheit haben:

    if( !*FileObject ) {
      cout ....

Auch wenn viele über die Hungarian Notation die Nase rümpfen
(inklusive mir), so habe ich doch etwas davon übernommen, was
sich bewährt hat. Bei mir beginnt der Name jeder Pointer Variablen
mit einem kleinen 'p'.

Dann wäre bei dir im Original gestanden

   if( ! pFileObject )

und es wäre offensichtlich, dass hier einfach nur ein Pointer
abgefragt wird und nicht das Objekt selbst, so wie der Code  im
then-Block vermuten lässt.

Aber wie gesagt: Wozu überhaupt der Pointer? Du brauchst ihn
nicht: (Ich hab noch ein paar andere sinnvolle Dinge im Code
geändert)

 ifstream FileObject;

  // Datei oeffnen
  FileObject.open(argv[1],ios::in | ios::binary);

  // Datei nichtexistent
  if (!FileObject) {
    cout << "\nFile nicht ladbar\n" << endl;

// Hast du schon mal Log-Files studiert? Wenn da steht
// Datei konnte nicht geöffnet werden, dann ist das super.
// Hilft dir aber nicht wirklich, denn es bleibt immer noch
// die Frage: WELCHES!
//
// Siehe Microsoft: Eine DLL konnte nicht gefunden werden!
// Super! Wenn ihr uns auch noch sagen würdet welche, könnten
// wir was dagegen tun. So aber ... bleibt nur raten.

    cout << "\nFile nicht ladbar '" << arv[1] << "'\n" <<
endl;

// Beachte auch: Ich schliesse den Filenamen in ' ein.
// Damit kann man erkennen ob man irgendwelche Sonderzeichen
// und sei es nur ein Leerzeichen, im String drinn hat.

    exit( EXIT_FAILURE );
  }

  // Filegroesse ermitteln
  FileObject.seekg( 0, istream::end );
  FileSize = FileObject.tellg();

  // setze seekg-pointer auf start
  FileObject.seekg( 0, istream::beg );

// Tja. Mit dem nächsten wirst du dir deine wunderbare
// ermittelste FileSize zerstören
  FileSize=FileObject->tellg();

// Hey. geht doch. Ja genau. So macht man das
  ifstream test;

  printf("\n%d\n",sizeof(test));

  printf("\n%d\n",sizeof(*FileObject));
  //test
  printf("%4X\n",1000);

  // hauptschleife
  while(1){
  key=getc(stdin);
  switch( key ){
    case 'h'  : printhelp();
      break;

// da printx eine Adresse will, geben wir ihr halt eine
    case 'n' : printx(&FileObject );


Anzumerken wäre noch, dass ein C++ Programmierer, hier
wahrscheinlich keinen Pointer übergeben würde, sondern
printx ganz einfach mit einer Referenz als Argument ausstatten
würde:

  void printx( ifstream& stream )
  {
    ...
  }

Weiters sollte man noch anmerken:
  Das mischen von cout und printf ist gefährlich. Da kann alles
  mögliche unerwartete passieren. Entscheide dich für eines
  von beiden: entweder nur printf oder nur cout
  und bleib dabei.
  Offiziell haben die beiden Ausgabestreams nämlich nichts mit-
  einander zu tun, so dass absolut nicht geregelt ist, in welcher
  Reihenfolge Ausgaben gemacht werden, wenn über beide Ausgabestreams
  Ausgaben erfolgen.

Autor: Rolf Magnus (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
>   Offiziell haben die beiden Ausgabestreams nämlich nichts mit-
>   einander zu tun, so dass absolut nicht geregelt ist, in welcher
>   Reihenfolge Ausgaben gemacht werden, wenn über beide
>   Ausgabestreams   Ausgaben erfolgen.

Das ist falsch (wow... muß ich mir im Kalender anstreichen). C- und
C++-I/O werden per Default automatisch syncrhonisiert und können
beliebig gemischt werden. Erst ein Aufruf von
std::ios_base::sync_with_stdio(false) ändert das.

Autor: SiO2 (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@Karl Heinz
Das mit cout und printf ist mir bewusst und habs aber erst mal gelassen
;).
Aber die Reihenfolge der Ausgabe sollte doch eingehalten werden, wenn
ich printf vor cout habe, sollte doch printf auch eher ausgeführt
werden.
Die Fehlermeldung, das die datei nicht ladbar war, bezieht sich ja auf
die in der kommandozeile angegebenen datei, aus dem kontext raus weis
man welche datei es ist ( jaja die faulen leute ;) )
Die dynamische zuweisung hatte ich erstmal gemacht, weil mein eigener
code ohne dyn. zuw. nicht ging.
Die mehrfache FileSize zuweisung war noch aus testzwecken drin.
Ich werds heute nochmal mit Referenzparametern testen (und auch nochmal
mit Pointern und versuchen es auch mit gcc zum laufen zu bringen)

Besten Dank für die Hilfe.

Autor: Björn (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
"Auch wenn viele über die Hungarian Notation die Nase rümpfen
(inklusive mir), so habe ich doch etwas davon übernommen, was
sich bewährt hat. Bei mir beginnt der Name jeder Pointer Variablen
mit einem kleinen 'p'."

Jep, das kann sehr hilfreich sein!

Autor: Karl heinz Buchegger (kbucheg)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> C- und C++-I/O werden per Default automatisch syncrhonisiert

Hmm. War das schon immer so oder trügt mich mein
Gedächtnis (soll schon mal vorkommen).
Rolf, wir haben doch lange Zeit in comp.lang.c++ vor
solchen Dingen gewarnt.

Autor: Karl heinz Buchegger (kbucheg)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
<Kurze google Recherche später>

Tja. Da bin ich ja schön reingefallen. Das synchronisieren
gabs anscheinend schon immer. Aber anscheinend gabs früher
Implementierungen bei denen das nicht so richtig funktioniert.
Und ich glaub mein Gedächtnis trügt auch: So dunkel
kann ich mich an die Situationen erinnern, bei denen Leute
über cout irgendwelche Prompts ausgaben und über getchar()
Zeichen einlesen (oder noch schlimmer: ueber getchr() ) und
sich wunderten warum das so nicht klappt.
Irgendsowas in dieser Richtung. Ja, ja. Alt sollte man halt
nicht werden :-)

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.