From 078e927e51cbfa18e26bd35076a0eb5b5bf1ffb8 Mon Sep 17 00:00:00 2001 From: Stefan Suhren Date: Fri, 9 Oct 2015 09:58:02 +0200 Subject: Add needed files --- Aufgabe7/latexsupport.txt | 433 ++++++ Aufgabe7/pmdesc3.pl | 369 +++++ Aufgabe7/programmierung-praktikum.tex | 2468 +++++++++++++++++++++++++++++++++ 3 files changed, 3270 insertions(+) create mode 100644 Aufgabe7/latexsupport.txt create mode 100755 Aufgabe7/pmdesc3.pl create mode 100644 Aufgabe7/programmierung-praktikum.tex (limited to 'Aufgabe7') diff --git a/Aufgabe7/latexsupport.txt b/Aufgabe7/latexsupport.txt new file mode 100644 index 0000000..c58394f --- /dev/null +++ b/Aufgabe7/latexsupport.txt @@ -0,0 +1,433 @@ +*latexsupport.txt* LATEX Support Mar 17 2006 + +LaTeX Support *latex-support* *latexsupport* + Plugin version 1.6 + for Vim version 6.0 and above + Fritz Mehner + +Write and run LaTeX programs using menus. + + 1. Usage |latexsupport-usage-gvim| + 1.1 Menu 'Comments' |latexsupport-comm| + 1.1.1 Append aligned comments to consecutive lines |latexsupport-comm-1| + 1.1.2 Code to comment |latexsupport-comm-2| + 1.1.3 Comment to code |latexsupport-comm-3| + 1.1.4 Frame comments, file header, ... |latexsupport-comm-4| + 1.2 Menu 'LaTeX' |latexsupport-latex| + 1.3 Menu 'Wizard' |latexsupport-wizard| + 1.3.1 Menu 'Snippets' |latexsupport-snippets| + 1.4 Menu 'Run' |latexsupport-run| + 1.4.1 Save and run |latexsupport-run-1| + 1.4.2 Run lacheck |latexsupport-run-2| + 1.4.3 Make clean |latexsupport-run-3| + 1.4.4 Settings |latexsupport-run-4| + 2. Hotkeys |latexsupport-hotkeys| + 3. Customization and configuration |latexsupport-custom| + 3.1 Global variables |latexsupport-custom-1| + 4. Template files and tags |latexsupport-tempfiles| + 4.1 Template files |latexsupport-tempfiles-1| + 4.2 Tags |latexsupport-tempfiles-2| + 5. Dictionaries |latexsupport-dictionary| + 6. Extend taglist.vim for LaTeX |latexsupport-taglist| + 7. Syntax based folding |latexsupport-folding| + 8. Release Notes |latexsupport-release-notes| + + How to add this help file to Vim's help |add-local-help| + + +============================================================================== +1. USAGE WITH GUI (gVim) *latexsupport-usage-gvim* +============================================================================== + +If the gvim root menu entry 'LaTeX' is not visible call it with the entry +"Load LaTeX Support" from the standard Tools-menu. +The entry "Load LaTeX Support" can also be used to unload the LaTeX-root menu. + +------------------------------------------------------------------------------ +1.1 MENU 'Comments' *latexsupport-comm* +------------------------------------------------------------------------------ + +1.1.1 APPEND ALIGNED COMMENTS TO CONSECUTIVE LINES *latexsupport-comm-1* + +In NORMAL MODE the menu entry + 'Line End Comm.' +will append "%" to the current line. + +In VISUAL MODE these entries will append aligned comments to all marked lines. +Marking and commenting the first 3 lines + + \lstset{stepnumber=0} + \lstset{framesep=2mm} + \lstset{linewidth=160mm} + \lstset{xleftmargin=6mm} + +yield + + \lstset{stepnumber=0} % + \lstset{framesep=2mm} % + \lstset{linewidth=160mm} % + \lstset{xleftmargin=6mm} + +The cursor will be positioned at the end of the first line. + +------------------------------------------------------------------------------ + +1.1.2 CODE TO COMMENT *latexsupport-comm-2* + +A marked block + +xxxxxxxx +xxxxxxxx +xxxxxxxx + +will be changed by the menu entry 'code->comment' into a multiline comment +(all (partially) marked lines): + +%xxxxxxxx +%xxxxxxxx +%xxxxxxxx + +------------------------------------------------------------------------------ + +1.1.3 COMMENT TO CODE *latexsupport-comm-3* + +If one or more commented lines are marked the entry 'comment->code' will +them. + +------------------------------------------------------------------------------ + +1.1.4 FRAME COMMENTS, FILE HEADER, ... *latexsupport-comm-4* + +Frame comments and the file header comment are read as templates from the +appropriate files (see |latexsupport-tempfiles|). + + +------------------------------------------------------------------------------ +1.2 MENU 'LaTeX' *latexsupport-latex* +------------------------------------------------------------------------------ + +1.2.1 NORMAL MODE, INSERT MODE. + +An empty statement will be inserted. The entry 'environment->\figure{}' will +insert an empty figure environment, change into insert mode and set the cursor +at the beginning of the 2. line: + +\begin{figure} + +\end{figure} + + +1.2.2 VISUAL MODE. + +Many entries will set a marked region inside the chosen construct. The +highlighted area + +xxxxx +xxxxx + +will be changed to + +\begin{figure} +xxxxx +xxxxx +\end{figure} + +by the entry 'environment->\figure{}' . + +The entry '\ref' changes the marked text 'xxxxxx' in + aaa xxxxxx bbbbbbbb +to + aaa \ref{xxxxxx} bbbbbbbb + +Some entries will double the marked text. The entry '\index' changes the +marked text 'xxxxxx' in + aaa xxxxxx bbbbbbbb +to + aaa xxxxxx \index{xxxxxx} bbbbbbbb + + +------------------------------------------------------------------------------ +1.3 MENU 'Wizard' *latexsupport-wizard* +------------------------------------------------------------------------------ + +1.3.1 CODE SNIPPETS *latexsupport-snippets* + +Code snippets are pieces of code which are kept in separate files in a special +directory (e.g. a few lines of code or a complete template for a Makefile). +File names are used to identify the snippets. The snippet directory will be +created during the installation ( $HOME/.vim/codesnippets-latex is the +default). Snippets are managed with the 3 entries + + LaTeX -> Snippets -> read code snippet + LaTeX -> Snippets -> write code snippet + LaTeX -> Snippets -> edit code snippet + +from the Snippets submenu. + +CREATING A NEW SNIPPET +When nothing is marked, "write code snippet" will write the whole buffer +to a snippet file, otherwise the marked area will be written to a file. + +INSERT A SNIPPET +Select the appropriate file from the snippet directory ("read code snippet"). +The inserted lines will be indented. + +EDIT A SNIPPET +This is a normal edit. + + +------------------------------------------------------------------------------ +1.4 MENU 'Run' *latexsupport-run* +------------------------------------------------------------------------------ + +1.4.1 SAVE AND RUN *latexsupport-run-1* + +Save the current buffer and run it through latex. Errors and warnings will be +shown in a quickfix error window. You can navigate using quickfix commands +(see |quickfix|). + +1.4.2 RUN lacheck *latexsupport-run-2* + +Save the current buffer and run it through lacheck (consistency checker for +LaTeX documents). Errors and warnings will be shown in a quickfix error +window. You can navigate using quickfix commands (see |quickfix|). + +1.4.3 MAKE CLEAN *latexsupport-run-3* + +This will remove the files with the following extension from the current +working directory: + + aux bbl blg brf dvi idx ilg ind + lof log lol lot out pdf ps toc + +This list of extensions is the default. The list can be changed by setting the +global variable g:LATEX_Files_Clean . + +1.4.4 SETTINGS *latexsupport-run-4* + +Show the actual settings (global variables, plugin tags, version). + +============================================================================== +2. HOTKEYS *latexsupport-hotkeys* +============================================================================== + +The following hot keys are defined in normal, visual and insert mode: + + Alt-F9 call xdvi + Ctrl-F9 compile with latex + Shift-F9 rum make + +The hot keys are defined in the file type plugin tex.vim . + + +============================================================================== +3. CUSTOMIZATION *latexsupport-custom* +============================================================================== + +------------------------------------------------------------------------------ +3.1 GLOBAL VARIABLES *latexsupport-custom-1* +------------------------------------------------------------------------------ + +Several global variables are checked by the script to customize it: + + ------------------------------------------------------------------------------ + GLOBAL VARIABLE DEFAULT VALUE TAG (see below) + ------------------------------------------------------------------------------ + g:LATEX_AuthorName "" |AUTHOR| + g:LATEX_AuthorRef "" |AUTHORREF| + g:LATEX_Email "" |EMAIL| + g:LATEX_Company "" |COMPANY| + g:LATEX_Project "" |PROJECT| + g:LATEX_CopyrightHolder "" |COPYRIGHTHOLDER| + + g:LATEX_Template_Directory $HOME."/.vim/plugin/templates/" + g:LATEX_File_Header "tex-file-header" + + g:LATEX_CodeSnippets $HOME."/.vim/codesnippets-latex/" + g:LATEX_Dictionary_File "" + g:LATEX_LoadMenus "yes" + + g:LATEX_File_Extension "tex" + g:LATEX_dvi_viewer "xdvi" + g:LATEX_ps_viewer "gv" + g:LATEX_pdf_viewer "acroread" + g:LATEX_Files_Clean 'aux bbl blg brf dvi idx ilg ind lof log lol lot out pdf ps toc' + + ---------------------------------------------------------------------------- + +1. group: Defines the text which will be inserted for the tags when a template + is read in (see also |latexsupport-tempfiles| below). + + g:LATEX_AuthorName : author name + g:LATEX_AuthorRef : author reference (e.g. acronym) + g:LATEX_Email : email address + g:LATEX_Company : name of the company / institution + g:LATEX_Project : project + g:LATEX_CopyrightHolder : the copyright holder + +2. group: g:LATEX_Template_Directory : Sets the template directory and the names of the + ... template files (see |latexsupport-tempfiles|). + +3. group: g:LATEX_CodeSnippets : The name of the code snippet directory + (see |latexsupport-snippets|). + g:LATEX_Dictionary_File : The name(s) of the dictionary file(s) used for + word completion (see also |latexsupport-dictionary|) + g:LATEX_LoadMenus : Load menus and mappings ("yes", "no") at startup. + +4. group: g:LATEX_File_Extension : File extension for latex files (default: tex). + g:LATEX_dvi_viewer : The standard dvi viewer (default: xdvi). + g:LATEX_ps_viewer : The standard Postscript viewer (default: gv). + g:LATEX_pdf_viewer : The standard PDF viewer (default: acroread). + g:LATEX_Files_Clean : List of file extensions for files to be deleted + (see |latexsupport-run-1|). + +To override the defaults add appropriate assignments to .vimrc . +Here are my settings as an example: + + let g:LATEX_AuthorName = "Dr.-Ing. Fritz Mehner" + let g:LATEX_AuthorRef = "Mn" + let g:LATEX_Email = "mehner@fh-swf.de" + let g:LATEX_Company = "FH Südwestfalen, Iserlohn" + + +============================================================================== +4. TEMPLATE FILES AND TAGS *latexsupport-tempfiles* +============================================================================== + +------------------------------------------------------------------------------ +4.1 TEMPLATE FILES *latexsupport-tempfiles-1* +------------------------------------------------------------------------------ + +Some menu entries generate comments or commented code. Four menu entries +generate block comments: + + Frame Comm. %% + Frame Comm. == + Frame Comm. -- + File Prolog + +The file prolog is inserted from a file: + ++--------------------------+--------------------------------------------------------+ +| menu entry | global variable | file (distribution set) | ++--------------------------+---------------------------+----------------------------+ +| LaTeX-file header | g:LATEX_File_Header | tex-file-header | +| | | | +| < future extensions > | | | ++--------------------------+--------------------------------------------------------+ + +The template files can be written or changed by the user to fulfill special +requirements (layout for a project or work group already exists, +file headers / blocks have to be prepared for a documentation tool, ... ). +They can hold not only comments but a complete file skeleton if this is +necessary. So you may want to lay out your own templates. + + +------------------------------------------------------------------------------ +4.2 TAGS *latexsupport-tempfiles-2* +------------------------------------------------------------------------------ + +The comments in these files do not have to be personalized but they can be. +The text can contain the following tags which are replaced by the appropriate +information when the file is read in: + + |AUTHOR| + |AUTHORREF| + |COMPANY| + |COPYRIGHTHOLDER| + |CURSOR| + |DATE| + |EMAIL| + |FILENAME| + |PROJECT| + |TIME| + |YEAR| + +Each tag can occur more than once. The tag |CURSOR| may appear only once. +The tag |CURSOR| will be the cursor position after the block is read in. +There is no need to use any of these tags, some or all can be missing. +The template files can actually be links pointing to existing templates. + + +============================================================================== +5. DICTIONARY *latexsupport-dictionary* +============================================================================== + +The file + + wordlists/german.list + +is a part of this plugin and can be used (together with your own lists) as +dictionary for automatic word completion. There is no default word list. If +you want to use it with an additional list MyC.list put the following lines +into .vimrc : + + let g:Latex_Dictionary_File = $HOME."/.vim/wordlists/german.list,". + \ $HOME."/.vim/wordlists/MyC.list" + +The right side is a comma separated list of files. Note the point at the end +of the first line (string concatenation) and the backslash in front of the +second line (continuation line). +You can use Vim's dictionary feature CTRL-X, CTRL-K (and CTRL-P, CTRL-N). + + +============================================================================== +6. EXTEND taglist.vim FOR LaTeX *latexsupport-taglist* +============================================================================== + +The use of the Vim plugin taglist.vim (Author: Yegappan Lakshmanan) is highly +recommended. It uses the program ctags which generates tag files for 3 dozen +languages (Exuberant Ctags, Darren Hiebert, http://ctags.sourceforge.net). +With the following extensions the structure of a LaTeX document and the list +of targets in a makefile can be shown in the taglist window. + +1) Append the file customization.ctags to the file $HOME/.ctags . + +2) Add the following lines (from customization.vimrc) to $HOME/.vimrc : + + " + "------------------------------------------------------------------- + " taglist.vim : define the title texts for LaTeX + " taglist.vim : define the title texts for make + "------------------------------------------------------------------- + noremap :Tlist + inoremap :Tlist + + let tlist_tex_settings = 'latex;s:sections;g:graphics;l:labels' + + let tlist_make_settings = 'make;m:makros;t:targets' + + +3) restart vim/gvim + +The two maps will toggle the taglist window (hot key F11) in all editing modes. +The two assignments define the headings for the make sections in the taglist +window. + + +============================================================================== +7. SYNTAX BASED FOLDING *latexsupport-folding* +============================================================================== + +The file syntax/tex.vim contains the basic settings for syntax based folding +(see also |folding|). The Vim variable foldlevel is set to 999 : + set foldlevel=999 +i.e. folding starts at block nesting level 999 (i.e. at first there is +no folding at all). +This could be changed to an appropriate value, e.g. 5. Folding now would start +always at level 5. +The alternative is to keep the level 999 and start folding with the normal +mode command 'zM' (close all folds) and then open those folds needed. + +To enable syntax based folding uncomment the last 3 lines in the file +syntax/tex.vim . + + +============================================================================== +8. RELEASE NOTES *latexsupport-release-notes* +============================================================================== + +See file README.latexsupport . + +============================================================================== +vim:tw=78:noet:ts=2:ft=help:norl: diff --git a/Aufgabe7/pmdesc3.pl b/Aufgabe7/pmdesc3.pl new file mode 100755 index 0000000..63e8105 --- /dev/null +++ b/Aufgabe7/pmdesc3.pl @@ -0,0 +1,369 @@ +#!/usr/bin/perl -w +#=================================================================================== +# +# FILE: pmdesc3 +# +# SYNOPSIS: Find versions and descriptions of installed perl Modules and PODs +# +# DESCRIPTION: See POD below. +# +# CREATED: 15.06.2004 22:12:41 CEST +# REVISION: 23.10.2004 +# - Module versions are checked with a regex; avoids unprintable +# characters (original version) and doubling of entries. +# - new option -v +# 28.10.2004 +# - Function get_module_description completely new written. +# 29.01.2005 +# - Look for a description in the DESCRIPTION section if no +# NAME section is found. +# 16.04.2005 +# - Adaption for MS Windows. +# TODO: Replace UNIX sort pipe. +# +#=================================================================================== + +package pmdesc3; + +$VERSION=1.2.2; # update POD at the end of this file + +require 5.6.1; + +use strict; +use Carp; +use ExtUtils::MakeMaker; +use File::Find qw(find); +use Getopt::Std qw(getopts); + +my $MaxDescLength= 150; # Maximum length for the description field: + # prevents slurping in big amount of faulty docs. + +my $rgx_version = q/\A\d+(\.\w+)*\Z/; # regex for module versions + +#=== FUNCTION ==================================================================== +# NAME: usage +#=================================================================================== +sub usage { + my $searchdirs = " "x12; + $searchdirs .= join( "\n"." "x12, sort { length $b <=> length $a } @INC ) . "\n"; + print <; # slurp mode + close ( INFILE ); # close input file + + $file =~ s/\cM\cJ/\cJ/g; # remove DOS line ends + $file =~ m/\A=head1\s+NAME(.*?)\n=\w+/s; # file starts with '=head1' (PODs) + $desc = $1; + + if ( ! defined $desc ) + { + $file =~ m/\n=head1\s+NAME(.*?)\n=\w+/s; # '=head1' is embedded + $desc = $1; + } + + if ( ! defined $desc ) + { + $file =~ m/\n=head1\s+DESCRIPTION(.*?)\n=\w+/s; # '=head1' is embedded + $desc = $1; + } + + if ( defined $desc ) + { + $desc =~ s/\A[ \t\n]*//s; # remove leading whitespaces + $desc =~ s/\n\s+\n/\n\n/sg; # make true empty lines + $desc =~ s/\n\n.*$//s; # discard all trailing paragraphs + $desc =~ s/\A.*?\s+-+\s+//s; # discard leading module name + $desc =~ s/\n/ /sg; # join lines + $desc =~ s/\s+/ /g; # squeeze whitespaces + $desc =~ s/\s*$//g; # remove trailing whitespaces + $desc = substr $desc, 0, $MaxDescLength; # limited length + } + return $desc; +} + +#=== FUNCTION ==================================================================== +# NAME: get_module_version +#=================================================================================== +sub get_module_version { + local $_; # MM->parse_version is naughty + my $vers_code = MM->parse_version($File::Find::name) || ''; + $vers_code = undef unless $vers_code =~ /$rgx_version/; + return $vers_code; +} + +#=== FUNCTION ==================================================================== +# NAME: MAIN +#=================================================================================== + +my %visited; + +$|++; + +#--------------------------------------------------------------------------- +# process options and command line arguments +#--------------------------------------------------------------------------- +my %options; + +getopts("hst:v:", \%options) or $options{h}=1; + +my @args = @ARGV; +@ARGV = @INC unless @ARGV; + +usage() if $options{h}; # option -h : usage + +#--------------------------------------------------------------------------- +# option -t : width of the module name column +#--------------------------------------------------------------------------- +usage() if $options{t} && $options{t}!~/^\d{1,3}$/; # width 1-3 digits + +$options{t} = "36" unless $options{t}; + +#--------------------------------------------------------------------------- +# option -v : width of the version column +#--------------------------------------------------------------------------- +usage() if $options{v} && $options{v}!~/^\d{1,2}$/; # width 1-2 digits + +$options{v} = "10" unless $options{v}; + +#--------------------------------------------------------------------------- +# option -s : install an output filter to sort the module list +#--------------------------------------------------------------------------- +if ($options{s}) { + usage() if $^O eq "MSWin32"; + if (open(ME, "-|")) { + $/ = ""; + while () { + chomp; + print join("\n", sort split /\n/), "\n"; + } + exit; + } +} + +#--------------------------------------------------------------------------- +# process +#--------------------------------------------------------------------------- +# +# :WARNING:15.04.2005:Mn: under Windows descending into subdirs will be +# suppressed by the the preprocessing part of the following call to find +# :TODO:16.04.2005:Mn: remove code doubling +# +if ( $^O ne "MSWin32" ) { # ----- UNIX, Linux, ... + + for my $inc_dir (sort { length $b <=> length $a } @ARGV) { + find({ + wanted => sub { + return unless /\.p(?:m|od)\z/ && -f; + + #--------------------------------------------------------------------- + # return from function if there exists a pod-file for this module + #--------------------------------------------------------------------- + my $pod = $_; + my $pm = $_; + if ( m/\.pm\z/ ) + { + $pod =~ s/\.pm\z/\.pod/; + return if -f $pod; + } + + my $module = get_module_name($File::Find::name, $inc_dir); + my $version; + if ( /\.pod\z/ ) + { + $pm =~ s/\.pod\z/\.pm/; + #------------------------------------------------------------------- + # try to find the version from the pm-file + #------------------------------------------------------------------- + if ( -f $pm ) + { + local $_; + $version = MM->parse_version($pm) || ""; + $version = undef unless $version =~ /$rgx_version/; + } + } + else + { + $version = get_module_version($_); + } + my $desc = get_module_description($_); + + $version = defined $version ? " ($version)" : " (n/a)"; + $desc = defined $desc ? " $desc" : " "; + + printf("%-${options{t}}s%-${options{v}}s%-s\n", $module, $version, $desc ); + + }, + + preprocess => sub { + my ($dev, $inode) = stat $File::Find::dir or return; + $visited{"$dev:$inode"}++ ? () : @_; + }, + }, + $inc_dir); + } +} +else { # ----- MS Windows + for my $inc_dir (sort { length $b <=> length $a } @ARGV) { + find({ + wanted => sub { + return unless /\.p(?:m|od)\z/ && -f; + + #--------------------------------------------------------------------- + # return from function if there exists a pod-file for this module + #--------------------------------------------------------------------- + my $pod = $_; + my $pm = $_; + if ( m/\.pm\z/ ) + { + $pod =~ s/\.pm\z/\.pod/; + return if -f $pod; + } + + my $module = get_module_name($File::Find::name, $inc_dir); + my $version; + if ( /\.pod\z/ ) + { + $pm =~ s/\.pod\z/\.pm/; + #------------------------------------------------------------------- + # try to find the version from the pm-file + #------------------------------------------------------------------- + if ( -f $pm ) + { + local $_; + $version = MM->parse_version($pm) || ""; + $version = undef unless $version =~ /$rgx_version/; + } + } + else + { + $version = get_module_version($_); + } + my $desc = get_module_description($_); + + $version = defined $version ? " ($version)" : " (n/a)"; + $desc = defined $desc ? " $desc" : " "; + + printf("%-${options{t}}s%-${options{v}}s%-s\n", $module, $version, $desc ); + + }, + }, + $inc_dir); + } +} + +#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +# Modul Documentation +#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +=head1 NAME + +pmdesc3 - Find versions and descriptions of installed perl modules and PODs + +=head1 SYNOPSIS + +pmdesc3 + +pmdesc3 ~/perllib + +=head1 DESCRIPTION + + pmdesc3 [-h] [-s] [-t ddd] [-v dd] [--] [dir [dir [dir [...]]]] + + OPTIONS: -h : print help message; show search path + -s : sort output (not under Windows) + -t ddd : name column has width ddd (1-3 digits); default 36 + -v dd : version column has width dd (1-2 digits); default 10 + +Find versions and descriptions of installed Perl Modules and PODs. +If no directories given, searches @INC . +The first column of the output (see below) can be used as module name or +FAQ-name for perldoc. + +Some modules are split into a pm-file and an accompanying pod-file. +The version number is always taken from the pm-file. + +The description found will be cut down to a length of at most +150 characters (prevents slurping in big amount of faulty docs). + +=over 2 + +=item Output + +The output looks like that: + + ... +IO::Socket (1.28) Object interface to socket communications +IO::Socket::INET (1.27) Object interface for AF_INET domain sockets +IO::Socket::UNIX (1.21) Object interface for AF_UNIX domain sockets +IO::Stty (n/a) +IO::Tty (1.02) Low-level allocate a pseudo-Tty, import constants. +IO::Tty::Constant (n/a) Terminal Constants (autogenerated) + ... + +The three parts module name, version and description are separated +by at least one blank. + +=back + +=head1 REQUIREMENTS + +ExtUtils::MakeMaker, File::Find, Getopt::Std + + +=head1 AUTHORS + + Tom Christiansen, tchrist@perl.com (pmdesc) + Aristotle, http://qs321.pair.com/~monkads/ (pmdesc2) + Fritz Mehner, mehner@fh-swf.de (pmdesc3) + +=head1 NOTES + +pmdesc3 is based on pmdesc2 (Aristotle, http://qs321.pair.com/~monkads/). +pmdesc3 adds extensions and bugfixes. + +pmdesc2 is based on pmdesc (Perl Cookbook, 1. Ed., recipe 12.19). +pmdesc2 is at least one magnitude faster than pmdesc. + +=head1 VERSION + +1.2.2 + +=cut + diff --git a/Aufgabe7/programmierung-praktikum.tex b/Aufgabe7/programmierung-praktikum.tex new file mode 100644 index 0000000..52bb5a2 --- /dev/null +++ b/Aufgabe7/programmierung-praktikum.tex @@ -0,0 +1,2468 @@ +%%===================================================================================== +%% FILE: programmierung-uebungen.tex +%% AUTHOR: Dr.-Ing. Fritz Mehner +%% EMAIL: mehner@fh-swf.de +%% VERSION: 1.1 +%% REVISION: 02.12.2002 +%% CREATED: 01.08.2002 +%%===================================================================================== + +%%%%%%%%%%%%%%%%%%%%%% LATEX-Vorspann %%%%%%%%%%%%%%%%%%%%%% + +\documentclass[oneside,10pt,a4paper]{book} +\newcommand{\Seitenformat}{1} + +%%\documentclass[doubleside,10pt,a4paper]{book} +%%\newcommand{\Seitenformat}{2} + +\usepackage{gastex} +\usepackage{german} +\usepackage[T1]{fontenc} +\usepackage[latin1]{inputenc} +\usepackage{makeidx} +\makeindex +\usepackage{geometry} +\geometry{verbose,a4paper,tmargin=20mm,bmargin=15mm,lmargin=20mm,rmargin=20mm} +\setlength\parskip{\medskipamount} +\setlength\parindent{0pt} + +\usepackage{listings} +\usepackage{graphicx} +\usepackage{floatflt} +\usepackage{amsmath} +\usepackage[hang]{subfigure} +\usepackage{setspace} +\usepackage{ifthen} + +\usepackage[usenames]{color} +\usepackage{fancyhdr} +\usepackage{pstricks} + +%\usepackage[ps2pdf]{hyperref} + +\newcommand{\DokumentAusgabestand}{02.12.2002} + +%%%%%%%%%%%%%%%%%%%%%% LATEX-Dokument %%%%%%%%%%%%%%%%%%%%%% + +\begin{document} + +%%---------------------------------------------------------------------- +%% Abschnittsüberschriften umbenennen +%%---------------------------------------------------------------------- +\renewcommand{\chaptername}{Übung} +\renewcommand{\indexname}{Stichwortverzeichnis} + +%%---------------------------------------------------------------------- +%% Einstellungen für fancyhdr +%%---------------------------------------------------------------------- +\pagestyle{fancyplain} %% fancyplain erzeugt Kopf- und Fußeinträge + %% auf auf den Seiten mit Kapitelanfängen +\fancyhf{} +\fancyfoot[c]{\thepage} +\ifthenelse{\Seitenformat = 1 } +{ %% ----- einseitig ------------------------------------- +\fancyhead[RE,RO]{\leftmark} +\fancyfoot[RO,RE]{\scriptsize Praktikum Programmierung} +\fancyfoot[LE,LO]{\scriptsize Stand \DokumentAusgabestand} +} +{ %% ----- doppelseitig ------------------------------------- +%%\fancyhead[RE,LO]{\leftmark} +\fancyhead[LO]{\rightmark} +\fancyhead[RE]{\leftmark} +\fancyfoot[RO,LE]{\scriptsize Praktikum Programmierung} +\fancyfoot[RE,LO]{\scriptsize Stand \DokumentAusgabestand} +} + + +%%---------------------------------------------------------------------- +%% Einstellungen für das Paket listings +%%---------------------------------------------------------------------- +\lstset{basicstyle={\ttfamily,\footnotesize},tabsize=2,frame=single} +\lstset{extendedchars=true,numbers=left,stepnumber=5,numberstyle=\tiny} +\lstset{framesep=2mm} +\lstset{linewidth=166mm} +\lstset{xleftmargin=6mm} +\lstset{identifierstyle=\ttfamily,keywordstyle=\bfseries} +\lstset{commentstyle=\normalfont} +\lstset{showstringspaces=false} +\lstdefinestyle{ANSI}{language=C} +\lstdefinestyle{C++}{alsolanguage=C++} + +\renewcommand\lstlistlistingname{Programmlisten} +\renewcommand\lstlistingname{Liste} + + +%%---------------------------------------------------------------------- +%% Titelblatt - Vorderseite +%%---------------------------------------------------------------------- + +%\title{\textbf{\textsc{\Huge Praktikum Programmierung}}} + + +\title{ +\begin{onehalfspace} +\textbf{\textsc{ +\Huge{Praktikum}\\ +\large{zu den Veranstaltungen}\\ +\Huge{Programmierung I}\\ +\Huge{Programmierung II}\\ +}} +\end{onehalfspace} +} +\author{\textbf{\textsc{Prof. Dr.-Ing. Fritz Mehner }}\\ +\\ +Fachhochschule Südwestfalen\\ +Fachbereich Informatik und Naturwissenschaften} + +\date{Stand \DokumentAusgabestand} +\maketitle + +%%---------------------------------------------------------------------- +%% Titelblatt - Rückseite +%%---------------------------------------------------------------------- + +\newpage + +\begin{quote} +\textbf{\textsc{Prof. Dr.-Ing. Fritz Mehner}}\\ +Fachhochschule Südwestfalen\\ +Fachbereich Informatik und Naturwissenschaften\\ +Frauenstuhlweg 31\\ +58644 Iserlohn\\ +\\ +Tel. 02371-566-201\\ +Email: mehner@fh-swf.de\\ +Raum: Z-127\\ +\end{quote} + +%%---------------------------------------------------------------------- +%% Buchvorspann +%%---------------------------------------------------------------------- +\frontmatter + +%%---------------------------------------------------------------------- +%% Einführung +%%---------------------------------------------------------------------- +\chapter*{Einführung} +\addcontentsline{toc}{chapter}{Einführung} + +Das vorliegende Dokument enthält die Übungen zu den Veranstaltungen \textbf{Programmierung 1} +und \textbf{Programmierung 2} für die folgenden Studiengänge: + +\begin{doublespace} +\begin{center} + %%~~~~~ TABULAR : begin ~~~~~~~~~~ + \begin{tabular}[]{|l|l|l|} + \hline \textbf{Studiengang} & \textbf{Fachbereich} & \textbf{Semester} \\ + \hline + \hline Angewandte Informatik & Informatik und Naturwissenschaften & 1. und 2. Sem. \\ [0.0ex] + \hline Physikalische Technik & Informatik und Naturwissenschaften & 1. und 2. Sem. \\ + \hline Mechatronik & Maschinenbau & 3. und 4. Sem. \\ + \hline + \end{tabular} \\ [0.0ex] + %%~~~~~ TABULAR : end ~~~~~~~~~~ +\end{center} +\end{doublespace} +\vspace{ 10mm} + +Die Durchführung der Aufgaben gibt Gelegenheit, das in der Vorlesung Gehörte +anzuwenden und zu vertiefen. + +Die Teilnahme am Praktikum und die Durchführung der Übungen sind Pflicht. +Die selbständige und erfolgreiche Lösung der Aufgaben wird im Praktikum bescheinigt +und ist eine Voraussetzung für die Teilnahme an der Klausur. + +Programmieren kann man nur lernen indem man programmiert. +Wenn keine Vorkenntnisse vorhanden sind, können die Anfänge durchaus mühevoll sein. +Die alleinige Teilnahme am Praktikum, d.h. Programmieren am Rechner +im Umfang von 2 Semesterwochenstunden, reicht \textit{keinesfall} zum Erwerb +gefestigter Grundkenntnisse aus. + +\begin{quote} +Es ist zwingend erforderlich auch außerhalb der Lehrveranstaltungen +das in der Vorlesung erworbene Wissen praktisch nachzuvollziehen, anzuwenden und zu vertiefen. +\end{quote} + +Dazu sollte auf dem eigenen Rechner eine entsprechende Entwicklungsumgebung zur +Verfügung stehen . +Grundsätzlich ist jeder Compiler oder jede Entwicklungsumgebung geeignet, sofern +die ANSI-C-Verträglichkeit gegeben ist. +Aus Kostengründen bietet sich freie Software an (LINUX oder FreeBSD). +Selbstverständlich können auch die Einrichtungen der Fachhochschule benutzt werden. + + +%%---------------------------------------------------------------------- +%% Zur Darstellung +%%---------------------------------------------------------------------- +\section*{Zur Darstellung} + +Programmcode, Programmausgaben, Programm- und Dateinamen, Schlüsselwörter von Programmiersprachen +und Menüeinträge erscheinen in \texttt{Schreibmaschinenschrift mit fester Zeichenbreite}. + +In den gerahmten C-/C++-Listen werden für Code und Kommentar zur Verbesserung der Lesbarkeit +unterschiedliche Schriftarten verwendet. + +Der Nachkommaanteil reeller Zahlen wird, entsprechend der Darstellung in den meisten Programmiersprachen, +durch einen \textit{Dezimalpunkt} abgetrennt, also z.B. PI = 3.1415 . + +Dieses Dokument wurde mit \LaTeX\ erzeugt. + + +%%---------------------------------------------------------------------- +%% Inhaltsverzeichnis / weitere Verzeichnisse +%%---------------------------------------------------------------------- +\cleardoublepage +\setcounter{tocdepth}{1} +\addcontentsline{toc}{chapter}{Inhaltsverzeichnis} +\tableofcontents{} + +%%\cleardoublepage +%%\addcontentsline{toc}{chapter}{Abbildungsverzeichnis} +%%\listoffigures +%% +%%\cleardoublepage +%%\addcontentsline{toc}{chapter}{Tabellenverzeichnis} +%%\listoftables +%% +%%\cleardoublepage +%%\addcontentsline{toc}{chapter}{Programmlisten} +%%\lstlistoflistings + +%%---------------------------------------------------------------------- +%% Buchhauptteil +%%---------------------------------------------------------------------- +\mainmatter + + +%%---------------------------------------------------------------------- +%% ÜBUNG : Summation unendlicher Reihen +%%---------------------------------------------------------------------- +\chapter{Summation unendlicher Reihen} +\index{Summation} +\index{Reihe! unendliche} + +%%---------------------------------------------------------------------- +%% Bildung endlicher Reihensummen +%%---------------------------------------------------------------------- +\section{Bildung endlicher Reihensummen} +\index{Reihe! harmonische} +\index{Reihe! harmonische!alternierend} +\index{Reihe! leibnizsche} +\index{Reihe! geometrische} + +\begin{align} +H & =\; \; \sum _{i=1}^{\infty }\frac{1}{i} +&&=\; \; \frac{1}{1}+\frac{1}{2}+\frac{1}{3}+\frac{1}{4}+\ldots \label{eq:HReihe} &&&\\ +A & =\; \; \sum _{i=1}^{\infty }\frac{\left(-1\right)^{i+1}}{i} +&&=\; \; \frac{1}{1}-\frac{1}{2}+\frac{1}{3}-\frac{1}{4}+\ldots \label{eq:AReihe} &&&\\ +L & =\; \; \sum _{i=1}^{\infty }\frac{\left(-1\right)^{i+1}}{2i-1} +&&=\; \; \frac{1}{1}-\frac{1}{3}+\frac{1}{5}-\frac{1}{7}+\ldots \label{eq:LReihe} &&&\\ +G & =\; \; \sum _{i=0}^{\infty }\frac{1}{2^{i}} +&& =\; \; \frac{1}{1}+\frac{1}{2}+\frac{1}{4}+\frac{1}{8}+\ldots \label{eq:GReihe} &&& +\end{align} + + +\begin{table}[h] + +\begin{onehalfspace} +\begin{center} +\begin{tabular}{|c|c|c|} +\hline +\textbf{Gleichung}& \textbf{Name}& \textbf{Summe}\\ +\hline +\hline +\ref{eq:HReihe}& +harmonische Reihe& +$\infty $\\ +\hline +\ref{eq:AReihe}& +alternierende harmonische Reihe& +$ln$ 2\\ +\hline +\ref{eq:LReihe}& +Leibnizsche Reihe& +$\pi $/4\\ +\hline +\ref{eq:GReihe}& +Geometrische Reihe& +2\\ +\hline +\end{tabular} +\end{center} +\end{onehalfspace} + +\caption{\label{cap:Unendliche-Reihen}Unendliche Reihen} +\end{table} + + +Die Bildung einer Summe S aus n Summanden wird mit Hilfe einer Schleife +durchgeführt. Bei jedem Schleifendurchlauf wird ein Summand $s_{i}$ +zu der sich aufbauende Summe S addiert: +\begin{eqnarray*} +S & = & s_{1}+s_{2}+s_{3}+\ldots +s_{n}\\ + & & \\ +S & = & 0\\ +S & = & S+s_{1}\\ +S & = & S+s_{2}\\ + & \ldots & \\ +S & = & S+s_{n} +\end{eqnarray*} + + +Schreiben Sie ein C-Programm, in welchem für jede dieser Reihen die +Summe der ersten 1000 Summanden gebildet und ausgegeben wird. + + +%%---------------------------------------------------------------------- +%% Wechselnde Vorzeichen +%%---------------------------------------------------------------------- +\subsection{Wechselnde Vorzeichen} +\index{Vorzeichen!wechselndes} + +Wechselnde Vorzeichen (Reihe \ref{eq:AReihe} und \ref{eq:LReihe}) +werden dadurch gebildet, daß man einer Hilfsvariablen v vor der Schleife +den Wert +1 zuweist. Die Summanden werden in der Schleife mit der +Vorzeichenvariablen v multipliziert. Danach wird mit der Zuweisung +v = -v die Umkehr des Vorzeichens für den nächsten Durchlauf erzwungen. + + +%%---------------------------------------------------------------------- +%% Nichtlinear wachsende oder fallende Summanden +%%---------------------------------------------------------------------- +\subsection{Nichtlinear wachsende oder fallende Summanden} + +Die Summanden der Geometrischen Reihe können ohne Potenzierung berechnet +werden. Der jeweils nächste Summand ergibt sich durch Multiplikation +mit dem Faktor $1/2$ aus dem vorhergehenden. Wenn die Variable \texttt{summand} +den Wert des Summanden aus dem letzten Schleifendurchlauf besitzt, +dann kann durch + +\begin{verbatim} +summand = 0.5*summand; +\end{verbatim} +der Wert für den aktuellen Schleifendurchlauf bestimmt werden. + + +%%---------------------------------------------------------------------- +%% Bildung ,,unendlicher'' Reihensummen +%%---------------------------------------------------------------------- +\section{Bildung ,,unendlicher'' Reihensummen} + +Die Bildung unendlicher Summen ist auf einem Digitalrechner natürlich nicht möglich. +Wegen der begrenzten Genauigkeit der Zahlendarstellung und der Tatsache, +daß die Summanden einer konvergierenden Reihe immer kleinere Beträge +annehmen, verändert die Addition weiterer Summanden eine bereits berechnete +Summe ab einem gewissen i nicht mehr ! +Wenn die Summe aus dem letzten Rechenschritt als Vergleichswert zur Verfügung steht, +kann dieser Umstand festgestellt und die Berechnung abgebrochen werden. +Die bis dahin ermittelte Summe stellt die Näherungslösung dar. + +Erstellen Sie eine neue Version des Programmes aus dem ersten Teil, +in welchem Sie dann alle Reihen solange aufsummieren, bis sich die +jeweilige Summe nicht mehr ändert. +Geben Sie die errechneten Summen aus und vergleichen Sie diese mit den +theoretischen Grenzwerten aus Tabelle \ref{cap:Unendliche-Reihen}. + + +%%---------------------------------------------------------------------- +%% ÜBUNG : Verwendung von Schleifen +%%---------------------------------------------------------------------- +\chapter{Verwendung von Schleifen} +\index{Schleifen} + +%%---------------------------------------------------------------------- +%% ASCII-Tabelle +%%---------------------------------------------------------------------- +\section{ASCII-Tabelle} +\index{ASCII-Tabelle} + +Schreiben Sie ein C-Programm, welches in 32 Zeilen eine 8-spaltige +ASCII-Tabelle ausgibt, die jeweils den Zahlenwert eines Zeichens (3-stellig +mit führenden Nullen) und das zugehörige abdruckbare Zeichen enthält. +Für die nicht darstellbaren Steuerzeichen (0-31) sollen 3 Punkte ausgegeben +werden. + +\lstset{language=C} +\lstinputlisting[caption={Programmausgabe: ASCII-Tabelle},label=ascii-tabelle]{ ./programme/ascii.txt } + + + +%%---------------------------------------------------------------------- +%% Teilsumme der harmonischen Reihe bei aufsteigender und absteigender Summation +%%---------------------------------------------------------------------- +\section{Teilsumme der harmonischen Reihe bei aufsteigender \\und absteigender Summation} +\index{Reihe! harmonische} +\index{Summation} + + +Schreiben Sie ein Programm, in welchem die Glieder der harmonischen +Reihe (Gleichung \ref{eq:HReihe}) beginnend mit 1/1 so lange aufsummiert +werden, bis sich die Reihensumme nicht mehr ändert und geben Sie die +Summe aus. + +Anschließend ist eine Schleife zu programmieren, die beginnend vom +letzten Wert des Index der vorhergehenden Schleife die Reihensumme +bildet und beim Summanden 1/1 endet. Diese Summe ist ebenfalls auszugeben. +Geben Sie nun die Differenz der beiden Summen aus (Exponentenformat). +Verwenden Sie den Datentyp \texttt{float} bei der Bildung der Summen. + +\begin{itemize} +\item Wie oft werden die beiden Schleifen durchlaufen ? +\item Was stellen Sie beim Vergleich der beiden Summen fest ? +\end{itemize} + + +%%---------------------------------------------------------------------- +%% Rundungsfehler durch fortgesetzte Multiplikation und Division +%%---------------------------------------------------------------------- +\section{Rundungsfehler durch fortgesetzte Multiplikation und Division} +\index{Rundungsfehler} + +Schreiben Sie ein Programm, in welchem die \texttt{float}-Zahl x = 1000000 +in einer ersten Schleife 10-mal mit dem \texttt{float}-Faktor k = 0.1693 multipliziert +wird. Das Ergebnis wird danach in einer zweiten Schleife 10-mal durch +den selben Faktor k dividiert. Theoretisch müßte danach x wieder den +Ausgangswert enthalten. Geben Sie den Ausgangswert und den Endwert +von x mit jeweils 10 Nachkommastellen aus und vergleichen Sie die +Werte. + +\begin{itemize} +\item Was stellen Sie beim Vergleich der beiden Werte fest ? +\end{itemize} + + +%%---------------------------------------------------------------------- +%% Steuerung einer for-Scheife +%%---------------------------------------------------------------------- +\section{Steuerung einer \texttt{for}-Scheife} + + + +%%----- FIGURE : begin ---------- +\begin{figure}[htb] +\begin{center} +\includegraphics[scale=.5]{./bilder/parabel.eps} +\caption{ \label{ABB:Parabel} Punktweise Berechnung einer Parabel } +\vspace{ 5mm} +\end{center} +\end{figure} +%%----- FIGURE : end ---------- + +Die Funktion $f(x)=x^{2}$ ist im Bereich von $x = 0\ldots30$ auszuwerten. +Dazu wird das x-Intervall {[}0,30{]} in 250 Teilintervalle der Länge +$\Delta x = 30/250 = 0.12$ eingeteilt und die Funktion an den 251 Teilungspunkten +ausgewertet (Abb. \ref{ABB:Parabel}). +Die Teilungspunkte $x_{i}$ und die dazugehörigen Funktionswerte $f(x_{i})$ +sollen in einer \texttt{for}-Schleife berechnet werden. Dabei sollen 3 verschiedene +Steuerungsmethoden ausprobiert werden: + +\begin{enumerate} +\item Ganzzahliger Schleifenzähler \texttt{i} . Das laufende $x_{i}$ wird durch +Multiplikation des Schleifenzählers mit der Intervalllänge ermittelt: +$x_{i}=i*\Delta x$ .\\ +Anmerkung: Der aktuelle Wert von $x_{i}$ hängt nur von einer Multiplikation +ab. +\item Ganzzahliger Schleifenzähler \texttt{i} . Das laufende $x_{i}$ wird durch +fortlaufende Addition der Intervalllänge ermittelt: $x_{i}=x_{i-1}+\Delta x$ +.\\ +Anmerkung: Der aktuelle Wert von $x_{i}$ hängt von allen vorhergegangenen +Additionen ab. +\item Reeller Schleifenzähler \texttt{x} . Das laufende $x$ wird durch Hochzählen +des Schleifenzählers \texttt{x} um die Intervalllängeermittelt: $x=x+\Delta x$ +.\\ +Anmerkung: Der aktuelle Wert von $x_{i}$ hängt von allen vorhergegangenen +Additionen und von der Darstellungsgenauigkeit von $\Delta x$ ab. +\end{enumerate} +Schreiben Sie ein Programm, in welchem die 3 Schleifen durchlaufen +werden. Der letzte in der Schleife berechnete x-Wert und der dazugehörige +Funktionswert soll jeweils ausgegeben werden (15 Nachkommastellen; +Datentyp \texttt{double}). + +\begin{itemize} +\item Was stellen Sie beim Vergleich der Ausgabewerte fest ? +\end{itemize} + + +%%---------------------------------------------------------------------- +%% ÜBUNG : Verwendung von Feldern +%%---------------------------------------------------------------------- +\chapter{Verwendung von Feldern} +\index{Felder} + +%%---------------------------------------------------------------------- +%% Feld mit Quadratzahlen belegen und ausgeben +%%---------------------------------------------------------------------- +\section{Feld mit Quadratzahlen belegen und ausgeben} + +Geben Sie das Beispielprogramm aus der Vorlesung ein, in welchem ein +\texttt{int}-Feld (100 Elemente) mit den Quadratzahlen $0^{2},1^{2},2^{2},...,99^{2}$ +belegt und der Feldinhalt anschließend ausgegeben wird. Verwenden +Sie in der Ausgabeschleife (Schleifenzähler: i ) die Anweisung + +\begin{verbatim} +if( i%10==0 ) printf("\n"); +\end{verbatim} +um nach jeweils 10 Werten einen Zeilenvorschub zu erzwingen. + + +%%---------------------------------------------------------------------- +%% Feld mit Zufallszahlen zwischen 0 und 50 belegen +%%---------------------------------------------------------------------- +\section[Feld mit Zufallszahlen zwischen 0 und 50 belegen]{Feld mit Zufallszahlen +zwischen 0 und 50 belegen und Mittelwert, +Minimalwert und Maximalwert aller Feldelemente ermitteln} +\index{Mittelwert} +\index{Minimalwert} +\index{Maximalwert} + + +Schreiben Sie ein Programm, in welchem ein \texttt{double}-Feld a +(100 Elemente) mit Zufallszahlen zwischen 0 und 50 (jeweils einschließlich) +belegt wird. Die Funktion \texttt{random()} , \texttt{include}-Datei \texttt{stdlib.h}, +liefert Zufallszahlen im Bereich von 0 bis $2^{31}-1$. Durch die +Bildung des Divisionsrestes mit 51 (Operator \% , modulo-Operator) +können daraus Werte zwischen 0 und 50 erzeugt werden: + +\begin{verbatim} +a[i] = random() % 51; +\end{verbatim} +\begin{itemize} +\item Geben Sie das so belegte Feld mit 10 Werten pro Zeile aus. +\item Bilden Sie das arithmetische Mittel aller Feldelemente und geben Sie +diesen Wert aus. +\item Ermitteln Sie den kleinsten Wert und den größten Wert der Feldelemente +und geben Sie diese beiden Werte aus. +\end{itemize} + +%%---------------------------------------------------------------------- +%% Korrespondierende Felder +%%---------------------------------------------------------------------- +\section{Korrespondierende Felder} +\index{Felder!korrespondierende} + +Schreiben Sie ein Programm, in welchem die \texttt{double}-Felder +\texttt{x}, \texttt{y1} und \texttt{y2} mit jeweils 1000 Elementen +angelegt werden. Die Funktionen $y_{1}(x)=\sin(x)$ und $y_{2}(x)=\cos(x)$ +sind im Bereich von $x = 0 \ldots 6.4$ auszuwerten (\texttt{include}-Datei +\texttt{math.h} ). Dazu wird das Intervall $\lbrack 0,6.4\rbrack$ in 100 Teilintervalle +der Länge $\Delta x=6.4/100$ eingeteilt und die beiden Funktionen +an den 101 Teilungspunkten ausgewertet (s.Aufgabe 2.4). Die $x$-Werte +werden fortlaufen im Feld \texttt{x}, die Funktionswerte entsprechend in den +Feldern \texttt{y1} und \texttt{y2} abgelegt. + +Nachdem die Felder belegt sind, sollen die Werte zeilenweise in der +Form + +\begin{quote} +\begin{verbatim} ++0.000000 +0.000000 +1.000000 + ++0.064000 +0.127651 +0.981625 + ++0.128000 +0.253213 +0.927174 + +. . . +\end{verbatim} +\end{quote} + +ausgegeben werden. Von der Kommandozeile des Betriebssystems aus kann +die Ausgabe des Programmes \texttt{kfeld.e} in die Datei \texttt{kfeld.dat} +umgeleitet werden: + +\begin{quote} +\begin{verbatim} +student@rechner5:/home/student> kfeld.e > kfeld.dat +\end{verbatim} +\end{quote} + +%%---------------------------------------------------------------------- +%% Erzeugung einer Graphik mit Hilfe des Programmes gnuplot +%%---------------------------------------------------------------------- +\section{Erzeugung einer Graphik mit Hilfe des Programmes \texttt{gnuplot}} +\index{gnuplot} + +%%===== FIGURE : begin ========== +\begin{figure}[htbp] +\begin{center} +%\includegraphics[ scale=0.9]{./bilder/schwingung.eps} +\input{./bilder/schwingung.tex} +\caption{ \label{ABB:Schwingungsfigur} Darstellung einer Schwingungsfigur durch das Programm \texttt{gnuplot}} +\vspace{ 5mm} +\end{center} +\end{figure} +%%===== FIGURE : end ========== + +Erstellen Sie nun eine Datei mit dem Namen \textbf{kfeld.plt} in der +folgende Steueranweisungen für das Programm \texttt{gnuplot} enthalten sind: + +\lstset{stepnumber=1} + +\lstinputlisting[caption={Steueranweisungen für das Programm \texttt{gnuplot}},label=gnuplot]{./programme/kfeld.plt} + + + +\begin{onehalfspace} +\begin{center}\begin{tabular}{|c|p{12cm}|} +\hline +\textbf{Zeile} & \textbf{Erklärung}\\ +\hline +\hline + 1 & Diagrammtitel festlegen\\ +\hline + 2 & Gitter erzeugen\\ +\hline + 3 & Legende nicht darstellen\\ +\hline + 4 & Beschriftung der x-Achse\\ +\hline + 5 & Beschriftung der y-Achse\\ +\hline + 6 & Kurvenausgabe: \newline + aus Datei \texttt{kfeld.dat} Spalte 3 über Spalte 2 auftragen; \newline + Punkte durch Linien verbinden\\ +\hline + 7 & Text \verb'"... weiter"' ausgeben und auf beliebigen Tastenanschlag warten\\ +\hline +\end{tabular}\end{center} +\end{onehalfspace} + +Nachdem Sie \texttt{\textbf{kfeld.plt}} abgespeichert haben, +rufen Sie das Program \texttt{gnuplot} mit foldender Komandozeile +in einem shell-Fenster auf: + + +\begin{quote} +\begin{verbatim} +student@rechner5:/home/student>gnuplot kfeld.plt +\end{verbatim} +\end{quote} + +Danach erscheint die graphische Ausgabe in einem neuen Fenster. Die +Ausgabe wird beendet, wenn der Mauszeiger über dem shell-Fenster steht +und die Eingabetaste gedrückt wird. + +Berechnen Sie nun + +\begin{align*} +y_{1}(x) & =\sin(x) & y_{1}(x) & =\sin(x) & y_{1}(x) & = \sin(2x) \\ +y_{2}(x) & =\cos(x) & y_{2}(x) & =\cos(3x) & y_{2}(x) & = \cos(3x) +\end{align*} + +Weitere Berechnungen mit graphischer Ausgabe : + +\begin{align*} +y_{1}(x) & =\sin(x) & y_{1}(x) & =x\cdot\sin(x) \\ +y_{2}(x) & =\cos(x) & y_{2}(x) & =x\cdot\cos(3x) +\end{align*} + +Um die Funktion $y_1(x)$ über $x$ aufzutragen muß die Zeile 6 in der Datei \texttt{\textbf{kfeld.plt}} +wie folgt aussehen: + +\begin{quote} +\begin{verbatim} +plot "kfeld.dat" using 1:2 with lines +\end{verbatim} +\end{quote} + +Für die Darstellung von $y_2(x)$ über $x$ lautet diese Zeile + +\begin{quote} +\begin{verbatim} +plot "kfeld.dat" using 1:3 with lines +\end{verbatim} +\end{quote} + + +%%---------------------------------------------------------------------- +%% ÜBUNG : Umgang mit Texten +%%---------------------------------------------------------------------- +\chapter{Umgang mit Texten} + + +%%---------------------------------------------------------------------- +%% Buchstaben und Ziffern in einem Text abzählen +%%---------------------------------------------------------------------- +\section{Buchstaben und Ziffern in einem Text abzählen} +\index{Buchstaben!abzählen} +\index{Ziffern!abzählen} + + +%%---------------------------------------------------------------------- +%% Zustandsdiagramme +%%---------------------------------------------------------------------- +\begin{figure}[h] +\subfigure[Wörter zählen] +{ +\begin{picture}(80,80) +\gasset{Nadjust=w,Nadjustdist=2} +\node[fillcolor=Yellow,linewidth=.4](L)( 40, 40){ZWISCHENRAUM} +\node[fillcolor=Yellow,linewidth=.4](W)( 40, 20){WORT} +\imark[iangle=180](L) +\drawedge[curvedepth=10](L,W){Buchstabe} +\drawedge[curvedepth=10](W,L){Leerzeichen} +\drawloop[loopangle= 0](L){Leerzeichen} +\drawloop[loopangle=270](W){Buchstabe} +\end{picture} +} +\subfigure[Wörter und Zahlen zählen] +{ +\begin{picture}(80,80) +\gasset{Nadjust=w,Nadjustdist=2} +\node[fillcolor=Yellow,linewidth=.4](Z)(40, 60){ZAHL} +\node[fillcolor=Yellow,linewidth=.4](L)(40, 40){ZWISCHENRAUM} +\node[fillcolor=Yellow,linewidth=.4](W)(40, 20){WORT} +\imark[iangle=180](L) +\drawedge[curvedepth=10](Z,L){Leerzeichen} +\drawedge[curvedepth=10](L,Z){Ziffer} +\drawedge[curvedepth=10](L,W){Buchstabe} +\drawedge[curvedepth=10](W,L){Leerzeichen} +\drawloop[loopangle= 0](L){Leerzeichen} +\drawloop[loopangle=270](W){Buchstabe} +\drawloop[loopangle= 90](Z){Ziffer} +\end{picture} +} +\caption{\label{cap:Zustandsdiagramme}Zustandsdiagramme\index{Zustanddiagramm} zur Wort- und Zahlenerkennung } +\end{figure} + + + +\begin{itemize} +\item Geben Sie das Beispielprogramm \texttt{string1.c} aus der Vorlesung ein, in +welchem ein Text eingelesen, ausgegeben und die Anzahl der Klein- +und Großbuchstaben ermittelt wird. Überprüfen Sie dessen Funktionsweise ! +\item Erweiteren Sie das Programm so, daß auch Ziffern abgezählt werden +können (Testfunktion: \texttt{isdigit()} ). +\item Ändern Sie das Programm nun so, daß die Unterscheidung zwischen Klein- +und Großbuchstaben entfällt und nur Buchstaben (Testfunktion: \texttt{isalpha()} +) und Ziffern abgezählt werden. +\end{itemize} + +%%---------------------------------------------------------------------- +%% Wörter in einem Text abzählen +%%---------------------------------------------------------------------- +\section{Wörter in einem Text abzählen} + +Das unter 4.1 entwickelte Programm soll nun so abgeändert werden, +daß die Wörter im Eingabetext abgezählt und deren Anzahl ausgegeben +werden. + +Die Analyse kann wie folgt durchgeführt werden: Das augenblicklich +betrachtete Zeichen gehört entweder zu einem Wort oder zu einem Zwischenraum +(Folge von Leerzeichen und/oder Tabulatoren). +Jeder der beiden Zustände wird in einer Zustandsvariablen \texttt{zustand} \index{Zustandsvariablen} +codiert, z.B. ZWISCHENRAUM: \texttt{zustand=0}, WORT: \texttt{zustand=1}. +In jedem Schritt (d.h. beim jeweils nächsten zu betrachtenden Zeichen) wird überprüft, +ob eine Zustandsänderung stattfindet (siehe Abb. \ref{cap:Zustandsdiagramme}). +Beim Zustandsübergang ZWISCHENRAUM $\rightarrow$ WORT wird der Wortzähler erhöht. + +Zur Klassifizierung der einzelnen Zeichen können die C-Klassifizierungsfunktionen +verwendet werden, die in der \texttt{h}-Datei \texttt{ctype.h} definiert sind +(s.a. Abb \ref{cap:Hierarchie-der-Zeichenklassen}). + + +%%---------------------------------------------------------------------- +%% Wörter und Zahlen in einem Text abzählen +%%---------------------------------------------------------------------- +\section{Wörter und Zahlen in einem Text abzählen} + +Das unter 4.2 entwickelte Programm soll nun so abgeändert werden, +daß zusätzlich Zahlen im Eingabetext erkannt, abgezählt und auch deren +Anzahl ausgegeben wird. +Dazu ist gemäß Abbildung \ref{cap:Zustandsdiagramme}b ein weiterer Zustand +ZAHL einzufügen und die zusätzlichen Übergänge zu implementieren. + +Erweitern Sie das Programm indem Sie prüfen, ob in einer Buchstabenfolge +eine Ziffer oder in einer Ziffernfolge ein Buchstabe auftritt. +In diesem Fall soll das Programm eine Fehlermeldung ausgeben und über den Funktionsaufruf +\texttt{exit(1)} verlassen werden. +Erstellen Sie nun in einem Editor eine Textdatei \texttt{text.txt}, +die eine größere Anzahl von Wörtern und Zahlen in einer einzigen Zeile enthält (höchstens 120 Zeichen). + +Führen Sie nun Ihr Programm von der Kommandozeile aus: + +\begin{quote} +\begin{verbatim} +.../home/student>prakt-4-3.e < text.txt +\end{verbatim} +\end{quote} + +Überprüfen Sie das Ergebnis ! + +Prüfen Sie nun Ihre Textdatei mit dem UNIX-Systemprogramm\index{UNIX!wc} +\texttt{wc}\index{wc} (steht für word count): + +\begin{quote} +\begin{verbatim} +.../home/student>wc -w < text.txt +\end{verbatim} +\end{quote} + +Die ausgegebene Zahl muß der Summe der Wörter und Zahlen in der Ausgabe +des eigenen Programmes entsprechen. + +\begin{figure}[h] +\begin{center}\includegraphics{./bilder/zeichenklassen}\end{center} +\caption{\label{cap:Hierarchie-der-Zeichenklassen}Hierarchie der Zeichenklassen\index{Zeichenklassen} +und der Klassifizierungsfunktionen in C (\texttt{h}-Datei \texttt{ctype.h})} +\end{figure} + + +%%---------------------------------------------------------------------- +%% ÜBUNG : Codieren und Decodieren von Texten +%%---------------------------------------------------------------------- +\chapter{Codieren und Decodieren von Texten} +\index{codieren} +\index{decodieren} +\index{Text!codieren, decodieren} + + +%%---------------------------------------------------------------------- +%% Inhalt eines Feldes um n Positionen nach links oder rechts rotieren +%%---------------------------------------------------------------------- +\section{\label{sec:Codieren-1}Inhalt eines Feldes um n Positionen nach links +oder rechts rotieren} + +Legen Sie ein Feld \texttt{ascii} vom Typ \texttt{int} mit n=128 Elementen an, +füllen Sie das Feld mit der Zahlenfolge 0, 1, 2, 3, ... , 127 ( = jeweiliger Feldindex) +und geben Sie das Feld in Zeilen zu 16 Elementen aus. + +Lesen Sie eine ganze Zahl $r$ ein die angibt, um wieviele Plätze der +Feldinhalt zyklisch nach links (negative Zahl) oder nach rechts (positive +Zahl) verschoben werden soll. Das folgende Beispiel zeigt eine Verschiebung +um $r = 2$ nach links: + +% +\begin{figure}[h] +\begin{center}\includegraphics{./bilder/feld-rotieren-1}\end{center} +\caption{\label{cap:Feldinhalt-um-2}Feldinhalt um 2 Positionen nach links +verschieben} +\end{figure} + + +%%---------------------------------------------------------------------- +%% Einen Teilbereich eines Feldes um n Positionen nach links oder rechts rotieren +%%---------------------------------------------------------------------- +\section{\label{sec:Codieren-2}Einen Teilbereich eines Feldes um n Positionen +nach links oder rechts rotieren} + +Ändern Sie das Programm aus der Aufgabe \ref{sec:Codieren-1} so ab, +daß zusätzlich die Anfangsposition $p_1$ und Endposition $p_2$ eines Bereiches +des Feldes eingelesen wird. Nur die Feldelemente innerhalb dieses +Bereiches sollen rotiert werden. + +Überprüfen Sie, ob vor der Verschiebung die folgenden Bedingungen +erfüllt sind: + +\begin{align*} +0 \leq p_1 && p_1 < p_2 && p_2 < 128 +\end{align*} + +Geben Sie das rotierte Feld mit derselben Formatierung wie das Originalfeld +aus und überprüfen Sie das Ergebnis mit verschiedenen Links- und Rechtsverschiebungen. + + +%%---------------------------------------------------------------------- +%% Text chiffrieren +%%---------------------------------------------------------------------- +\section{\label{sec:Codieren-3}Text chiffrieren} +\index{chiffrieren} + +Verwenden Sie das Programm aus Aufgabe \ref{sec:Codieren-2} und rotieren +Sie das \texttt{int}-Feld zwischen $p_1 = 32$ und $p_2 = 126$ (=alle Nichtsteuerzeichen +des ASCII-Codes) um $r = -5$ Positionen (nach links). + +Lesen Sie zeichenweise eine Datei \texttt{klar.txt} in einen Textpuffer\texttt{text} +ein (s. Beispiel \texttt{string.c} aus der Vorlesung). Die Datei \texttt{klar.txt} soll +einen einzeiligen Klartext enthalten. + +Die Feldelemente des Textpuffers enthalten die eingelesenen Zeichen +in ASCII-Codierung. Diese liegt jeweils zwischen den Werten 0 und +127. Diese Werte können nun mit Hilfe des eingangs erzeugten Feldes +in einfacher Weise chiffriert werden. + +Die Werte der Zeichen im Textpuffer \texttt{text} werden als Index des teilweise +rotierten Feldes \texttt{ascii} zur Adressierung des Zielzeichens verwendet: + +\begin{quote} +\begin{verbatim} +putchar( ascii[ text[i] ] ); +\end{verbatim} +\end{quote} + +Wegen der Rotation der Nichtsteuerzeichen um 5 Positionen wird der +Buchstabe A auf F, die Ziffer 1 auf 6 usw. abgebildet. Die Steuerzeichen +(falls vorhanden) werden durch sich selbst codiert, d.h. nicht verändert. + +Das Feld vor der Rotation: Der Feldindex entspricht dem ASCII-Wert +des Inhalts, der hier in lesbarer Form dargestellt ist (Abb. \ref{cap:Zeichenfeld-als-Hilfsmittel}, +oben). + +% +\begin{figure}[h] +\begin{center}\includegraphics{./bilder/feld-rotieren-2}\end{center} + + +\caption{\label{cap:Zeichenfeld-als-Hilfsmittel}Zeichenfeld als Hilfsmittel +zur Textchiffrierung} +\end{figure} + + +Das Feld nach der Rotation: Wird das Feld mit dem Wert des Buchstabens +B (=66) adressiert, wird nun der Inhalt 71 ausgelesen (entspricht +dem ASCII-Wert von G), d.h. B wird durch G codiert (Abb. \ref{cap:Zeichenfeld-als-Hilfsmittel}, +unten). + + +%%---------------------------------------------------------------------- +%% Text dechiffrieren +%%---------------------------------------------------------------------- +\section{Text dechiffrieren} +\index{dechiffrieren} + +Kopieren Sie das Programm aus Aufgabe \ref{sec:Codieren-3} und rotieren +Sie das \texttt{int}-Feld zwischen $p_1 = 32$ und $p_2 = 126$ (=alle Nichtsteuerzeichen +des ASCII-Codes) um $r = +5$ Positionen (nach rechts). + +Führen Sie nun Ihr Programm von der Kommandozeile aus: + +\begin{quote} +\begin{verbatim} +.../home/student>prakt-5-4.e < geheim.tx > klar1.txt +\end{verbatim} +\end{quote} + +Bei richtiger Arbeitsweise beider Programme muß der Inhalt der Dateien +\texttt{klar.txt} und \texttt{klar1.txt} übereinstimmen. + + +%%---------------------------------------------------------------------- +%% ÜBUNG : Einfache statistische Kennwerte +%%---------------------------------------------------------------------- +\chapter{Einfache statistische Kennwerte} +\index{Kennwerte!statistische} + +%%---------------------------------------------------------------------- +%% Statistische Kennwerte +%%---------------------------------------------------------------------- +\section{Statistische Kennwerte} + +Folgende Kennwerte einer Zahlenfolge $x_{1},...,x_{n}$ sind zu berechnen: + +%%+++++ TABLE : begin ++++++++++ + +\begin{onehalfspace} + +\begin{tabular}{|c|p{12cm}|} +\hline +\textbf{Kennwert} & \textbf{Berechnungsvorschrift}\\ +\hline +\hline +Minimum\index{Minimum}& +kleinster Wert der Zahlenfolge\\ +\hline +Maximum\index{Maximum}& +größter Wert der Zahlenfolge\\ +\hline +Spanne\index{Spanne}& +(Maximum - Minimum)\\ +\hline +Arithmetischer Mittelwert\index{Mittelwert!arithmetischer}& +$$am=\sum _{i=1}^{n}x_{i}$$ +\\ +\hline +Geometrischer Mittelwert\index{Mittelwert!geometrischer}& +$$gm=\sqrt[n]{x_{1}x_{2}\cdots x_{n}}$$ +Zur Berechnung siehe Abschnitt \ref{SEC:GeoMittel}. +\\ +\hline +Quadratischer Mittelwert\index{Mittelwert!quadratischer}& +$$qm=\sqrt{\frac{1}{n}\sum _{i=1}^{n}x_{i}^{2}}$$ +\\ +\hline +Mittlere Abweichung\index{Abweichung}& +$$ma=\frac{1}{n}\sum _{i=1}^{n}\Vert x_{i}-am\Vert $$ +\\ +\hline +Median\index{Median}& +Der Median einer Menge von Zahlen, die \textit{der Größe nach sortiert} sind, +ist bei ungerader Anzahl der Wert in der Mitte, bei gerader Anzahl das arithmetische Mittel +der beiden Werte in der Mitte. +Zur Sortierung s. Abschnitt \ref{SEC:Sortieren}. \\ +\hline +\end{tabular} + +\end{onehalfspace} +%%+++++ TABLE : end ++++++++++ + +Bei der Programmerstellung ist folgendermaßen vorzugehen: + +\begin{itemize} +\item Verwenden Sie zur Berechnung der Kennwerte jeweils eine eigene Funktion. +\item Es sollen 200 \texttt{double}-Werte berücksichtigt werden, die mit Hilfe des +Zufallsgenerators \texttt{\textbf{rand()}} (Prototyp in \texttt{stdlib.h}) +erzeugt werden können (Wertebereich 0 bis 100; eine Nachkommastelle, +die ungleich Null sein kann). +\item Schreiben Sie eine C-Funktion, die die Zahlenreihe in Zeilen zu 10 +Werten auf den Bildschirm ausgibt. +\item Zur Berechnung des geometrischen Mittels soll der natürliche Logarithmus +verwendet werden ( s. Abschnitt \ref{SEC:GeoMittel}; Funktionen: \texttt{\textbf{log(), exp()}}, +Prototypen in \texttt{math.h} ). +Die Übergabe eines eindimensionalen Feldes an eine Funktion geschieht wie folgt: +\end{itemize} + + +\begin{quote} +\begin{verbatim} +double am ( double x[ ], int n ) +{ +} +\end{verbatim} +\end{quote} + +%%---------------------------------------------------------------------- +%% Sortieren durch Vertauschen +%%---------------------------------------------------------------------- +\section{\label{SEC:Sortieren}Sortieren durch Vertauschen} +\index{Sortieren durch Vertauschen} + +\begin{floatingfigure}[r]{85mm} + +\includegraphics[ ]{./bilder/sortieren-vertauschen.eps} + +\caption{ Sortieren durch Vertauschen } + +\end{floatingfigure} + +\textbf{Vorgehensweise} Das erste und das zweite Element der vorgelegten +Liste werden verglichen. Ist das erste größer als das zweite, so werden +die beiden vertauscht. Der gleiche Vorgang wird auf das (nunmehr) +zweite und dritte Element der Liste angewandt, dann auf das (nunmehr) +dritte und vierte. Dies wird bis zum Vergleich des (n-1)-ten mit dem +n-ten Element fortgesetzt. Nach (n-1) Vergleichen befindet sich das +größte Element am Ende der Liste. + +Nach dem gleichen Verfahren wird nun in der um eine Position verkürzten +Liste das zweitgrößte Element auf die vorletzte Position gebracht. +Dies wird fortgesetzt an einer immer kürzer werdenden Restliste bis +diese schließlich nur noch aus einem Element besteht. + +\textbf{Aufwand} Der Sortieraufwand\index{Sortieraufwand} A ergibt +sich durch das Aufsummieren der in den einzelnen Durchläufen anfallenden +Vergleichsschritte: + +\[ +A=\sum _{i=1}^{n-1}\left(n-i\right)=\frac{n(n-1)}{2}\approx \frac{n^{2}}{2}\] + + +\textbf{Vorteil} Das Verfahren hat den Vorteil, daß es keinerlei zusätzlichen +Speicher benötigt. Der Sortiervorgang läuft innerhalb der vorgelegten +Originalliste ab. + +\textbf{Nachteil} Ein schwerwiegender Nachteil ist die Zunahme des +Aufwandes mit dem Quadrat der Listenlänge $n$. Das Verfahren ist daher +nur für kurze, selten zu sortierende Listen geeignet. + +%%---------------------------------------------------------------------- +%% Berechnung des geometrischen Mittelwertes +%%---------------------------------------------------------------------- +\section{\label{SEC:GeoMittel}Berechnung des geometrischen Mittelwertes} +\index{Mittelwert!geometrischer} + +Durch Logarithmieren der Gleichung +$$gm=\sqrt[n]{x_{1}x_{2}\cdots x_{n}}$$ +mit dem natürlichen Logarithmus $\ln$ (Basis $e$) erhält man +\index{Logarithmus!natürlicher} + +\begin{eqnarray*} +GM= \ln{gm} &=& \ln{\sqrt[n]{x_{1}x_{2}\cdots x_{n}}} \\ +&=& \frac{1}{n}(\ln{x_1}+\ln{x_2}+\ldots+\ln{x_n}) \\ +&=& \frac{1}{n}\sum_{i=1}^{n}\ln{x_i} +\end{eqnarray*} + +d.h. man berechnet zunächst den Logarithmus von $gm$ als arithmetisches Mittel der +Summe der Logarithmen der Größen $x_i$. +Man erhält nun das gesuchte Ergebnis $gm$ durch Potenzierung: +$$gm=e^{GM}=e^{\ln{gm}}$$ + + +%%---------------------------------------------------------------------- +%% ÜBUNG : Vollständige Lösung einer quadratischen Gleichung +%%---------------------------------------------------------------------- +\chapter{Vollständige Lösung einer quadratischen Gleichung} +\index{Gleichung!quadratische} +\index{quadratische Gleichung} + +%%---------------------------------------------------------------------- +%% Lösung einer quadratischen Gleichung +%%---------------------------------------------------------------------- +\section{Lösung einer quadratischen Gleichung} + +Für die allgemeine quadratische Gleichung $ax^{2}+bx+c=0$ wird üblicherweise +die Lösungsformel + +\begin{equation} +x_{1,2}=\frac{1}{2}\left[-b\pm \sqrt{b^{2}-4ac}\right]\label{eq:Lsg-Quadr-Gleichung} +\end{equation} + + +angegeben. Eine durch ein Programm automatisch zu bestimmende Lösung +muß in der Regel \textit{logisch vollständig} entwickelt und programmiert werden. +Jeder der Koeffizienten $a$, $b$ und $c$ kann gleich Null oder ungleich +Null sein. Hierdurch ergeben sich bereits $2^{3}=8$ Fälle. Durch +Betrachtung der Vorzeichen der Ausdrücke, die bei einzelnen Fällen +unter einer Wurzel stehen, ergeben sich dann insgesamt 10 Fälle. Diese +10 Fälle sind in der folgenden Tabelle wiedergegeben. Es gilt mit +den Hilfsgrößen: + +\begin{align*} u=-c/a && v=b^{2}-4ac && i=\sqrt{-1} \end{align*} + +\begin{doublespace} +\begin{center}\begin{tabular}{|c|r|r|r|r|r|l|} +\hline +Fall& +a& +b& +c& +u& +v& +Berechnungsvorschrift\\ +\hline +\hline +0& +$=0$& +$=0$& +$=0$& +& +& +triviale Gleichung\\ +\hline +1& +$=0$& +$=0$& +$\neq 0$& +& +& +Widerspruch\\ +\hline +2& +$=0$& +$\neq 0$& +$=0$& +& +& +$x_{1}=0$\\ +\hline +3& +$=0$& +$\neq 0$& +$\neq 0$& +& +& +$x_{2}=-c/b$\\ +\hline +4& +$\neq 0$& +$=0$& +$=0$& +& +& +$x_{1}=x_{2}=0$\\ +\hline +5.1& +$\neq 0$& +$=0$& +$\neq 0$& +$\geq 0$& +& +$x_{1,2}=\pm \sqrt{u}$\\ +\hline +5.2& +$\neq 0$& +$=0$& +$\neq 0$& +$<0$& +& +$x_{1,2}=\pm i\sqrt{-u}$\\ +\hline +6& +$\neq 0$& +$\neq 0$& +$=0$& +& +& +$x_{1}=0,x_{2}=-b/a$\\ +\hline +7.1& +$\neq 0$& +$\neq 0$& +$\neq 0$& +& +$\geq 0$& +$x_{1,2}=\frac{1}{2a}\left[-b\pm \sqrt{v}\right]$\\ +\hline +7.2& +$\neq 0$& +$\neq 0$& +$\neq 0$& +& +$<0$& +$x_{1,2}=\frac{1}{2a}\left[-b\pm i\sqrt{-v}\right]$\\ +\hline +\end{tabular}\end{center} +\end{doublespace} + +Entwickeln Sie ein Programm, in welchem zunächst die Koeffizienten +$a$, $b$ und $c$ eingelesen werden. Anschließend wird mit Hilfe einer vollständigen +Fallunterscheidung der zutreffende Fall ermittelt und gelöst. Die +gewonnene Lösung soll ausgegeben und durch eine anschließende Kontrollrechnung +(Einsetzen von $x_{1}$ und $x_{2}$ in die Ausgangsgleichung) automatisch +überprüft werden. + + +%%---------------------------------------------------------------------- +%% Kontrollrechnung für Fall 5.2 +%%---------------------------------------------------------------------- +\section{Kontrollrechnung für Fall 5.2} + +Für die konjugiert komplexen Lösungen $x_{1}$ und $x_{2}$ erhält +man zunächst: + +\begin{eqnarray*} +x_{1.2} & = & \pm s\cdot i\\ +x_{1,2}^{2} & = & -s^{2} +\end{eqnarray*} + + +Durch Einsetzen in die Ausgangsgleichung (b = 0) erhält man nun + +\begin{eqnarray*} +a\cdot (-s^{2})+c & = & 0 +\end{eqnarray*} + + +Der Absolutwert der linken Seite muß kleiner sein als eine positive +Schranke $\varepsilon $ (s.u.). + + +%%---------------------------------------------------------------------- +%% Bestimmung der komplexen Lösungen für den Fall 7.2 +%%---------------------------------------------------------------------- +\section{Bestimmung der komplexen Lösungen für den Fall 7.2} + +\[ +x_{1,2}=\frac{1}{2a}\left[-b\pm i\sqrt{-v}\right]=\left(\frac{-b}{2a}\right)\pm \left(\frac{\sqrt{-v}}{2a}\right)\cdot i=r\pm s\cdot i\] + + +Die Ausdrücke in den runden Klammern sind reell und müssen getrennt +berechnet werden (z.B. in den Variablen \texttt{r} und \texttt{s}). Bei der Druckausgabe +wird die imaginäre Einheit $i$ als Text ausgegeben: + +\begin{verbatim} +printf("x1 = %.3f %+.3f*i", r, +s ); + +printf("x2 = %.3f %+.3f*i", r, -s ); +\end{verbatim} + +%%---------------------------------------------------------------------- +%% Kontrollrechnung für Fall 7.2 +%%---------------------------------------------------------------------- +\section{Kontrollrechnung für Fall 7.2} + +Für die konjugiert komplexen Lösungen $x_{1}$ und $x_{2}$ erhält +man zunächst: + +\begin{eqnarray*} +x_{1,2} & = & r\pm s\cdot i\\ +x_{1,2}^{2} & = & \left(r\pm s\cdot i\right)^{2}=\left(r^{2}-s^{2}\right)\pm \left(2rs\right)\cdot i +\end{eqnarray*} + + +Durch Einsetzen in die Ausgangsgleichung erhält man nun + +\begin{eqnarray*} +a\left[\left(r^{2}-s^{2}\right)\pm \left(2rs\right)\cdot i\right] \quad + \quad b\left[r\pm s\cdot i\right] & = & 0 \\ +\left[a\left(r^{2}-s^{2}\right)+br+c\right] \quad \pm\quad \left[a(2rs)+bs\right]\cdot i & = & 0 +\end{eqnarray*} + + +Die Ausdrücke in den eckigen Klammern müssen beide Null sein um die Gleichung zu erfüllen. +Wegen der bekannten Eigenschaften der Gleitkommarechnung kann nicht direkt mit Null verglichen werden. +Der Absolutwert des jeweiligen Ausdruckes muß kleiner sein als eine positive Schranke +$\varepsilon $ (z.B. $\varepsilon =10^{-10}$). + + +%%---------------------------------------------------------------------- +%% ÜBUNG : Rekursion +%%---------------------------------------------------------------------- +\chapter{Rekursion} + + +%%---------------------------------------------------------------------- +%% Berechnung der Fakultät einer natürlichen Zahl +%%---------------------------------------------------------------------- +\section{Berechnung der Fakultät einer natürlichen Zahl} +\index{Fakultät} + +%%===== FIGURE (floating) : begin ========== +\begin{floatingfigure}[r]{70mm} +\begin{center} +\includegraphics[ ]{./bilder/rekurs-fakul.eps} +\caption{ \label{Ablaufdiagramm-Fakultät} Ablaufdiagramm zur Berechnung der Fakultät } +\vspace{ 5mm} +\end{center} +\end{floatingfigure} +%%===== FIGURE (floating): end ========== + + +Der Ausdruck $n!$ ist definiert als + +$$n!\quad = \quad n\cdot (n-1)\cdot (n-2)\ldots 2\cdot 1\quad = \quad n\cdot (n-1)!$$ + +Daraus ergibt sich die Möglichkeit, eine Funktion \texttt{fakul()} zur Berechnung +der Fakultät rekursiv zu schreiben. Das vereinfachte Ablaufdiagramm +ist in Abb. \ref{Ablaufdiagramm-Fakultät} wiedergegeben. + +Schreiben Sie ein Hauptprogramm, in welchem eine rekursive Funktion + +\texttt{ long fakul ( long n )} + +aufgerufen wird um eine Tabelle der Fakultäten der Zahlen von 1 bis 20 zu berechnen. +Stellen Sie fest, bis zu welchem $n$ die berechnete Fakultät richtig ist. + + +%%---------------------------------------------------------------------- +%% Berechnung der Fibonacci-Zahlen +%%---------------------------------------------------------------------- +\section{Berechnung der Fibonacci-Zahlen} +\index{Fibonacci-Zahlen} + +Die Fibonacci-Zahlen $f_{i}$ sind wie folgt rekursiv definiert: + +\begin{align} +f_{1}=1 && f_{2}=1 && f_{n}=f_{n-1}+f_{n-2};\quad n\geq 3 \label{eq:fibinacci-Zahlen} +\end{align} + +Schreiben Sie ein Hauptprogramm, in welchem eine rekursive Funktion + +\begin{quote} +\begin{verbatim} +int finonacci ( int n ) +\end{verbatim} +\end{quote} + +aufgerufen wird um die Fibonacci-Zahlen $f_1$ bis $f_{20}$ zu berechnen und in einer Tabelle auszugeben. +Verwenden Sie eine globale Variable um die jeweils erforderliche Anzahl der Funktionsaufrufe festzustellen. +Geben Sie die Anzahl der Funktionsaufrufe ebenfalls in der Tabelle aus. +Ermitteln Sie die Abhängigkeit zwischen der Fibonacci-Zahl und +der Anzahl der zur Berechnung erforderlichen Funktionsaufrufe. + + +%%---------------------------------------------------------------------- +%% Erzeugung von Permutationen +%%---------------------------------------------------------------------- +\section{Erzeugung von Permutationen} +\index{Permutation} + +%%+++++ TABLE (floating) : begin ++++++++++ +\begin{floatingtable}[r]{ +\begin{tabular}{p{10mm} p{11mm} p{11mm} p{11mm}} + & 1& 2& 3\\ + & 1& 3& 2\\ + & 2& 1& 3\\ + & 2& 3& 1\\ + & 3& 2& 1\\ + & 3& 1& 2\\ +\end{tabular}} +\caption{ \label{cap:Permutationen-von-3} Permutationen von 3 Zahlen } +\vspace{ 15mm} +\end{floatingtable} +%%+++++ TABLE (floating): end ++++++++++ + +Eine Permutation entsteht durch die Umordnung einer Objekt- oder Zahlenreihe. +Eine Aufgabenstellung aus der Kombinatorik ist die systematische Erzeugung +aller $n!$ Anordnungen einer Menge von $n$ Zahlen. Die Menge $(1,2,3)$ +besitzt $3! = 6$ Permutationen (s. Tab. \ref{cap:Permutationen-von-3}). + +Eine Möglichkeit zur Erzeugung von Permutationen kann rekursiv programmiert werden. +Ein Feld \texttt{a[ ]} ist anfänglich z.B. fortlaufend mit den Werten 0, 1, 2, ... 7 belegt +und wird wie folgt permutiert: + +Die Permutation der Stufe 0 entsteht durch Eintauschen des Wertes +des 1. Feldplatzes mit allen anderen Feldplätzen (8 Möglichkeiten). +Die 1. Stufe berücksichtigt nur noch die Feldplätze 2 bis $n$ (Abb. +\ref{cap:Erzeugung-von-Permutationen}a ), usw. + +Die Ordnung $n$ der Permutaionen wird in einer globalen Variablen \texttt{n} abgelegt. +Die Funktion \texttt{void perm ( int k )} kann so geschrieben +werden, daß bei einem Startaufruf mit \texttt{perm (0)} gemäß Ablauf +in Abb. \ref{cap:Erzeugung-von-Permutationen}b die Permutationen +für 0, 1, 2, 3, .. der Reihe nach erzeugt werden. +Erst bei Erreichen der Stufe $n-1$ wird die jeweilige Permutation +(Inhalt des Feldes \texttt{a[ ]} ) ausgegeben. + +\begin{figure}[h] +\begin{center} +\subfigure[Symmetrisches Tauschen]{\includegraphics[ scale=0.8]{./bilder/permutation}} +\subfigure[Vereinfachtes Ablaufdiagramm]{\includegraphics[ scale=0.8]{./bilder/rekurs-perm}} +\end{center} +\caption{Erzeugung von Permutationen\label{cap:Erzeugung-von-Permutationen}} +\end{figure} + +Die Korrektheit der Ergebnisse kann nur für kleine $n$ (z.B. $n = 2, 3 \ldots$ ) +direkt überprüft werden. +Für größere $n$ kann die Programmausgabe in eine Datei umgeleitet werden +(z.B. für: $n = 8$; $8! = 40320$ ) : + +\begin{quote} +\begin{verbatim} +permutation.e > perm8.dat +\end{verbatim} +\end{quote} + +Wenn eine Zeile pro Permutation erzeugt wurde (hier 40320 Zeilen), +kann mit dem Kommando + +\begin{quote} +\begin{verbatim} +wc -l perm8.dat +\end{verbatim} +\end{quote} + +die Anzahl der Zeilen der Datei \texttt{perm8.dat} festgestellt werden +(\texttt{wc} ist ein UNIX-Kommando zur Wortzählung, die Option \texttt{-l} erzwingt jedoch +die Zeilenzählung). Um festzustellen, ob alle Permutaionen voneinander +verschieden sind, kann der Dateiinhalt sortiert werden: + +\begin{quote} +\begin{verbatim} +sort -u < perm8.dat > perm8sort.dat +\end{verbatim} +\end{quote} + +\texttt{sort} \index{sort} \index{UNIX!sort}ist das UNIX-Sortierkommando, +die Option \texttt{-u} erzwingt, daß mehrfach vorhandene Datensätze nur einmal +gezählt werden. Weicht die Satzanzahl von \texttt{perm8.dat} und \texttt{perm8sort.dat} +voneinander ab, dann ist die Erzeugung noch fehlerhaft. + + +%%---------------------------------------------------------------------- +%% ÜBUNG : Zweidimensionale Felder - Bildverarbeitung +%%---------------------------------------------------------------------- +\chapter{Zweidimensionale Felder - Bildverarbeitung} +\index{Bildverarbeitung} + +%%---------------------------------------------------------------------- +%% Bilddatei lesen und speichern +%%---------------------------------------------------------------------- +\section{Bilddatei lesen und speichern} + +In der Datei \texttt{grau1.pgm} ist ein Grauwertbild\index{Grauwertbild} +(Abb. \ref{cap:Grauwertbild}) wie folgt abgespeichert (s. Listing +\ref{pgm-Datei} und Tab. \ref{cap:Aufbau-einer-pgm-Datei}): + +\lstset{language=C} +\lstset{stepnumber=5} +\lstinputlisting[lastline=24,caption={Beginn der pgm-Datei \texttt{grau1.pgm}},label=pgm-Datei]{./bilder/grau1.pgm} + + +\begin{table}[h] +\begin{onehalfspace} +\begin{center}\begin{tabular}{|c|c|l|} +\hline +\textbf{Zeile}& \textbf{Inhalt}& \textbf{Bedeutung}\\ +\hline +\hline + 1 & P2 & Codierung des Dateityps, hier pgm\\ +\hline + 2 & 256 256 & Bildbreite und -höhe in Pixel\\ +\hline + 3 & 255 & maximaler Grauwert (0 = schwarz , 255 = weiß)\\ +\hline + 4 bis Dateiende& & Grauwerte der einzelnen Bildpunkte; zeilenweise fortlaufend abgelegt\\ +\hline +\end{tabular}\end{center} + +\caption{Aufbau einer pgm-Datei\label{cap:Aufbau-einer-pgm-Datei}} +\end{onehalfspace} +\end{table} + +\begin{figure}[h] +\begin{center} +\includegraphics[scale=.5]{./bilder/grau1.eps} +\end{center} +\caption{Grauwertbild in der Datei \texttt{grau1.pgm}\label{cap:Grauwertbild}} +\end{figure} + + +Schreiben Sie ein Programm in welches die Datei \texttt{grau1.pgm} eingelesen wird. +Die Bildinformationen (Zeile 1-3) sollen zur Kontrolle ausgegeben werden. +Das Bild wird in einem hinreichend großen globalen Feld vom Typ \texttt{unsigned char} +zeilenweise eingelesen. +Anschließend ist das Bild im selben Dateiformat in eine Datei \texttt{grau2.pgm} zu speichern. +Das abgespeicherte Bild kann mit den Programmen \texttt{xv\index{xv}} oder \texttt{kview\index{kview}} +(Bildbetrachtung und -bearbeitung) dargestellt werden: + +\begin{quote} +\begin{verbatim} +xv grau1.pgm +\end{verbatim} +\end{quote} + +Programm \texttt{xv}: Bei Betätigung der rechten Maustaste erscheint ein Dialogfenster. +Wenn der Mauszeiger über dem Bild steht, reicht die Eingabe des Buchstabens +q um das Programm zu beenden. + + +%%---------------------------------------------------------------------- +%% Grauwertbild bearbeiten +%%---------------------------------------------------------------------- +\section{Grauwertbild bearbeiten} + + +%%===== FIGURE (floating) : begin ========== +\begin{floatingfigure}[r]{80mm} +\begin{center} +\includegraphics[ ]{./bilder/bildbearbeitung-menu.eps} +\caption{Menu 'Bildbearbeitung'\label{cap:Menu-Bildbearbeitung}} +\vspace{ 5mm} +\end{center} +\end{floatingfigure} +%%===== FIGURE (floating): end ========== + +Im zweiten Schritt soll durch die Anwendung von Bearbeitungsschritten aus +dem Originalbild ein Ergebnisbild erzeugt werden. + +Legen Sie zunächst ein weiteres Feld zur Aufnahme des bearbeiteten Bildes an, +kopieren Sie das eingelesenen Bild vom ersten in das zweite +Feld und geben Sie dann das zweite Feld in die Datei \texttt{grau2.pgm} aus. + +Geben Sie nun ein kleines Menü (Abb. \ref{cap:Menu-Bildbearbeitung}) +aus und lesen Sie einen Buchstaben zur Auswahl ein. +Mit diesem Buchstaben wird eine \texttt{switch}-Anweisung gesteuert, +in welcher die Bildoperationen durchgeführt werden. + +\textbf{Invertierung}\index{Invertierung}. Bei der Invertierung wird +der neue Grauwert $b_{ij}$ aus dem ursprünglichen Grauwert $a_{ij}$ +wie folgt berechnet: +$$b_{ij}=max.Grauwert-a_{ij}$$ +Es entsteht ein Negativbild: Schwarz wird zu Weiß und umgekehrt. Kontrollieren +Sie das Ergebnis mit dem Bildbetrachter \texttt{xv}. + +% +\begin{figure} +\begin{center} +\includegraphics{./bilder/bildverarb-mittelwert} +\end{center} +\caption{Glättung durch Mittelwertbildung über 9 Bildpunkte\label{cap:Gl=E4ttung-durch-Mittelwertbildung}} +\end{figure} + + +\textbf{Schwellwertoperation}\index{Schwellwertoperation}. Alle Bildpunkte, +die im Originalbild einen Grauwert kleiner 150 besitzen, werden im +Ergebnisbild zu Null gesetzt. Alle anderen Grauwerte werden unverändert +übernommen. + +\textbf{Glättung}\index{Glättung}. Bei der Glättung entsteht das +Zielpixel durch Mittelwertbildung über das Originalpixel und dessen +8 Umgebungspixel (Abb. \ref{cap:Gl=E4ttung-durch-Mittelwertbildung}). +Durch die Glättung werden harte Kontraste gemildert. + +% +\begin{figure} +\begin{center} +\includegraphics[scale=1.0]{./bilder/bildverarb-kanten} +\end{center} +\caption[Kantenerkennung]{Kantenerkennung durch Verknüpfung einer 3x3-Umgebung des Originalbildes mit einer Gewichtungsmatrix\label{cap:Kantenerkennung-durch-Verkn=FCpfung}} +\end{figure} + + +\textbf{Kantenerkennung}\index{Kantenerkennung}. Objektkanten sind +dort zu vermuten, wo sprungartige Helligkeitsübergänge vorhanden sind. +Um Kanten rechnerisch zu ermitteln wird über das Bild ein sog. Operatorfenster +geschoben. Der aktuelle Bildpunkt und die 8 Nachbarpunkte werden mit +den Gewichtungen in Abb. \ref{cap:Kantenerkennung-durch-Verkn=FCpfung} +multipliziert, addiert und zur Normierung durch 9 geteilt. Der Betrag +dieses Ergebnisses ist der Wert des Zielbildpunktes. Wie bei der Glättung +kann diese Operation nur auf die inneren Punkte des Originals angewendet +werden. + + +%%---------------------------------------------------------------------- +%% Bildbereich füllen +%%---------------------------------------------------------------------- +\section{Bildbereich füllen} +\index{Bildbereich füllen} + +%%===== FIGURE (floating) : begin ========== +\begin{floatingfigure}[r]{95mm} +\includegraphics[scale=1.0]{./bilder/bild-fuellen.eps} +\caption{ \label{ABB:Fuellung-eines-Bildbereiches} Rekursives Füllen eines Bildbereiches } +\end{floatingfigure} +%%===== FIGURE (floating): end ========== +Bei Grauwertbildern sollen zusammenhängende Bereiche mit einem neuen +Grauwert versehen werden. Dazu wird ein Impfpixel auf einen neuen +Wert gesetzt und rekursiv alle Nachbarpixel untersucht. Wenn ein Nachbarpixel +denselben Originalgrauwert besitzt, dann erhält es ebenfalls den neuen +Wert und seine Nachbarn müssen auch untersucht werden. Beachten Sie, +daß jeder innere Bildpunkt 4 echte Nachbarn besitzt (Randpunkte entsprechend +weniger !). + +In Abb. \ref{ABB:Fuellung-eines-Bildbereiches}, links, wird ein Hintergrundpixel +mit einem neuen Grauwert ,,geimpft''. Im rechten Bild haben alle +Hintergrundpixel rekursiv den neuen Grauwert erhalten. + +Verwenden Sie nachfolgenden Rahmen: + +\lstset{language=C} +\lstinputlisting[caption={Rahmen für die rekursive Funktion \texttt{fill}},label=pgm-fill]{./programme/fill.c} + + +%%---------------------------------------------------------------------- +%% Verwendung von Strukturen +%%---------------------------------------------------------------------- +\section{Verwendung von Strukturen} +\index{Struktur} + +Erstellen Sie eine neue Version des Programmes, in welcher die Grauwertbilder +in einer Struktur (Listing \ref{pgm-struct}) abgelegt werden. Außerdem +sollen alle Bildverarbeitungsfunktionen in jeweils einer eigenen Funktion +dargestellt werden. Die Bilder sind mittels Zeiger an die Funktionen +übergeben werden. + +\lstset{language=C} + +\lstinputlisting[caption={Strukturdefinition für ein pgm-Bild},label=pgm-struct]{./programme/bildverarb-struct.c} + + +%%---------------------------------------------------------------------- +%% ÜBUNG : Implementierung eines Stapels als Klasse +%%---------------------------------------------------------------------- +\chapter{Implementierung eines Stapels als Klasse} +\index{Stapel} +\index{Klasse} + +%%---------------------------------------------------------------------- +%% Basisimplementierung eines Stapels als C++ - Klasse +%%---------------------------------------------------------------------- +\section{Basisimplementierung eines Stapels als C++ - Klasse} + +\begin{floatingfigure}[r]{75mm} + +\includegraphics[ ]{./bilder/stack.eps} + +\caption{ \label{Datenstruktur-Stapel} Datenstruktur Stapel } + +\end{floatingfigure} + +Abb. \ref{Datenstruktur-Stapel} zeigt die Skizze eines Stapels mit +100 Datenelementen. Der Stapelzeiger \texttt{top} zeigt auf den nächste freien +Platz. + +Datenelemente des Stapels: + +\begin{itemize} +\item Feld, 100 Elemente, zur Aufnahme der Daten +\item Stapelzeiger (\texttt{top}) +\item Feldumfang (zur Überwachung; globale \texttt{const}-Größe) +\end{itemize} +Operationen auf dem Stapel: + +\begin{itemize} +\item Initialisieren (\texttt{top} = 0) +\item Element auflegen (\texttt{push}) +\item Element abnehmen (\texttt{pop}) +\item Feststellen, ob der Stapel leer ist +\item Anzahl der Datenelemente ermitteln +\item Wert des obersten Elementes feststellen +\end{itemize} +Schreiben Sie ein C++-Programm (Dateiendung \texttt{.cc}), in welchem +ein Stapel mit 100 Elementen als Klasse \texttt{stack} für die Aufnahme von +\texttt{int}-Elementen implementiert ist. Die Datenelemente sind als +\texttt{private}-Elemente, die Operationen (Methoden, Komponentenfunktionen) +als \texttt{public}-Elemente einzurichten. + +Die Implementierung der Komponentenfunktionen soll außerhalb der Klassendefinition +stehen und muß deshalb den scope-resolution-Operator ( \texttt{::} ) verwenden: + +\begin{quote} +\begin{verbatim} +void stack :: push ( int datum ) { . . . } +\end{verbatim} +\end{quote} + +Die Einrichtung eines Stapels geschieht z.B. durch + +\begin{quote} +\begin{verbatim} +stack stapel1; +\end{verbatim} +\end{quote} + +Der Aufruf einer Komponentenfunktion geschieht z.B. durch + +\begin{quote} +\begin{verbatim} +stapel1.push( 37 ); +\end{verbatim} +\end{quote} + +\begin{itemize} +\item Schreiben Sie ein Hauptprogramm, in welchem der Stapel in einer Schleife +mit einigen Elementen gefüllt wird. +\item Geben Sie die Belegung des Stapels aus und bauen Sie den Stapel wieder +ab (mit Ausgabe) um das richtige Funktionieren zu testen. +\item Verhindern Sie Unterlauf und Überlauf des Stapels durch entsprechende Vorkehrungen +in den Komponentenfunktionen. +\item Ersetzen Sie die Initialisierungsfunktion durch einen Konstruktor. +\item Verwenden Sie zur Eingabe und Ausgabe \texttt{cin} und \texttt{cout} ( +\texttt{\#include } ). +\end{itemize} + +%%---------------------------------------------------------------------- +%% Konstruktor und Destruktor für Stapel beliebiger Größe +%%---------------------------------------------------------------------- +\section{Konstruktor und Destruktor für Stapel beliebiger Größe} +\index{Konstruktor} +\index{Destruktor} + +Ändern Sie die Klassendefinition so ab, daß mit Hilfe eines 1. Konstruktors +ein Stapel beliebiger Länge zur Laufzeit angelegt werden kann (Operator +\texttt{new}). +Ein 2. Konstruktor, ohne Parameter, soll Stapel der Länge 1024 anlegen. + +Ein Destruktor soll den dynamische belegten Platz eines Stapels freigeben +(Operator \texttt{delete}). + +Überprüfen Sie die Wirkung durch folgendes Experiment: Schreiben Sie +eine rekursive Funktion + +\begin{quote} +\begin{verbatim} +void belege (int n) +\end{verbatim} +\end{quote} + +die einen Stapel der Größe 1024 als lokale Datenstruktur besitzt. + +Im Innern wird n um 1 vermindert (solange es ungleich Null ist). Anschließend +ruft sich die Funktion selbst auf. Wenn n gleich Null ist, wird mit +dem Systemaufruf + +\begin{quote} +\begin{verbatim} +system("free"); +\end{verbatim} +\end{quote} + +\index{UNIX!free} +die augenblickliche Belegung des Hauptspeichers ausgegeben und die +Funktion mit \texttt{return} beendet. Im Hauptprogramm wird vor und +nach dem Aufruf von \texttt{belege(1024)} ebenfalls \verb'system("free")' +aufgerufen (Prototyp in \verb'stdlib.h'). Der Vergleich der Speicherbelegungen +sollte etwa 4 MByte ergeben (warum?). + + +%%---------------------------------------------------------------------- +%% Stapel-Objekte kopieren +%%---------------------------------------------------------------------- +\section{Stapel-Objekte kopieren} + +Schreiben Sie eine Komponentenfunktion \texttt{copy}, + +\begin{quote} +\begin{verbatim} +void copy ( const Stack &s ); +\end{verbatim} +\end{quote} + +die einen Stapel \texttt{s} (Aufrufargument) auf die Originalstruktur kopiert. +Der zu kopierende Stapel wird als Referenz übergeben. + +Folgende Maßnahmen sind erforderlich: + +\begin{itemize} +\item dynamisch belegtes Feld des Zielobjektes freigeben (\texttt{delete}), +\item Feld gemäß Längenangabe von \texttt{s} im Zielobjekt neu belegen (\texttt{new}), +\item Feldinhalt kopieren, +\item die Datenelemente übernehmen. +\end{itemize} +Überprüfen Sie die Wirkung durch einen entsprechenden Test. + +Anmerkung: Die Funktion \texttt{copy} kann durch die Überladung des +Zuweisungsoperators\index{Zuweisungsoperator} \texttt{=} ersetzt werden. + + +%%---------------------------------------------------------------------- +%% ÜBUNG : Klasse von Vektoren mit 3 Elementen +%%---------------------------------------------------------------------- +\chapter{Klasse von Vektoren mit 3 Elementen} +\index{Vektor} + +Die Implementierung einer Klasse \texttt{Vek3} soll die wichtigsten +Grundoperationen der Vektorarithmetik\index{Vektorarithmetik} für +Vektoren der Länge 3 bereitstellen. + +\textbf{Datenelemente}: + +\begin{quote} +\texttt{double}-Variablen \texttt{x, y, z} +\end{quote} + +\textbf{Komponentenfunktionen}: + +\begin{tabular}{|c||p{14cm}|} +\hline +\textbf{Funktion}& \textbf{Beschreibung}\\ +\hline +\hline +\texttt{Vek3}& +0 - 3 Komponente werden gesetzt (Ersatzwerte jeweils 0.0)\\ +\hline +\texttt{null}& +alle Komponenten zu 0 setzen\\ +\hline +\texttt{e\_x}& +Einheitsvektor\index{Einheitsvektor} in x-Richtung erzeugen\\ +\hline +\texttt{e\_y}& +Einheitsvektor in y-Richtung erzeugen\\ +\hline +\texttt{e\_z}& +Einheitsvektor in z-Richtung erzeugen\\ +\hline +\texttt{set\_x}& +x-Komponente zuweisen\\ +\hline +\texttt{set\_y}& +y-Komponente zuweisen\\ +\hline +\texttt{set\_z}& +z-Komponente zuweisen\\ +\hline +\texttt{get\_x}& +x-Komponente zurückgeben\\ +\hline +\texttt{get\_y}& +y-Komponente zurückgeben\\ +\hline +\texttt{get\_z}& +z-Komponente zurückgeben\\ +\hline +\texttt{norm}& +Vektor auf die Länge 1.0 normieren\index{Vektor!normieren}\\ +\hline +\texttt{laenge}& +Rückgabe der Vektorlänge\index{Vektor!Länge}\\ +\hline +& +\textit{Die folgenden 3 Operationen verändern den eigenen Vektor und +geben eine Referenz auf sich selbst zurück.}\\ +\hline +\texttt{plusgleich}& +Vektoraddition\index{Vektor!Addition}\\ +\hline +\texttt{minusgleich}& +Vektorsubtraktion\index{Vektor!Subtraktion}\\ +\hline +\texttt{mulgleich}& +Multiplikation mit einem Skalar\index{Vektor!Multiplikation mit einem Skalar}\\ +\hline +& +\textit{Die folgenden 3 Operationen erzeugen jeweils einen neuen Vektor +und geben diesen zurück; der eigene Vektor bleibt unverändert.}\\ +\hline +\texttt{add}& +Vektoraddition\\ +\hline +\texttt{sub}& +Vektorsubtraktion\\ +\hline +\texttt{mul}& +Multiplikation mit einem Skalar\\ +\hline +\texttt{skalarprodukt}& +Skalarprodukt\index{Vektor!Skalarprodukt} zweier Vektoren\\ +\hline +\texttt{kreuzprodukt}& +Kreuzprodukt\index{Vektor!Kreuzprodukt} zweier Vektoren (s.u.)\\ +\hline +\texttt{out}& +einfache Ausgabefunktion\\ +\hline +\end{tabular} + +\begin{itemize} +\item Alle Methoden sind in einem Hauptprogramm geeignet zu testen. +\item Verwenden Sie die nachstehende Klassendefinition (Listing \ref{vek3-class}). +\end{itemize} +\lstset{language=C} + +\lstset{stepnumber=5} + +\lstinputlisting[caption={Definition der Klasse \texttt{Vek3}},label=vek3-class]{./programme/vek3-class.cc} + + +%%---------------------------------------------------------------------- +%% Berechnung des Kreuzproduktes +%%---------------------------------------------------------------------- +\section*{Berechnung des Kreuzproduktes} +\index{Vektor!Kreuzprodukt} + +$$ +\vec{a} \times \vec{b} = +\left( \begin{array}{c} a_x \\ a_y \\ a_z \end{array} \right) +\times +\left( \begin{array}{c} b_x \\ b_y \\ b_z \end{array} \right) += +\left( +\begin{array}{c} +a_y b_z - a_z b_y \\ +a_z b_x - a_x b_z \\ +a_x b_y - a_y b_x +\end{array} +\right) +$$ + + + +%%---------------------------------------------------------------------- +%% ÜBUNG : Überladen von Operatoren +%%---------------------------------------------------------------------- +\chapter{Überladen von Operatoren} +\index{Operator} + +Die Klasse \texttt{Vek3} aus der vorhergehenden Übung soll nun mit +Hilfe der Operatorüberladung\index{Operatorüberladung} so eingerichtet +werden, daß die übliche mathematische Schreibweise für elementare +Vektoroperationen möglich wird, also z.B.: + +\begin{quote} +\begin{footnotesize} +\begin{verbatim} +double skprod; +Vek3 u, v, w; +u = Vek3( 1.0, 2.0, 3.0 ); // Anfangswerte u +v = Vek3( -3.3, 2.5, 3.1 ); // Anfangswerte v +w = 3.1*u + 23.4*v; // Vektorausdruck +skprod = u*v; // Skalarprodukt +w.norm(); // Vektor w normieren +\end{verbatim} +\end{footnotesize} +\end{quote} + +Erzeugen Sie eine neue Version der Klasse \texttt{Vek3}, in der die +Operatoren in den Tabellen \ref{cap:Zuweisungsoperatoren} und \ref{cap:friend-Funktionen} +implementiert sind und testen Sie alle Operatoren. + + +\begin{table}[h] +\begin{onehalfspace} +\begin{center}\begin{tabular}{|c|c|l|} +\hline +\textbf{Operator} & \textbf{1. Operand} & \textbf{Bemerkung} \\ +\hline +\hline +\texttt{+} & & positives Vorzeichen\\ +\hline +\texttt{-} & & negatives Vorzeichen\\ +\hline +\texttt{+=} & \texttt{const Vek3 \&} & Vektoraddition mit Zuweisung\\ +\hline +\texttt{-=} & \texttt{const Vek3 \&} & Vektorsubtraktion mit Zuweisung\\ +\hline +\texttt{{*}=}& \texttt{double} & Streckung mit Zuweisung\\ +\hline +\texttt{/=} & \texttt{double} & Streckung mit Zuweisung\\ +\hline +\texttt{+} & \texttt{const Vek3 \&} & Vektoraddition\\ +\hline +\texttt{-} & \texttt{const Vek3 \&} & Vektorsubtraktion\\ +\hline +\texttt{/} & \texttt{double} & Streckung\\ +\hline +\end{tabular}\end{center} + +\caption{\label{cap:Zuweisungsoperatoren}Zuweisungsoperatoren der Klasse \texttt{Vek3}} +\end{onehalfspace} +\end{table} + + +% +\begin{table}[h] +\begin{onehalfspace} +\begin{center}\begin{tabular}{|c|c|c|c|} +\hline +\textbf{Operator}& \textbf{1. Operator} & \textbf{2. Operand} & \textbf{Bemerkung}\\ +\hline +\hline +\texttt{{*}} & \texttt{const Vek3 \&} & \texttt{double} & Vektor{*}Skalar\\ +\hline +\texttt{{*}} & \texttt{double} & \texttt{const Vek3 \&} & Skalar{*}Vektor\\ +\hline +\texttt{{*}} & \texttt{const Vek3 \&} & \texttt{const Vek3 \&} & Skalarprodukt\\ +\hline +\texttt{<\,{}<} & \texttt{const Vek3 \&} & & Ausgabe\\ +\hline +\end{tabular}\end{center} +\caption{\label{cap:friend-Funktionen}\texttt{friend}-Funktionen\index{friend-Funktionen} der Klasse \texttt{Vek3} } +\end{onehalfspace} +\end{table} + + +%%---------------------------------------------------------------------- +%% ÜBUNG : Vererbung +%%---------------------------------------------------------------------- +\chapter{Vererbung} + + +%%---------------------------------------------------------------------- +%% Implementierung der Klassen bahn und kbogen +%%---------------------------------------------------------------------- +\section{Implementierung der Klassen \texttt{bahn} und \texttt{kbogen}} + +Zur Implementierung der Klassen \texttt{bahn} und \texttt{kbogen} +wird in dieser Übung die Klasse \texttt{Vek3} aus der vorhergehenden Übung benötigt. +Erzeugen Sie zunächst aus der dort erstellten Lösung folgende Dateien: + +\begin{tabular}{lp{13cm}} +\texttt{\textbf{vek3.h}}& +header-Datei für die Klasse \texttt{Vek3}; enthält die Klassendefinition und +\texttt{include}-Anweisungen für \texttt{iostream.h} und \texttt{math.h}\\ +\texttt{\textbf{vek3.cc}}& +Implementierung der Klasse \texttt{Vek3}; enthält am Anfang +\verb'#include "vek3.h"' +und anschließend die Implementierung der Methoden der Klasse \texttt{Vek3} .\\ +\texttt{\textbf{praktikum-13-1.cc}}& +Hauptprogramm zum Test der Klasse \texttt{Vek3}; enthält am Anfang +\verb'#include "vek3.h"' +und anschließend die Aufrufe und Testausgaben der Methoden der Klasse \texttt{Vek3} .\\ +\end{tabular} + +Definieren und implementieren Sie danach die Klassen \texttt{bahn} und \texttt{kbogen} +(s. Vorlesung): + +\begin{center}\begin{tabular}{|lll|} +\hline +\texttt{\textbf{bahn}}& +\textbf{Datenkomponenten}& +\texttt{pa}, \texttt{pe} Ortsvektoren; Anfangs- und Endpunkt der Bahn (Typ \texttt{Vek3})\\ +& +\textbf{Methoden}& +Konstruktor ohne Parameter\\ +& +& +Konstruktor mit 2 Vektoren als Parameter\\ +& +& +Startpunkt setzen\\ +& +& +Zielpunkt setzen\\ +& +& +Länge berechnen\\ +\hline +\texttt{\textbf{kbogen}}& +\textbf{Datenkomponenten}& +pm Ortsvektor; mittlerer Bahnpunkt (Typ \texttt{Vek3})\\ +& +\textbf{Methoden}& +Konstruktor ohne Parameter\\ +& +& +Konstruktor mit 3 Vektoren als Parameter\\ +& +& +mittleren Punkt setzen\\ +& +& +Länge berechnen (vereinfacht als Summe der Länge der beiden Sehnen)\\ +\hline +\end{tabular}\end{center} + +Legen Sie im Hauptprogram \texttt{bahn}- und \texttt{kbogen}-Objekte +mit und ohne Initialisierung an, berechnen Sie die Längen und geben +Sie diese aus. + +Ergänzen Sie die Konstruktoren und die Längenberechnungen durch einfache +Hilfsausgaben, die die jeweilige Funktion eindeutig benennen und kontrollieren +Sie die Programmausgabe. + + +%%---------------------------------------------------------------------- +%% Initialisierungen mit Hilfe der Basisklassen-Konstruktoren +%%---------------------------------------------------------------------- +\section{Initialisierungen mit Hilfe der Basisklassen-Konstruktoren} + +Ändern Sie den parametrierten Konstruktor der abgeleiteten Klasse +\texttt{kbogen} so ab, daß der Konstruktor der Basisklasse \texttt{bahn} für +den Anfangs- und Endpunkt der Bahn verwendet wird. + +Verfolgen Sie die Aufrufreihenfolge mit Hilfe der oben eingerichteten +Hilfsausgaben. + + +%%---------------------------------------------------------------------- +%% Implementierung der Klasse bahn als Basisklasse +%%---------------------------------------------------------------------- +\section{Implementierung der Klasse \texttt{bahn} als Basisklasse} +\index{Basisklasse} + +Implementieren Sie die Klasse \texttt{bahn} als Basisklasse, die eine +virtuelle Funktion\index{Funktion!virtuelle} \texttt{laenge()} enthält. + +\begin{itemize} +\item Leiten Sie Klassen \texttt{gerade}, \texttt{kbogen} und \texttt{parabel} +ab. +\item Die Konstruktoren sollen den Konstruktor der Basisklasse \texttt{bahn} +für die Anfangs- und Endpunkte verwenden. +\item Die Funktionen zur Längenberechnung sollen jeweils überladen werden. +\item Richten Sie entsprechende Objekte ein und verfolgen Sie die Aufrufe +mittels Hilfsausgaben. +\end{itemize} + +%%---------------------------------------------------------------------- +%% Polymorphie +%%---------------------------------------------------------------------- +\section{Polymorphie} +\index{Polymorphie} + +\begin{itemize} + +\item Richten Sie im Hauptprogramm ein Feld mit 100 Zeigern auf den Typ +\texttt{bahn} ein: \\ +\\ +\verb'bahn *bz[100];'\\ + +\item Legen Sie im Hauptprogramm einige Teilbahnobjekte an (\texttt{gerade}, +\texttt{kbogen}, \texttt{parabel}) und setzen Sie in das Feld \texttt{bz} fortlaufend +Zeiger auf diese Objekte. + +\item Schreiben Sie nun eine Funktion \\ +\\ +\verb'double bahnlaenge ( bahn *bahnzeiger[], int n ) { ... } ' \\ +\\ +an die das Feld \texttt{bz} und die Anzahl der verzeigerten Elemente +übergeben werden. Die Funktion soll die Summe der Längen aller Teilbahnen +berechnen und über \texttt{return} zurückgeben. +\end{itemize} + +%%---------------------------------------------------------------------- +%% Absicherung einer Header-Datei gegen mehrfach-include +%%---------------------------------------------------------------------- +\section{Absicherung einer Header-Datei gegen mehrfach-\texttt{include}} + +Der gesamte Inhalt einer \texttt{h}-Datei\index{h-Datei} (außer dem Kommentar +am Dateianfang) ist durch die folgende \texttt{if}-Anweisung (Präprozessor\index{Präprozessor}) +gegen mehrfaches Einkopieren abzusichern: + + +\begin{quote} +\begin{verbatim} +\#ifndef VEK3\_H // Name bekannt? +\#define VEK3\_H // Name einrichten +... +\#endif +\end{verbatim} +\end{quote} + + +%%---------------------------------------------------------------------- +%% Anhänge +%%---------------------------------------------------------------------- +\begin{appendix} + + +%%---------------------------------------------------------------------- +%% ANHANG : Editor +%%---------------------------------------------------------------------- +\chapter[Erstellen von Programmen]{Erstellen von Programmen \newline (Editieren, Compilieren, Binden)} +\chaptermark{Erstellen von Programmen} +\index{Editieren} +\index{Compilieren} +\index{Binden} + +\begin{figure}[h] +\begin{center} +\subfigure[\texttt{C-Run}]{\includegraphics[ scale=1.0]{./bilder/vim-5.eps}} +\hspace{15mm} +\subfigure[\texttt{Comments}]{\includegraphics[ scale=1.0]{./bilder/menu-comm.eps}} +\hspace{15mm} +\subfigure[\texttt{C-Statements}]{\includegraphics[ scale=1.0]{./bilder/menu-2.eps}} +\end{center} +\caption{\label{ABB:gvim-menu} GVIM : Menüs der C/C++-Unterstützung (Auswahl)} +\end{figure} + +Zur Programmierung wird der sehr leistungsfähige Editor \index{Editor} \texttt{GVIM} \index{GVIM}verendet. +Dieser Editor ist eine Weiterentwicklung des klassischen UNIX-Editors \texttt{vi}. \index{vi} +Die nichtgraphische Version des \texttt{GVIM} heißt \texttt{VIM} \index{VIM}. +Die Handhabung des Editors ist u.a. in den Büchern und Anleitungen beschrieben, +die am Ende dieses Anhangs aufgeführt sind. + +\texttt{GVIM} kann als integrierte Entwicklungsumgebung (IDE) eingesetzt werden. +Der Editor kann beliebig viele Dateien zum Editieren öffnen. +Jede offene Datei wird in einem Editierpuffer gehalten (Das Menü \texttt{Buffers} ermöglicht die Navigation). +Die Fenster können längs und quer geteilt werden. + +Das Menü \texttt{C-Run} (Abbildung \ref{ABB:gvim-menu}) ermöglicht +die Compilierung des aktiven Puffers (Eintrag \texttt{save and compile}) mit Standardeinstellungen +für den Compiler. Der Pufferinhalt wird vor der Übersetzung abgespeichert. +Beim Auftreten von Übersetzungsfehlern wird ein Fehlerfenster geöffnet. +Die fehlerhaften Code-Zeilen im Programmfenster können +durch Auswahl der Fehlereinträge (Maus oder Richtungstasten) im Fehlerfenster +angesprungen und berichtigt werden. + +Für Programme, die nur aus einer einzigen Datei bestehen, besteht +die Möglichkeit, diese Datei nach dem Übersetzen zu binden (Menüeintrag \texttt{link}) und die +Ausführung zu starten (Menüeintrag \texttt{run}). +Dadurch kann die Erstellung eines \texttt{make}-Skriptes vermieden werden. +Die Programmausgaben erscheinen in einer subshell im Editorfenster (Abb. \ref{ABB:vim-subshell} unten). + +Bei Anwahl des Menüpunktes \texttt{C-Run->link} wird der Pufferinhalt +vor dem Binden übersetzt, wenn die evtl. vorhandene Object-Datei älter +ist, als die vor dem Binden gerade gesicherte Quelldatei. + +Bei Anwahl des Menüpunktes \texttt{C-Run->run} wird der Pufferinhalt +vor dem Starten des Programmes übersetzt und gebunden, wenn die evtl. +vorhandene Object-Datei oder die ausführbare Datei älter ist, als +die vor dem Starten gerade gesicherte Quelldatei. + +Für größere Projekte ist die Verwendung von \texttt{make}-Skripten +\index{make} \index{UNIX!make} +oder ähnlicher Werkzeuge erforderlich. +Das \texttt{make}-Programm kann dann ebenfalls über das \texttt{C-Run}-Menü gestartet werden. + +Für Programme mit längeren Ausgaben ist der Aufruf mit Weiterleitung der Ausgaben +durch einen pager (Programm zum Blättern in Dateien oder Konsolausgaben) vorgesehen. + +Die Hauptmenüeinträge \texttt{Comments}, \texttt{C-Statements} usw. erlauben das Einsetzen +von vorbereiteten Kommentaren und von C- bzw. C++-Anweisungen (Abbildung \ref{ABB:gvim-menu}). + +Für einige der bei der Programmerzeugung häufig auszuführenden Tätigkeiten stehen Tastenkürzel +zur Verfügung (s. Tab. \ref{TAB:gvim-tasten} ) +\\ +\\ + +%%+++++ TABLE : begin ++++++++++ +\begin{table}[htbp] +\begin{center} + + %%~~~~~ TABULAR : begin ~~~~~~~~~~ + \begin{tabular}[]{|c|l|} + \hline Tastenkombination& Wirkung\\ [0.0ex] + \hline + \hline F2 & Inhalt des aktiven Puffers sichern. \\ + \hline F3 & Dialog zum Öffnen von Dateien aufrufen. \\ + \hline F6 & Fehlerfenster öffnen. \\ + \hline F7 & Zur Position des vorherigen Fehlers springen. \\ + \hline F8 & Zur Position des nächsten Fehlers springen. \\ + \hline Alt-F9 & Pufferinhalt abspeichern und danach den Pufferinhalt compilieren. \\ + \hline F9 & Programm binden, ggf. vorher compilieren. \\ + \hline Strg-F9 & Programm ausführen, ggf. vorher compilieren und binden. \\ + \hline Shift-F9 & make aufrufen.\\ + \hline + \end{tabular} \\ [0.0ex] + %%~~~~~ TABULAR : end ~~~~~~~~~~ + +\caption{ \label{TAB:gvim-tasten} GVIM : Die wichtigsten Tastenkombinationen der C/C++-Erweiterung} +\vspace{ 5mm} +\end{center} +\end{table} +%%+++++ TABLE : end ++++++++++ + + +%%===== FIGURE : begin ========== +\begin{figure}[htbp] +\begin{center} +\includegraphics[scale=0.9]{./bilder/run1.eps} +\caption{ \label{ABB:vim-subshell} GVIM : Programmausgabe in einer subshell im Editorfenster } +\vspace{ 5mm} +\end{center} +\end{figure} +%%===== FIGURE : end ========== + +Der Editor VIM/GVIM ist ein leistungsstarker Programmiereditor für den Profi. +Die Bedien- und Anwendungsmöglichkeiten sind entsprechend umfangreich. +Neben der online-Hilfe und der Originaldokumentation stehen folgende Bücher +und Anleitungen zur Verfügung: + +\begin{description} +\item [Qualine, Steve ] Vi IMproved - Vim +\footnote{mehrere Exemplare in der Bibliothek der FH SWF vorhanden}\\ +New Riders Publishing, 2001, ISBN: 0735710015\\ +oder unter http://vim.sourceforge.net/docs.php als PDF-Datei + +\item [Robbins, Arnold ] vi Editor kurz\&gut +\footnotemark[1]\\ +O'Reilly, 2000, ISBN 3-89721-213-7\\(Kurzanleitung, 63 Seiten, 2. Auflage) + +\item [Lamb, Linda / Robbins, Arnold ] Textbearbeitung mit dem vi-Editor +\footnotemark[1]\\ +O'Reilly, 1999, ISBN 3-89721-126-2\\(deutsche Übersetzung der 6. amerikanischen Auflage) + +\item [http://www.vim.org ] The VIM (Vi IMproved) Home Page\\ +Homepage des Vim-Projektes; viele Verweise auf andere Seiten und auf Dokumentation. + +\item [http://vim.sourceforge.net ] Vim bei sourceforge\\ +Vim-Skripte zur Erweiterung des Editors, Tips, Neuigkeiten, ... + +\end{description} + + + + +%%---------------------------------------------------------------------- +%% ANHANG : Testen von Programmen (Debugging) +%%---------------------------------------------------------------------- +\chapter[Testen von Programmen]{Testen von Programmen (Debugging)} +\chaptermark{Testen von Programmen} +\index{Testen} +\index{Debugging} + + +%%===== FIGURE : begin ========== +\begin{figure}[htbp] +\begin{center} +\includegraphics[scale=0.9]{./bilder/ddd.eps} +\caption{ \label{ABB:DDD} Der Debugger \texttt{DDD} } +\vspace{ 5mm} +\end{center} +\end{figure} +%%===== FIGURE : end ========== + +Zum Testen von Programmen kann der Debugger \texttt{DDD} \index{DDD} verwendet werden. +Das zu testende Programm muß dazu als ausführbare Datei vorliegen, d.h. es muß übersetzt +und gebunden sein und enthält damit keine syntaktischen Fehler mehr. + +Der DDD kann über das Symbol auf der Arbeitsfläche gestartet werden. +Im Dialog wird das zu testende und ausführbare Programm geöffnet. +Die zugehörige Quelldatei erscheint nun im Quelltextfenster (Abb. \ref{ABB:DDD} ). +Außerdem erscheint im Quelltextfenster das frei verschiebbare Kommandofenster. + +\newpage + + + +%%===== FIGURE (floating) : begin ========== +\begin{floatingfigure}[r]{70mm} +\begin{center} + \subfigure[Haltepunktmenü] + { + \includegraphics[ ]{./bilder/ddd-breakpoint-menu.eps} + } + \subfigure[Kommandomenü] + { + \includegraphics[ ]{./bilder/ddd-menu.eps} + } +\caption{ \label{ABB:DDD-menu} DDD : Haltepunktmenü und Kommandomenü} +\end{center} +\end{floatingfigure} +%%===== FIGURE (floating): end ========== + + +\textbf{Haltepunkte (breakpoints).} \index{Haltepunkt} \index{breakpoint} +Setzt man die Schreibmarke an den Anfang einer ausführbaren Quellcodezeile und +betätigen die rechte Maustaste, dann erscheint das Haltepunktmenü (Abb. \ref{ABB:DDD-menu}a). +Die erste Auswahl (\texttt{Set Breakpoint}) setzt einen festen Haltepunkt. +Der zweite Eintrag (\texttt{Set Temporary Breakpoint}) setzt einen Haltepunkt, +der nach dem Erreichen wieder gelöscht wird. +Der dritte Eintrag (\texttt{Continue Until Here}) ermöglicht die Programmausführung +oder -weiterführung bis zu der Zeile vor der Schreibmarke. +\\ +\textbf{Programm schrittweise testen.} +Durch die Anwahl des Eintrages \texttt{Run} im Kommandomenü (Abb. \ref{ABB:DDD-menu}b) +wird das Programm gestartet und bis zur letzten ausführbaren +Programmanweisung \textit{vor} dem Haltepunkt ausgeführt. +Die erreichet Stelle wird durch einen roten Pfeil gekennzeichnet (Abb. \ref{ABB:DDD}). +Mit Hilfe der anderen Möglichkeiten des Kommandomenüs kann das Programm +Zeile für Zeile ausgeführt werden (Tab. \ref{TAB:DDD-Kommandomenü}). +Nach jedem Schritt können dann z.B. Variablenwerte angesehen oder verändert werden. + +\vspace{ 5mm} + +%%+++++ TABLE : begin ++++++++++ +\begin{table}[htbp] +\begin{center} + %%~~~~~ TABULAR : begin ~~~~~~~~~~ + \begin{tabular}[]{|p{4cm}|p{12cm}|} + \hline + Haltepunkt setzen + & - Cursor am Anfang der gewünschten Zeile positionieren \newline + - rechte Maustaste niederhalten (Haltepunktmenü) \newline + - \texttt{Set Breakpoint} oder \texttt{Delete Breakpoint} wählen \newline + - am Zeilenanfang erscheint ein Stop-Schild \\ + \hline + Haltepunkt löschen + & - Cursor über dem Stop-Schild positionieren \newline + - rechte Maustaste niederhalten (Haltepunktmenü) \newline + - \texttt{Delete Breakpoint} wählen \\ + \hline + Programm bis zum \newline Haltepunkt ausführen + & - Menüeintrag \texttt{Run} wählen\\ + \hline + Wert einer Variable \newline ansehen + & - Mauszeiger im Quelltextfenster über dem Variablennamen positionieren\\ + \hline + Datenelement im \newline Datenfenster anzeigen + & - Mauszeiger im Quelltextfenster über dem Namen positionieren \newline + - rechte Maustaste niederhalten (Display-Menü erscheint) \newline + - \texttt{Display} wählen\newline + - im Datenfenster erscheint die entsprechende Anzeige\\ + \hline + Datenelement im \newline Datenfenster erweitern + & Bei Strukturen, Feldern, komplexen Objekten usw. kann \newline + die Darstellung erweitert oder zusammengefaßt werden:\newline + - Mauszeiger im Datenfenster über dem Datenelement positionieren \newline + - rechte Maustaste niederhalten (Menü) \newline + - \texttt{Show All} oder \texttt{Hide All} wählen\\ + \hline + \end{tabular} \\ [0.0ex] + %%~~~~~ TABULAR : end ~~~~~~~~~~ +\caption{ \label{TAB:DDD-Bedienung} DDD : Grundlegende Bedienung } +\end{center} +\end{table} +%%+++++ TABLE : end ++++++++++ + + +%%+++++ TABLE : begin ++++++++++ +\begin{table}[htbp] +\begin{center} + %%~~~~~ TABULAR : begin ~~~~~~~~~~ + \begin{tabular}[]{|l|l|} + \hline Run & Starte das zu testende Programm \\ + \hline Interrupt & Unterbreche das zu testende Programm \\ + \hline Step & eine Zeile weiter (bei Unterprogammaufrufen wird in das Unterprogramm gesprungen) \\ + \hline Next & eine Zeile weiter (bei Unterprogammaufrufen wird der Aufruf übersprungen) \\ + \hline Until & Programm bis zur nächsten ausführbaren Zeile fortsetzen (zeilenweise Ausführung) \\ + \hline Cont & Programm nach einem Haltepunkt fortsetzen \\ + \hline Kill & Programm abbrechen \\ + \hline + \end{tabular} \\ [0.0ex] + %%~~~~~ TABULAR : end ~~~~~~~~~~ +\caption{ \label{TAB:DDD-Kommandomenü} DDD : Die Befehle des Kommandomenüs } +\end{center} +\end{table} +%%+++++ TABLE : end ++++++++++ + +Der Debugger DDD ist äußerst leistungsfähig und steht für mehrere Rechnerplattformen zur Verfügung. +Eine umfassendere Darstellung würde den Rahmen an dieser Stelle sprengen. +Alles weitere muß der Originaldokumentation entnommen werden. + + +\end{appendix} + + +%%---------------------------------------------------------------------- +%% Buchnachspann +%%---------------------------------------------------------------------- +\backmatter + +%%====================================================================== +%% Stichwortverzeichnis +%%====================================================================== +\cleardoublepage +\addcontentsline{toc}{chapter}{Stichwortverzeichnis} +\printindex{} + +\end{document} +%%%%%%%%%%%%%%%%%%%%%% LATEX-Dokument -- ENDE %%%%%%%%%%%%%% -- cgit v1.2.3-70-g09d2