Eclipse - Benutzer-Homepage-Server der TH Mittelhessen

Eclipse
Version Kepler
(4.3 Release vom 26. Juni 2013)
Installation unter Windows 8.1
c Y. Pfeifer
(Mai 2014)
Inhaltsverzeichnis
1 Java-Programmierung
1.1 Installation von Eclipse unter Windows 8.1
1.2 Aufbau der Workbench / Views . . . . . .
1.2.1 Package Explorer . . . . . . . . . .
1.2.2 Navigator-Fenster . . . . . . . . . .
1.2.3 Outline-Fenster . . . . . . . . . . .
1.2.4 Problems-Fenster . . . . . . . . . .
1.3 Java-Applikation erstellen . . . . . . . . .
1.4 Java-Klasse compilieren . . . . . . . . . .
1.5 Java-Applikation ausführen . . . . . . . .
1.5.1 Java-Applikation mit Parametern .
1.6 Erstellen einer Bibliothek . . . . . . . . . .
1.7 Verwenden einer Bibliothek . . . . . . . .
1.8 Standalone-Applikation erstellen (Standard
1.8.1 Variante 1 . . . . . . . . . . . . . .
1.8.2 Variante 2 . . . . . . . . . . . . . .
1.9 Tipps . . . . . . . . . . . . . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
Widget Toolkit
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
2 C/C++ Programmierung
2.1 Voraussetzungen . . . . . . . . . . . . . . . . .
2.1.1 Installation CDT . . . . . . . . . . . . .
2.1.2 Installation MinGW . . . . . . . . . . .
2.2 C/C++ Anwendung erstellen und ausführen . .
2.3 Compilierung und Ausführung von der Console
2.4 Makefile . . . . . . . . . . . . . . . . . . . . . .
2.5 C++ Programm mit Makefile . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
(SWT))
. . . . .
. . . . .
. . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
4
4
5
5
5
5
5
5
7
8
8
9
9
10
10
12
12
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
13
13
13
13
14
15
15
15
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
3 Java und Datenbanken
17
3.1 UCanAccess . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2
3
1 Java-Programmierung
1.1 Installation von Eclipse unter Windows 8.1
Zunächst Eclipse Zip unter Beachtung der gewünschten Version (32-Bit-/ 64-Bit-Version) downloaden (z.B. unter http://www.eclipse.org).
Häufig enthält der Zip auch beide Versionen. In dem Fall die für das Betriebssystem benötigte Version auswählen und diese entpacken. Dadurch wird ein Ordner Eclipse angelegt, der
auch die ausführbare Datei eclipse.exe enthält. Dieser Ordner kann später problemlos an die
gewünschte Stelle im Dateisystem umkopiert werden, ohne die Funktionsfähigkeit der Software
zu gefährden.
Voraussetzung für die Nutzung von Eclipse ist die Installation mindestens einer JRE (jre-8windows-x64), welche beispielsweise unter www.oracle.com heruntergeladen werden kann.
Zur JRE (Java Runtime Environment, Java-Laufzeitumgebung) zählt neben API und Klassenbibliotheken die JVM, die Java Virtual Machine, welche für die Ausführung des vom JavaCompiler erzeugten Bytecodes verantwortlich ist. Dazu werden die erzeugten plattformunabhängigen Bytecodedateien (class-Dateien) während der Laufzeit in die plattformabhängige Maschinensprache übersetzt. Die Maschine, die diesen Bytecode ausführt, ist typischerweise virtuell,
das heißt, der Code wird nicht direkt durch Hardware (etwa einen Mikroprozessor) ausgeführt, sondern durch entsprechende Software auf der Zielplattform. Neben dem Klassenlader
(classloader und resolver) beinhaltet die JVM die Speicherverwaltung inklusive der automatischen Speicherbereinigung (garbage collection) sowie die Ausführungseinheit (execution engine). In der Regel (Ausnahme: Threads, d.h. nebenläufig ablaufende Programme) wird jedes
Java-Programm in seiner eigenen virtuellen Maschine ausgeführt.
Beim Aufruf von Eclipse ist die Angabe einer Arbeitsumgebung, des sogenannten workspace,
erforderlich, in der die Projekte erstellt werden sollen. Standardmäßig wird der Pfad
C:\Users\[Benutzername]\workspace vorgeschlagen.
Dieser kann jedoch individuell abgeändert werden. Die Einstellung des workspace wird unter
WINDOWS->PREFERENCES->GENERAL->STARTUP AND SHUTDOWN
verwaltet. Hier können auch mehrere workspaces eingetragen sein, zwischen denen ein Wechsel
über FILE->SWITCH WORKSPACE möglich ist.
Beim erstmaligen Start von Eclipse wird ein Begrüßungsbildschirm angezeigt, welcher u.a. Tutorials für die Erstellung einfacher Java-Anwendungen enthält. Diese Tutorials können nach
dem Schließen jederzeit unter HELP->WELCOME erneut aufgerufen werden.
4
1.2 Aufbau der Workbench / Views
1.2.1 Package Explorer
Der Package Explorer enthält alle Projekte, welche im aktuellen workspace angelegt wurden.
Hierbei werden jedoch nur die für das Projekt notwendigen Daten angezeigt; das bin-Verzeichnis
bzw. in diesem erstellte class-Dateien sind nicht sichtbar.
1.2.2 Navigator-Fenster
Der Navigator ist kein automatischer Bestandteil der Java-Perspektive, kann jedoch unter dem
Menüpunkt WINDOW->SHOW VIEW->NAVIGATOR eingeblendet werden. Im Gegensatz
zum Package Explorer enthält er alle Ordner und Dateien, die im workspace angelegt wurden. Geschlossene Projekte (Kontextmenü: CLOSE PROJECT) verursachen einen geringeren
Speicherverbrauch, werden jedoch weiterhin im zugeklappten Zustand angezeigt.
1.2.3 Outline-Fenster
Das Outline-Fenster bietet eine Übersicht über verwendete Klassen und Methoden und dient
der Navigation im aktiven Editorfenster. Durch Auswahl eines Eintrags springt der Curser zur
gewünschten Position im Quellcode.
1.2.4 Problems-Fenster
Im Problems-Fenster wird eine Liste der vorhandenen Fehler angezeigt, die durch Anklicken
eines Eintrags im zugehörigen Quellcode selektiert werden können.
1.3 Java-Applikation erstellen
Zunächst sollte die Java-Perspektive ausgewählt werden:
WINDOW->OPEN PERSPECTIVE->JAVA BROWSING
Neues Projekt anlegen unter:
• FILE->NEW->JAVA PROJECT oder entsprechenden Button anklicken
• Projektname eingeben
• Create separate source and output folders“ auswählen für eine saubere Trennung von
”
Quellcode (.java-Dateien) und class-Dateien.
5
⇒ im Package Explorer erscheint das neue Projekt mit src als Unterordner und JRE System
Library
⇒ im workspace wird ein nach dem Projektnamen benannter Ordner angelegt mit den Unterordnern
• .settings (enthält org.eclipse.jdt.core.prefs = Prefs-Datei)
• bin
• src und den Dateien
• .classpath
• .project
Aufbau der .project-Datei:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<?xml version="1.0" encoding="UTF−8"?>
<projectDescription>
<name>Projektname</name>
<comment></comment>
<projects>
</projects>
<buildSpec>
<buildCommand>
<name>org.eclipse.jdt.core.javabuilder</name>
<arguments>
</arguments>
</buildCommand>
</buildSpec>
<natures>
<nature>org.eclipse.jdt.core.javanature</nature>
</natures>
</projectDescription>
Listing 1.1: .project-Datei
Aufbau der .classpath-Datei:
1
2
3
4
5
6
<?xml version="1.0" encoding="UTF−8"?>
<classpath>
<classpathentry kind="src" path="src"/>
<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.
internal.debug.ui.launcher.StandardVMType/CDC−1.1%Foundation−1.1"/>
<classpathentry kind="output" path="bin"/>
</classpath>
Listing 1.2: .classpath-Datei
Neue Java-Klasse anlegen:
• FILE->NEW->CLASS oder entsprechenen Button anklicken
• Optional ist die Angabe eines Packages, dem die zu erstellende Klasse angehören soll.
• SourceFolder: Projektname/src
• Klassenname angeben
• main-Methode auswählen, wenn diese erzeugt werden soll
6
⇒ unter src wird im Package Explorer standardmäßig ein default package erzeugt, das die Datei
<Klassenname>.java enthält.
⇒ in der Verzeichnisstruktur wird im Ordner src die Datei Klassenname.java und im Ordner
bin die Datei <Klassenname>.class angelegt.
1.4 Java-Klasse compilieren
Um die Quellcode-Dateien (.java-Dateien) außerhalb von Eclipse compilieren zu können (Eclipse verfügt über einen eigenen Compiler), wird ein JDK, ein Java Development Kit, benötigt. Die
Laufzeitumgebung (Java Runtime Environment, JRE) selbst umfasst nur die virtuelle Maschine (JVM) und die mitgelieferten Bibliotheken, beihaltet jedoch keine Entwicklungswerkzeuge
wie bspw. Compiler. Wird zusätzlich zur JRE ein Java-Compiler benötigt, so ist die Nutzung
des JDK zu empfehlen, welches sowohl JRE als auch Entwicklungswerkzeuge zum Erstellen
von Java-Programmen wie Compiler oder Java-Archiver enthält. Das JDK (jdk-8<version>windows-x64.exe für ein 64-Bit-System, z.B. jdk-8u5-windows-x64.exe) kann von der Webseite
www.oracle.com heruntergeladen werden.
Nach der Installation befindet sich der Java-Compiler (javac.exe) in der Regel im Verzeichnis
C:\Program Files\Java\jdk1.8.0 05\bin\ , sodass die Klasse mithilfe des Befehls
C:\Program Files\Java\jdk1.8.0 05\bin\javac“ MyClass.java
”
compiliert werden kann.
Um auf die vollständige Pfadangabe zum Java-Compiler verzichten zu können, muss die Umgebungsvariable PATH aktualisiert werden. Das Setzen der PATH Variable (optional) erfolgt
unter
SYSTEMSTEUERUNG->SYSTEM UND SICHERHEIT->SYSTEM->Erweiterte Systemeinstellungen (linkes Menü).
Es öffnet sich ein Fenster mit Systemeigenschaften, in welchem die Umgebungsvariablen editiert werden können. Bei der Umgebungsvariablen PATH handelt es sich um eine Reihe von
durch Semikolon (;) getrennten Verzeichnissen, die Windows benutzt, um nach Programmen
zu suchen (Suchreihenfolge erfolgt von links nach rechts). Hierbei sollte nur ein bin-Verzeichnis
für ein JDK eingetragen sein; alle nachfolgenden werden von Windows ignoriert.
Um die PATH Variable dauerhaft zu setzen, ist die vollständige Pfadangabe C:\Program
Files\Java\jdk1.8.0 05\bin\ zur bereits existierenden PATH Variable hinzuzufügen.
Nach dem Setzen der Umgebungsvariablen PATH können alle ausführbaren Dateien (javac.exe,
java.exe, javadoc.exe, ...) ohne Pfadangabe aus jedem beliebigen Verzeichnis heraus aufgerufen
werden.
Sofern es dem Benutzer aufgrund mangelnder Rechte nicht gestattet ist, Änderungen in der
Systemsteuerung vorzunehmen, kann die PATH Variable vorübergehend mit Hilfe der MS-DosEingabeaufforderung gesetzt werden.
Der Befehl path=<neuer Pfad>;%path% fügt den gewünschten Pfad den bereits existierenden
7
Pfadangaben hinzu. Nach dem Schließen der Shell, wird jedoch der alte PATH-Inhalt wiederhergestellt.
Tipp: Bei der Erstellung von Quellcodedateien im Editor sollten bei Speichern unter..“ die
”
Klassennamen inklusive java-Endung in Hochkommata angegeben werden (z.B. Klasse.java“),
”
da die erstellte Datei sonst als Textdatei interpretiert wird. Dem Namen Klasse.java wird in
dem Fall ein .txt hinzugefügt, sodass die Datei als Klasse.java.txt und somit als Textdatei
abgespeichert und interpretiert wird.
Mit Hilfe der Zeichenkettenangabe kann die .txt-Erweiterung umgangen werden.
1.5 Java-Applikation ausführen
Um die Java-Anwendung innerhalb der Entwicklungsumgebung auszuführen:
Rechtsklick auf die Klasse im Package Explorer ->RUN AS->JAVA APPLICATION
Ausführung der Java-Anwendung in der Console / MS-DOS-Eingabeaufforderung:
- Verwendung eines default-packages wird angenommen • Verzeichnis aufrufen, in dem sich die class-Datei befindet (z.B. bin-Ordner
• java <Klassenname>
Bei Verwendung eines eigenen packages:
• java <package>.<Klassenname>
• z.B. java de.stud.inf.HalloWelt
1.5.1 Java-Applikation mit Parametern
Beispielhafter Auszug aus dem Quellcode:
1
public static void main(String[] args) {
2
System.out.println("Argumente: ");
for(int i=0;i<args.length;i++)
System.out.println(args[i]);
3
4
5
6
}
Listing 1.3: Java-Quellcode-Auszug
In der Entwicklungsumgebung können die Parameter über das Kontextmenü der entsprechenden Anwendung (Rechtsklick im Package Explorers) ->RUN AS->RUN CONFIGURATIONS
unter dem Tab ARGUMENTS - durch RETURN getrennt - eingetragen werden.
Unter der Karteikarte MAIN werden das Projekt und die main-class angegeben.
Die Anwendung wird direkt mit dem Button RUN gestartet.
8
Ausführung der Java-Anwendung in der Console / MS-DOS-Eingabeaufforderung:
- Verzeichnis aufrufen, in dem sich die class-Datei befindet (z.B. bin-Ordner)
- java <Klassenname> arg1 arg2 ...
1.6 Erstellen einer Bibliothek
Zur Weiterverwendung von Klassen anderer Projekte kann die zu verwendende Klasse über die
import-Anweisung integriert werden.
z.B. import de.test.util.* ⇒ importiert alle Klassen des Packages de.test.util.
Nach dem Speichern werden Fehler angezeigt, da sich das Projekt mit der / den verwendeten
Klasse(n) nicht im Klassenpfad befindet.
Lösung mit Hilfe von QUICKFIX (Kontextmenü):
Quickfix schlägt vor, das Projekt der importierten Klassen dem Build Pfad des aktuellen Projekts hinzuzufügen.
⇒ unter dem Menüpunkt PROJECT->PROPERTIES wird im Register PROJECTS das importierte Projekt hinzugefügt.
Alternativ kann auch ein Eintrag im Register LIBRARIES erfolgen (Add Class Folder ..., binOrdner des entsprechenden Projekts auswählen).
Die Weiterverwendung von Klassen anderer Projekte kann auch über die Nutzung von Bibliotheken erfolgen.
• Projekt anlegen (s.o)
• Klasse anlegen (s.o.)
• Im Package Explorer Kontextmenüpunkt EXPORT aufrufen (Exportformat JAR FILE)
• zu exportierende Ressource auswählen. Hierbei werden i.d.R. die Dateien .classpath und
.project nicht mit übernommen (gegebenfalls Häkchen entfernen).
• Export generated class files and resources“ (Standard) exportiert keine Quellcodedateien.
”
⇒ Die jar-Datei wird im workspace erstellt.
1.7 Verwenden einer Bibliothek
Empfehlenswert ist das Anlegen eines lib-Ordners unterhalb des Projekts, der die verwendeten
Jar-Dateien enthält!
In der Entwicklungsumgebung kann der lib-Ordner im Package Explorer angelegt, die benötigten Jars mit Hilfe eines Imports hinzugefügt werden.
9
Vorgehensweise:
• lib-Ordner markieren
• Kontextmenü aufrufen ->IMPORT
• FILESYSTEM auswählen
• From directory (im linken Fenster wird der Ordner ausgewählt, in dem sich die Jar-Dateien
befinden, rechts die gewünschte / zu importierende jar-Datei.)
Das Archiv (jar-Datei) muss nun dem Klassenpfad hinzugefügt werden
(PROJECT->PROPERTIES->JAVA BUILD PATH): in dem Tab LIBRARIES -> Button
ADD JAR anklicken und das gewünschte Archiv auswählen.
Ausführung der Java-Anwendung von der Console
- Verzeichnis aufrufen, in dem sich die class-Datei befindet (z.B. bin-Ordner)
java -classpath <Pfad zur Bib>/<bib>.jar; <Klasse>
Bsp.
java -classpath ../lib/myBib.jar; myClass
1.8 Standalone-Applikation erstellen (Standard Widget
Toolkit (SWT))
1.8.1 Variante 1
Import-Wizard öffnen ->File->Import... (Plug-in Development->Plug-ins and Fragments auswählen)
Auf der Import Plug-ins and Fragments“-Seite:
”
• Import from: The active target platform
• Plug-ins and Fragments to import: Select from all plug-ins and fragments found at the
specified location
• Import as: Projects with source folders
Auf der Selection Seite:
• Aus den gefundenen Plug-ins und Fragmenten
org.eclipse.swt.{platform}.{os} z.B. org.eclipse.swt.win32.win32.x86 64 auswählen
und den zu importierenden hinzufügen (Add ...)
10
⇒ im workspace wird ein Ordner org.eclipse.swt.win32.win32.x86 64 angelegt, der wiederum
die Ordner
• .settings
• about files
• bin
• library
• META-INF
• src und weitere Dateien wie
• .api description
• .project
• about
• fragment.properties
• build.properties und dlls enthält.
Der Ordner bin enthält org->eclipse->swt mit weiteren Ordnern und Dateien.
Der Ordner src enthält org->eclipse->swt mit weiteren Ordnern und Dateien.
Java-Projekt anlegen (s.o.)
Da das Projekt SWT erfordert, muss dies in den Projekt-Eigenschaften angegeben werden
(Rechtsklick auf das Projekt->Properties)
Auf der Java Build Path - Seite:
• Projects Tab öffnen
• org.eclipse.swt.{platform}.{os} - Projekt hinzufügen
Neue Klasse mit main-Methode anlegen
In der main-Methode folgenden Quellcode eintragen:
1
2
3
4
5
6
7
8
Display display = new Display();
Shell shell = new Shell(display);
shell.setText("Hello world!");
shell.open();
while (!shell.isDisposed()) {
if (!display.readAndDispatch()) display.sleep();
}
display.dispose();
11
Zunächst werden Compilierfehler angezeigt (rotes x neben den entsprechenden Zeilen)
Source->Organize Imports entfernt diese Fehler
Beim Ausführen erscheint u.U. ein Fehler, dass swt-win32-4332.dll nicht gefunden wurde.
Die DLL an die gewünschte Stelle zu kopieren, beseitigt den Fehler.
1.8.2 Variante 2
• Java Projekt erstellen
• Klasse mit obigem Code erstellen
• lib-Ordner unterhalb des Projekts anlegen und swt.jar importieren
• Zunächst werden Compilierfehler angezeigt (rotes x neben den entsprechenden Zeilen)
• swt.jar zum Klassenpfad hinzufügen (PROJECT->PROPERTIES->JAVA BUILD PATH):
in dem Tab LIBRARIES -> Button ADD JAR anklicken und das gewünschte Archiv auswählen.
• Über das Kontextmenü QUICK FIX aufrufen
• Je nachdem welcher Fehler ausgewählt wurde, erscheint die Meldung: Import ’Display’
bzw. ’Shell’ (org.eclipse.swt.widgets)
⇒ import org.eclipse.swt.widgets.*;
1.9 Tipps
• Zeilennummern hinzufügen: WINDOW->PREFERENCES GENERAL->EDITORS->TEXT
EDITORS show line numbers
• Weitere JRE verwenden: WINDOW->PREFERENCES JAVA->INSTALLED JREs
• Mit Javadoc-Kommentaren zusätzliche Dokumentation erzeugen
12
2 C/C++ Programmierung
2.1 Voraussetzungen
Um Eclipse darüberhinaus für die C/C++ Programmierung nutzen zu können, wird zum einen
ein entsprechender Compiler zum anderen das C/C++ Development Tool (CDT) benötigt. Als
Compiler stehen für Windows der MinGW GCC und der Cygwin GC zur Verfügung. MinGW
(Minimalist GNU for Windows) ist eine Open Source Entwicklungsumgebung für die Entwicklung nativer MS-Windows Anwendungen. Diese ist abhängig von einer Reihe von DLLs (z.B.
der MSVCRT.DLL, der MS C Runtime Library), welche Teil des Betriebssystems sind.
2.1.1 Installation CDT
Plugins wie das CDT können unter HELP->INSTALL NEW SOFTWARE installiert werden.
Dazu ist im Work with“-Feld
”
Kepler - http://download.eclipse.org/releases/kepler
einzutragen.
... Fetching children of Kepler ...
Aus der Liste mit verfügbaren Plugins kann das gewünschte Plugin z.B.
C/C++ Development Tools“ für die C/C++ Programmierung
”
ausgewählt werden.
2.1.2 Installation MinGW
MinGW-3.1.0-1 (Minimalist GNU for Windows) kann unter
prdownloads.sourceforge.net/mingw/MinGW-3.1.0-1.exe
heruntergeladen werden.
Installieren nach C:\MinGW
Für die C/C++ Programmierung sollte ein von der Java-Programmierung abweichendes workspace
gewählt werden.
Nach der Installation des Plugins wird unter
WINDOW->OPEN PERSPECTIVE auch die Perspektive C/C++ angeboten.
13
2.2 C/C++ Anwendung erstellen und ausführen
1. Projekt erstellen:
FILE->NEW->C++ Project
Project name: z.B. FirstProject
Project type: Executable - Empty Project
Toolchains: Compiler (MinGW GCC) auswählen
Unter Select Configurations“ DEBUG und RELEASE auswählen.
”
2. C-Datei erstellen:
FILE->NEW->SOURCE FILE
Source File: Hello.cpp (Datei-Endungen müssen klein geschrieben werden, da Eclipse sonst den
Fehler Nothing to build für project“ erzeugt, weil Eclipse diese nicht als C/C++ Dateien
”
erkennt!!!)
Für C-Projekte werden analog dazu C-Projekte bzw. .c-Dateien erstellt.
Im workspace werden unterhalb des Projekt-Ordners ”FirstProject”die Dateien
• .cproject
• project
• Hello (C-Quellcodedatei)
angelegt.
1
2
#include <iostream>
using namespace std;
3
4
5
6
7
int main() {
cout << "Hello, world!" << endl;
return 0;
}
Listing 2.1: C++-Datei
Bei angegebenem Beispielcode werden Fehler beim Namespace und bei der verwendeten Funktion angezeigt, da diese nicht aufgelöst werden können.
PROJECT->CLEAN beseitigt die Fehler.
3. Compilieren & Binden
BUILD PROJECT ..
Im Projekt-Ordner wird ein Ordner Debug angelegt, der die Anwendung und die .o-Datei enthält.
14
4. Programm ausführen
RUN AS->LOCAL C/C++ APPLICATION
2.3 Compilierung und Ausführung von der Console
Voraussetzungen:
Umgebungsvariable PATH um C:\MinGW\bin (Pfad, in dem sich z.B. die gcc.exe befindet)
erweitern.
Häufig enthält der bin-Ordner kein make.exe, oft ist nur ein mingw32-make.exe oder ähnliches
vorhanden, dann Kopie erstellen und in make umbenennen.
g++ -c -g Hello.cpp erzeugt Hello.o aus der Quellcodedatei
g++ -g -o Hello.exe Hello.o erzeugt Anwendung (Hello.exe) aus der Hello.o
2.4 Makefile
Erstellung der Anwendung kann auch mit Hilfe eines Makefiles erfolgen.
1
all: Hello.exe
2
3
4
clean:
del Hello.o Hello.exe
5
6
7
Hello.exe: Hello.o
g++ −g −o Hello.exe Hello.o
8
9
10
Hello.o: Hello.cpp
g++ −c −g Hello.cpp
Listing 2.2: Makefile
Datei als makefile“ (in Hochkommata) abspeichern
”
Aufrufen von der Console mit Hilfe des Befehls
make (startet make.exe)
Daraufhin wird der im aktuellen Verzeichnis gespeicherte makefile ausgeführt.
2.5 C++ Programm mit Makefile
Bei Projekten ohne selbst erstelltem Makefile wird von Eclipse automatisch ein Makefile generiert, um die Anwendung zu erzeugen. Ein individueller Makefile für den Erstellungsprozess ist
jedoch ebenfalls möglich.
15
1. C++ Makefile Projekt erstellen
FILE->NEW->PROJECT
Project Name: ...
Project Type: Makefile project - Empty project
Toolchains: MinGW GCC
2. C++ Datei anlegen
FILE->NEW->SOURCE FILE
3. Makefile erstellen
FILE->NEW ...
File name: makefile
Makefile (s.o.)
4. Kontextmenü zum Projekt -> BUILD PROJECT
5. -> RUN AS->LOCAL C/C++ APPLICATION
16
3 Java und Datenbanken
3.1 UCanAccess
Mit Java 8 wurde die JDBC-ODBC-Bridge entfernt, d.h. der herkömmliche Zugriff auf eine
Datenbank mittels
1
2
3
Class.forName("‘sun.jdbc.odbc.JdbcOdbcDriver"’);
Connection con = DriverManager.getConnection
("‘jdbc:odbc:NameDatenquelle"’,benutzerkennung,passwort);
ist auf diese Weise nicht mehr möglich.
Einen Lösungsansatz bietet der JDBC Treiber UCanAccess
(http://ucanaccess.sourceforge.net/site.html), welcher sowohl alte als auch neue Access-Formate
(.mdb, accdb) unterstützt.
Um UCanAccess zu nutzen, werden die folgenden Komponenten benötigt:
• UCanAccess (ucanaccess-2.x.x.jar)
• HSQLDB (hsqldb.jar, version 2.2.5 or newer)
• Jackcess (jackcess-2.x.x.jar)
• commons-lang (commons-lang-2.4.jar, or newer)
• commons-logging (commons-logging-1.0.4.jar, or newer
UCanAccess enthält bereits alle erforderlichen JAR Files im Zip. Nach dem Entpacken erhält
man unter anderem die folgenden Bibliotheken:
• ucanaccess-2.0.4.jar
• lib/commons-lang-2.6.jar
• lib/commons-logging-1.1.3.jar
• lib/hsqldb.jar
• lib/jackcess-2.0.3.jar
17
Durch Rechtsklick auf das Projekt → Build Path → Configure Build Path ... öffnet sich das
Menü für die Build Path Einstellungen. Hier können die 5 Bibliotheken dem Projekt als externe
JARs hinzugefügt werden (Libraries, Add External JARs...).
Der Zugriff auf die DB kann nun wie folgt aussehen:
1
2
import java.sql.∗;
public class BasicJDBC {
3
4
5
6
7
public static void main(String[] args) {
Connection con = null;
Statement stmt = null;
ResultSet rs = null;
8
9
String URL ="jdbc:ucanaccess://C:/Users/Benutzername/Desktop/DB.accdb";
10
11
12
13
14
15
16
17
18
try{
con = DriverManager.getConnection(URL);
stmt = con.createStatement();
}
catch(Exception e)
{
System.err.println("Verbindung zu " + URL + " konnte nicht hergestellt werden.");
}
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
try{
rs = stmt.executeQuery("select ∗ from tabelle");
while(rs.next()){
//...
System.out.println(rs.getString("feldName"));
}
}
catch(Exception e)
{
e.printStackTrace();
}
finally{
try{
if(rs != null) rs.close();
if(stmt != null) stmt.close();
if(con != null) con.close();
}
catch(Exception e)
{
e.printStackTrace();
}
}/∗∗/
}// Ende main
} // Ende class
18