C++ Eigene Header einbinden als Schnittstelle !?

GeraldR

Ich lese derzeit das Buch "Die C++ Programmiersprache", von Bjarne Stroustrup.

Und verstehe folgendes nicht:

Es soll funktionieren Header als Schnittstellen für die Implementierung zu Nutzen, ohne die dazu gehörigen Definitionen aus den cpp's zu includen. Des weiteren soll es funktionieren verschieden Header bereit zu stellen: z.B. einen für den Programmierer und einen für den Anwender.

z.B.

testheader.h

#ifndef testheaderh
#define testheaderh
class test
{
int testvar;
public:
test(int tvar):testvar(tvar);
int wert();
};
#endif

test.cpp

#include "testheader.h"
int test::wert()
{
return testvar;
}

main.cpp

#include <iostream.h>
#include "testheader.h"
int main()
{
test erster(5);
cout<<erster.wert();
return 0;
}

rüdiger

1. wo ist jetzt deine Frage?

2. iostream.h ist veraltet. Kann es sein, dass du eine veraletete Version des Stroustups hast?

Belgarad

mit den header dateien *.h teilst du dem compiler die signatur der einzubindenen funktionen mit.
d.h. selbst wenn du keinen src hast, kannst du funktionen verwenden, wenn du die header kennst.

GeraldR

@ Belgarad Ich weiß leider nicht was scr bedeutet, vielleicht kannst Du es ausschreiben,...

@kingruedi
Das Proble was ich habe ist folgendes:
Ich habe diese Programmierweise mit dem Borland C++ Builder 3 und dem Bloodshed
Dev-C++ comiler versucht, jedoch findet er die Klasse bzw. Funktionen nicht.
Nebenbei hatte ich ma leinen Kurs belegt und auch dort hatte ich nix von der Verwendung der Header als Schnittstelle erfahren.

Bisher habe ich immer den Header und die zugehörige Cpp mit

include

eingefügt bzw. im Fall von Borland auch ab und zu mit

useunit

.

Tja und stehe ich da und kapiere zwar was dieses Einfügen vobn Schnittstellen,
also verschiedenen Headerversionen (Nutzer,Programmierer=detailierter)bringt, und das es nicht schlecht wäre, wenn ich in mehreren cpp's den gleichen Header aufführe und so den Header als Schnittstelle zwische den ganzen cpp's zu etablieren ohne sie extra einzufügen. Aber es funktioniert überhaupt nicht.

Vielleicht liegt es auch an den Compliern, abwohl ich bei Borland auch den Einstellungen aus AnsiC++ geändert hatte.

GeraldR

Ein weiteres nicht funktionirendes Beispeil aus dem Buch

//temp.h
template<class T> void out(const T& t);

//temp.cpp
include<iostream>
#include "temp.h"
export template<class T>void out(const T& t);
{std::cerr<<t;}

//main.cpp

#include <iostream>
#include <stdlib.h>

#include "temp.h"

int main(int argc, char *argv[])
{
  out(5);
  system("PAUSE");	
  return 0;
}

RHBaum

Ich lese derzeit das Buch "Die C++ Programmiersprache", von Bjarne Stroustrup.

Kenne das Buch ned, aber Bücher vom "Meister" sind im allgemeinen etwas schwer verdaulich Weiss ned wie es hier ist.
Veilleicht solltes mal nach nem Buch schauen, wo die Grundlegenden Dinge etwas ausfuehrlicher beschrieben sind, vielleicht setzt der Autor etwas viel Basisiwissen voraus.

Zu dem Header problem, Kannst dir es vereinfacht folgendermassen vorstellen

Dein Einsprungpunkt ist deine main-source(cpp) Datei. In der ist meistens die main() funktion deklariert. diese sollte alle Headerdateien (Kurz Header) includen, die sie braucht.

DIe Header beinhalten "meist" nur die Prototypen von Funktionen / Klassen, koennen aber auch die Implementation beinhalten.

Class X
{
public:
	X();
	virtual void ~X();

	void doAnything();
protected:
	int MyVar;
}

das ist nen Typischer Fall von nur Prototyp.

Class X
{
public:
X():
MyVar(0)
{
}

virtual void ~X()
{
}

void doAnything()
{
MyVar ++;
}
protected:
int MyVar;
}

Das waer nen Besipiel mit Implementation.
Bei dieser Variante brauchst du keine weitere cpp Datei zu deiner h Datei, weil die h datei alles selbst implementiert.
Beim kompilieren wird der Code generiert und automatisch zu der cpp "hinzugelinkt", die die h-Datei includiert.
Meist Biblotheken mit kleinen schlanken klassen, und vor allem templates ( die koennen es nicht anders ... ist aber nen anderes thema) benutzen diese Variante.

Bei der Variante nur mit den Prototypen, musst die implementation deiner Funktionen in ner seperaten Datei vornehmen.

X::X():
MyVar(0)
{
}

void X::~X()
{
}

void X::doAnything()
{
	MyVar ++;
}

so in etwa, diese Datei muss natuerlich die definition ihrer eigenen schnittstelle includieren

Beim kompilieren deiner main cpp datei, wird nun nicht mehr der Code aus der H datei hinzugelinkt, sondern es werden nur Linker-Symbole an hand der Signatur (name und Parameter/Rueckgabewert) deiner funktionen angelegt.
Deine andere cpp die diese funktionen implementiert, musst du nun auch uebersetzen (der Compiler macht aus allen erstmal nur eine obj datei), und du ershaelst 2 obj-Dateien, die du mit dem Linker dann zu deiner exe / bin oder was weiss ich, zusammenlinkst. Anhand der generierten Symbole kann der Linker feststellen, ob alle benutzen Funktionen aus der H-Datei implementiert wurden ... wenn nicht, bringt der Linker nen Error ... (Symbol not found)

Du brauchst also nirgendswo eine cpp Datei mit include einbinden (normalerweise nich, gibt wie immer ausnahmen), sondern nur alle cpp dateinen linken, aber das macht meisst deine IDE ... wenn die cpp datei im Projekt drinn hast.

Hoffe das war verstaendlich erklaert ...

CIao ...

GeraldR

Erstaml danke an alle die geantwortet haben, wird wohl daran gelgen haben, daß die header und cpp nicht im Projekt abgespeichert waren, sondern nur im gleichem Verzeichnis lagen - also keine Chance für die IDE *g*

RHBaum

Trotzdem wuerde ich empfehlen, mal was ueber "make" zu lesen.
Normal nimmt dir die IDE viel arbeit ab, aber bei nicht auf Anhieb ersichtlichen Fehlern hilft dir "Basiswissen" enorm weiter.
Im Context mit make wird sehr viel ueber codeerzeugung linken, Bibliotheken etc. mitbehandelt.
Mit diesen wissen bist dann auch an keine IDE mehr gebunden ...

Ciao ...