\documentclass[11pt]{article}
\usepackage{longtable}
%\usepackage{landscape}

\pagestyle{empty}
\sloppy
\frenchspacing
\setlength{\textwidth}{23 cm}
\setlength{\textheight}{19 cm}
\setlength{\oddsidemargin } {0 mm}
\setlength{\evensidemargin } {0 mm}
\setlength{\topmargin } {0 mm}
\setlength{\headsep } {0 mm}
%\openup -4 pt
\parindent 0 pt

\begin{document}
\noindent
{\bf \Large EINE KLEINE \"UBERSETZUNGSHILFE F\"UR MONOGLOTTE PROGRAMMIERER}\\
{\it Zusammenstellung der Sprachmittel zur Unterst\"utzung
  prozeduraler Programmierung in FORTRAN, PASCAL, C, C++: 
  Alles in der C-Spalte Gesagte gilt ebenfalls f\"ur C++}\\
\noindent
\setlongtables
\begin{longtable}[l]{|l|l|l|l|}
\hline 
FORTRAN 77 & PASCAL & ANSI/ISO C & ANSI/ISO C++ \\ 
\hline
\endhead
\hline
\endfoot
\multicolumn{4}{|l|}{\bf 0 Literatur}\\
\hline
\begin{minipage}{5.5cm}
Regionales Rechenzentrum f\"ur 
Niedersachsen, Uni Hannover: \\
FORTRAN 77 Sprachumfang           
\end{minipage}
&
\begin{minipage}{5.5cm}
Quelle:\\ 
{\footnotesize\tt
http://www.cit.ac.nz/smac/pascal}
\end{minipage}
&
\begin{minipage}{5.5cm}
Kernighan/Ritchie:\\
The C Programming Language, 
Prentice Hall.
\end{minipage}
&
\begin{minipage}{5.5cm}
B. Stroustrup:\\
The C++ Programming Language, 3rd ed,
Addison Wesley.
\end{minipage}
\\
\hline
\multicolumn{4}{|l|}{\bf 1 Kurzes Beispielprogramm, Kommentarsyntax}\\
\hline
{\footnotesize
\begin{minipage}{5.5cm}
\begin{verbatim}
c234567890123456789 .. max 72
      program hello
      integer  a
      real*8   b
      parameter (b=3.1415926d0)
C       square root
      a = sqrt(exp(b))**3
      print*,"exp(pi)^(3/2): ",
     &       a
      end
\end{verbatim}
\end{minipage}
}
&
{\footnotesize
\begin{minipage}{5.5cm}
\begin{verbatim}
program hello (output);
const b : real = 3.1415926;
var   a : integer;
begin
  (* square root *) 
  a := sqrt(exp(b))^3;
  writeln("exp(pi)^(3/2): ",
      a );
end.  
\end{verbatim}
\end{minipage}
}
&
{\footnotesize
\begin{minipage}{5.5cm}
\begin{verbatim}
#include <stdio.h>
#include <math.h>
int main(){
  const double b = 3.1415926;
  /* square root */
  int a = pow(sqrt(exp(b)),3.); 
  printf("exp(pi)^(3/2): %d", 
      a );
  return 1;
}
\end{verbatim}
\end{minipage}
}
&
{\footnotesize
\begin{minipage}{5.5cm}
\begin{verbatim}
#include <iostream>
#include <cmath>
using std::pow, std::exp, std::sqrt;

int main(){
  const double b = 3.1415926;
  // square root
  int a = pow(sqrt(exp(b)),3.); 
  std::cout << "exp(pi)^(3/2): " 
            << a << "\n";
  return 1;
}
\end{verbatim}
\end{minipage}
}
\\
\hline
\multicolumn{4}{|l|}{\bf 2 Anweisungen}\\
\hline
\begin{minipage}[t]{5.5cm}
{\footnotesize
\begin{verbatim}
c234567890123456789 .. max 72
      A = A * B
      PRINT*,'A= ',A
\end{verbatim}
}%
  Festformatsprache:\\
  Befehle ab der 7. Spalte, max.\ 72;\\
  Fortsetzungszeichen in der 6. Spalte;\\
  Labels 2.-5. Spalte;\\
  Eine Anweisung pro Zeile;\\
  Gro{\ss}schreibung Standard, 
  keine Unterscheidung von Gro{\ss}-- und 
  Kleinschreibung.
\end{minipage} 
&
\begin{minipage}[t]{5.5cm} 
{\footnotesize
\begin{verbatim}
begin
  a := a * b;
  writeln("a=", a)       
end
\end{verbatim}
}%
  Freiformatsprache:
  {\tt ;} zur Trennung zweier Anweisungen,\\
  mehrere Anweisungen pro Zeile m\"oglich\\
  Gruppierung von Anweisungen zwischen
  {\tt begin} und {\tt end}\\
  Gro\ss{}- und Kleinschreibung signifikant 
  bei Benutzersymbolen,
  {\it nicht} bei Sprachbestandteilen
\end{minipage}
&
\begin{minipage}[t]{5.5cm}
{\footnotesize
\begin{verbatim}
#include <stdio.h>
  ...
  { a *= b; 
    printf("a= %g\n", a);
  } 
\end{verbatim}
}
\vspace{-0.4cm}
Freiformatsprache:
  {\tt ;} zur Beendung von Anweisungen,\\
  mehrere Anweisungen pro Zeile m\"oglich\\
  Gruppierung von Anweisungen zwischen
  {\tt \{} und {\tt \}}\\
  Gro\ss{}- und Kleinschreibung signifikant  
\end{minipage}
&
\begin{minipage}[t]{5.5cm}
{\footnotesize
  \begin{verbatim}
#include <iostream>
using std::cout;
  ...
  { a *= b;
    cout << "a= " << a << "\n";  
  }
  \end{verbatim}
}
\end{minipage}
\\
\newpage
\hline
\multicolumn{4}{|l|}{\bf 3 Datentypen, Deklarationen, Felder}\\
\hline
\begin{minipage}[t]{5.5cm}
{\footnotesize
\begin{verbatim}
IMPLICIT NONE
INTEGER  A, B, C                     
PARAMETER(A=25)
REAL*8        D              
COMPLEX       G
CHARACTER*1   E                 
LOGICAL       F                

INTEGER   AA(10,20)
INTEGER*2 AB(-3:9)
REAL*4    AD(0:9)     
\end{verbatim}
}
Bezeichner k\"onnen 
Typ implizieren  
\end{minipage}
&
\begin{minipage}[t]{5.5cm}
{\footnotesize
\begin{verbatim}

var b, c: integer;
const  a: integer =25; 
var    d: real;

var    e: char;
var    f: bool;

var aa: array[10;20] of integer;(?)
var ab: array[-3..9] of integer;
var ad: array[10] of real; 
\end{verbatim}
}
immer deklariert
\end{minipage}
&
\begin{minipage}[t]{5.5cm}
{\footnotesize
\begin{verbatim}

int     b, c;
const int a=25; 
double  d;

char    e;
int     f;

int    aa[10][20];
short _ab[13], *ab=&_ab[0]+3;
float  ad[10]; 
\end{verbatim}
}
immer deklariert
\end{minipage}
&
\begin{minipage}[t]{5.5cm}
{\footnotesize
\begin{verbatim}
#include <complex>
#include <map>
#include <string>

bool    f = false;
complex<double> g(0.,1.), 
        x = g * g;

std::map<std::string,int> age;
age["Peter"] = 15;

\end{verbatim}
}
wie C, sowie weitere frei definierbare 
Typen/Klassen; immer deklariert
\end{minipage}
\\
\hline
\multicolumn{4}{|c|}{\it g\"ultige Feldelemente:}\\
\hline
\begin{minipage}[t]{5.5cm}
default: erster Feldindex 1\\
sonst wie spezifiziert
\begin{verbatim}                       
AA(1,1) .. AA(10,20)
AB(-3) .. AB(9) 
\end{verbatim}
\end{minipage} 
&
\begin{minipage}[t]{5.5cm}
default: erster Feldindex 1\\
sonst wie spezifiziert
\begin{verbatim}                       
aa[1,1] .. aa[10,20]  (?)
ab[-3] .. ab[9]
\end{verbatim}
\end{minipage}
&
\begin{minipage}[t]{5.5cm}
erster Feldindex immer 0\\
sonst nur Zeigerarithmetik
\begin{verbatim}
aa[0][0] .. aa[9][19]
ab[-3] .. ab[9]
\end{verbatim}
\end{minipage}
&
\begin{minipage}[t]{5.5cm}
wie C, zus\"atzlich 
dynamische Feldtypen aus {\tt std::}
{\footnotesize
\begin{verbatim}
#include <vector>
 ...  int n; ...
 std::vector<int> v(n,0)
 v[7] = 9;   // ok if 7 < n
\end{verbatim}
}
\end{minipage}
\\
\hline
\multicolumn{4}{|l|}{\bf 4 Zuweisungen, Arithmetik}\\
\hline
\begin{minipage}[t]{5.5cm}
{\footnotesize
\begin{verbatim}         
C = A  + - * / B           
C = C  + - * / B
C = C  + - 1                 
A**((B + C) * D)        
MOD(I,J)                  
SQRT(A) COS(A) SIN(A)    
A**2                      
ISHIFT(I,5)
\end{verbatim}
}
\end{minipage} 
&
\begin{minipage}[t]{5.5cm}
{\footnotesize
\begin{verbatim}
c := a + - * / b;
c := c + - * / b;
inc(c); dec(c); (?)  
a ^ ((b+c)*d)   (?)
i mod j
sqrt(a) cos(a) sin(a) 
a ^ 2
(?)
\end{verbatim}
}
\end{minipage}
&
\begin{minipage}[t]{5.5cm}
{\footnotesize
\begin{verbatim}
c = a + - * / b;
c += -= *= /= b;  
c++; ++c; c--; --c; 
pow(a,(b+c)*d) 
i % j
sqrt(a) cos(a) sin(a) 
a * a   pow(a,2.)
i << 5, i >> 5
\end{verbatim}
}
\end{minipage}
&
\begin{minipage}[t]{5.5cm}
\begin{verbatim}\end{verbatim}
wie bei C,\\ 
Neudefinition der Operatoren 
f\"ur eigene Typen/Klassen 
m\"oglich
\end{minipage}
\\
\hline
\newpage
\multicolumn{4}{|l|}{\bf 5 Zeichenketten, -operationen}\\
\hline
\begin{minipage}[t]{5.5cm}
{\tt CHARACTER*10  A}\\         
{\tt A  = 'foo''s'}\\
{\tt A(1:2)} ist {\tt 'fo'}\\         
{\tt A(6:6)} ist undefiniert\\ 
{\tt A = a // 'sel'}\\
\\
Zugriff auf Teilketten mit :\\
\end{minipage}
&
\begin{minipage}[t]{5.5cm}
{\tt var a: string[10];}\\
{\tt a  := 'foo''s'}\\
({\tt a[0]} ist L\"ange)\\
{\tt a[1]} ist {\tt 'f'}\\         
{\tt a[6]} ist undefiniert\\ 
{\tt append(a,'sel');}\\
Einzelzeichen wie bei Feldern\\
begrenzte L\"ange: 255 Zeichen 
\end{minipage}
&
\begin{minipage}[t]{5.5cm}
{\tt 
char a[10];\\
a = "foo's";\\
a[0]  {\rm ist} 'f'\\
a[5]  {\rm ist} \verb|'\0'|\\
a[6]  {\rm ist undefiniert}\\
strcat(a,"sel");\\
}
Einzelzeichen wie bei Feldern\\ 
Konvention/Problem: Nullterminierung 
\end{minipage}
&
\begin{minipage}[t]{5.5cm}
{\tt 
std::string  a;\\
a = "foo's";\\
a[0]  {\rm ist} 'f'\\
a[5]  {\rm ist undefiniert}\\
a[6]  {\rm ist undefiniert}\\
a += "sel";}\\
Einzelzeichen wie bei Feldern\\
unbegrenzte L\"ange
\end{minipage}
\\
\hline
\multicolumn{4}{|l|}{\bf 6 Vergleichsausdr\"ucke, logische Operatoren}\\
\hline
\begin{minipage}[t]{5.5cm}
{\footnotesize
\begin{verbatim}     
LOGICAL C
.FALSE.              
.TRUE.               
.EQ. .NE. 
.GT. .GE. .LT. .LE.    
.NOT. .AND. .OR.                  
( IEXOR(A,B) IAND(,) IOR(,) )
\end{verbatim}
}
\end{minipage} 
&
\begin{minipage}[t]{5.5cm}
{\footnotesize
\begin{verbatim}     
var c: boolean;
<false> (?)              
<true>  (?)
 =   <>
 >   >=  <  <=     
not and or 
(?)
\end{verbatim}
}
\end{minipage} 
&
\begin{minipage}[t]{5.5cm}
{\footnotesize
\begin{verbatim}     
int     c;
0
1 
=   !=
>   >=  <  <=     
!   &&  ||
~   &   |   ^   
\end{verbatim}
}
Werte \verb|!=0| sind wahr
\end{minipage} 
&
\begin{minipage}[t]{5.5cm}
{\footnotesize
\begin{verbatim}     
bool   c;
true
false 
eq  neq
>   >=  <  <=     
not   and    or
compl bitand bitor xor
\end{verbatim}
}
zus\"atzliche Schl\"usselw\"orter 
um Operatoren abzubilden
\end{minipage} 
\\
\hline
\multicolumn{4}{|l|}{\bf 7 Bedingte Ausf\"uhrung}\\
\hline
\begin{minipage}[t]{5.5cm}
{\footnotesize
\begin{verbatim}
IF (.NOT.(A.GT.B).AND.GOON) THEN      
  DO_SOMETHING
ELSE
  DO_SOMETHING_ELSE  
ENDIF 


\end{verbatim}
}
else-Teil kann entfallen
\end{minipage}
&
\begin{minipage}[t]{5.5cm}
{\footnotesize
\begin{verbatim}
if not (a > b) and go_on then 
begin 
  statement;
  statement2
end
else  
  statement3;
\end{verbatim}
}
else-Teil kann entfallen\\
bei einer Anweisung k\"onnen
{\tt begin} und {\tt end}
entfallen. 
\end{minipage}
&
\begin{minipage}[t]{5.5cm}
{\footnotesize
\begin{verbatim}
if( !(a > b) && go_on ){ 
  statement;
  statement2;
}
else 
  statement3;

\end{verbatim}
}
else-Teil kann entfallen\\
bei einer Anweisung k\"onnen
\verb|{}| entfallen
\end{minipage}
&
\begin{minipage}{5cm}
dto.
\end{minipage}
\\
\hline
\newpage
\multicolumn{4}{|l|}{\bf 8 (Nicht-)Abweisende -, Z\"ahlschleifen}\\
\hline
\begin{minipage}{5.5cm}
{\footnotesize
\begin{verbatim}    
 99 IF(.NOT. cond) THEN
    ... 
    GOTO 99
    ENDIF

199 CONTINUE
    ...
    IF( cond ) GOTO 199    

    DO 10 I=1,10,2                   
    ...                             
10  CONTINUE                       
\end{verbatim}
}
Angabe der Schrittweite 
bei {\tt DO} m\"oglich (hier 2)
\end{minipage}
&
\begin{minipage}{5.5cm}
{\footnotesize
\begin{verbatim}    
    while cond do 
      statement;

    repeat
      statement;
    until cond;

    for i :=1 to 6 do 
      statement;
\end{verbatim}
}
Einzelanweisungen oder Bl\"ocke\\
{\tt for} Schrittweite immer 1
\end{minipage}
&
\begin{minipage}{5.5cm}
{\footnotesize
\begin{verbatim}    
    while( cond )
      statement;

    do 
      statement;
    while( cond );

    for(int i=0; i<10; i+=2)
      statement;
\end{verbatim}
}
Einzelanweisungen oder Bl\"ocke\\
Beliebige Tests in {\tt for}\\
Ggf. Deklaration im Bedingungsteil\\
\end{minipage}
&
dto.
\\
\hline
\multicolumn{4}{|l|}{\bf 9 Funktionen, Prozeduren}\\
\hline
\begin{minipage}[t]{5.5cm}
{\footnotesize
\begin{verbatim}     
REAL*8 FUNCTION MFUNC( A, B )  
REAL*8 A, B
REAL*8 C 
C = A*B                      
MFUNC = C                   
RETURN
END                          

SOUBROUTINE FOO( A )            
REAL*8 A                       
A = A + 2D0                       
RETURN
END                          
\end{verbatim}
}
Parameter\"ubergabe per Re\-fe\-renz, d.h. 
Zuweisungen im Auf\-ru\-fer sichtbar.\\
keine konsistente Typ\-\"uber\-pr\"u\-fung der 
Argu\-mente\\
{\tt RETURN} an beliebiger Stelle
\end{minipage}
&
\begin{minipage}[t]{5.5cm}
{\footnotesize
\begin{verbatim}     
function mfunc(a, b: real): real; 
var c: real;
begin
  c := a * ;
  mfunc := c;
end;

procedure foo(var a: real);
begin
  a := a + 2
end;


\end{verbatim}
}
Parameter\"ubergabe als Kopie, oder als 
Referenz (mit {\tt var}).\\
R\"uckkehr immer am Prozedurende, 
kein {\tt return}\\
\end{minipage}
&
\begin{minipage}[t]{5.5cm}
{\footnotesize
\begin{verbatim}     
int mfunc(int a, int b) {  
  return a * b;   
} 

void foo( int *a ){
  *a += 2;
  return; 
}





\end{verbatim}
}
Parameter\"ubergabe als Kopie, Felder als Referenz. 
Zeigervariablen n\"otig, um Werte zu ver\"andern.\\
{\tt return} (ggf. mit R\"uckgabewert) an beliebiger 
Stelle. 
\end{minipage}
&
\begin{minipage}[t]{5.5cm}
{\footnotesize
\begin{verbatim}     




void foo(int &a){
  a += 2;
  return;
}





\end{verbatim}
}
Referenzvariablen als Funktions\-parameter m\"oglich 
\end{minipage}
\\
\hline
\newpage
\multicolumn{4}{|l|}{\bf 10 Ein-/Ausgabe}\\
\hline
\begin{minipage}[t]{5.5cm}
{\footnotesize
\begin{verbatim}    
INTEGER A                   
REAL*8  C, D(2)    

PRINT*, A, C, D             
WRITE(*,'(2F12.6)') D                             
\end{verbatim}
}
\end{minipage}
&
\begin{minipage}[t]{5.5cm}
{\footnotesize
\begin{verbatim}    
program io(input, output);
...
var a, i: integer;
    c: real;
    d: array[2] of real;
...
writeln(a,c);
for i:=1 to 2 do
  write ( d[i]:12:6 );
writeln();
readln( c, a );
\end{verbatim}
}
\end{minipage}
&
\begin{minipage}[t]{5.5cm}
{\footnotesize
\begin{verbatim}    
#include <stdio.h>
...
int    a, i;
double c;
double d[2];
...
printf("%i %g\n",a,c);
for(i=0; i<2; i++)
  printf("%12.6g", d[i]);
printf("\n");
scanf("%lg %d",&c, &a);
\end{verbatim}
}
\end{minipage}
&
\begin{minipage}[t]{5.5cm}
{\footnotesize
\begin{verbatim}    
#include <iostream>
...
int    a;
double c;
double d[2];
...
std::cout << a << c << "\n";
for(int i=0; i<2; i++)
  std::cout << setw(12) 
     << setprecision(6) << d[i];
std::cout << endl;
std::cin >> c >> a;
\end{verbatim}
}
\end{minipage}
\\
\hline
\multicolumn{4}{|l|}{\bf 11 Dateien}\\
\hline
\begin{minipage}[t]{5.5cm}
{\footnotesize
\begin{verbatim*}  
      REAL*8  A
      OPEN(90,STATUS='UNKNOWN',
     & FILE='OUT.DAT')
      OPEN(91,STATUS='UNKNOWN',
     & FILE='IN.DAT')
      READ(91,*) A
      CLOSE(91)
      WRITE(90,999) A                           
999   FORMAT('A = ',F7.2)
      CLOSE(10)                                
\end{verbatim*}
}
5, 6 Terminal Ein/Ausgabe\\
kleine Zahlen manchmal belegt\\
Nummern < 100
\end{minipage}
&
\begin{minipage}[t]{5.5cm}
{\footnotesize
\begin{verbatim}                                                 
program fileio(in,out);
var in, out: file of char;
    a:real;
begin
  reset(in,'in.dat'); 
  readln(in,a);
  close(in);
  rewrite(out,'test.dat');
  writeln(out,'a= ',a);
  close(out)
end.

\end{verbatim}
}
\end{minipage}
&
\begin{minipage}[t]{5.5cm}
{\footnotesize
\begin{verbatim}                                                 
#include <stdio.h>
...
double  a;
FILE  *in, *out; 
out = fopen("out.dat","w");
in  = fopen("in.dat","r");  
fscanf(in,"%lg", &a);  
fclose(in);
fprintf(out,"a= %7.2f", a);
fclose(out);
\end{verbatim}
}
\end{minipage}
&
\begin{minipage}[t]{5.5cm}
{\footnotesize
\begin{verbatim}                                                 
#include <fstream>
...
ofstream out("out.dat");
ifstream in("in.dat"); 
in >> a;
in.close();
out << "a = " <<  setw(7) <<
    << setprecision(2) << a;
out.close();
\end{verbatim}
}
\end{minipage}
\\
\hline
\multicolumn{4}{|l|}{\bf 12 Strukturen/Records}\\
\hline
keine
&
\begin{minipage}[t]{5.5cm}
{\footnotesize
\begin{verbatim}
type info = record
        name: string[20];
        age:  integer;
     end;   
var myinfo : info;
myinfo.name := 'Stefan';
\end{verbatim}
}
\end{minipage}
&
\begin{minipage}[t]{5.5cm}
{\footnotesize
\begin{verbatim}
typedef struct {
   char name[20];
   int  age;
} info;
info myinfo = {"Peter",10};
myinfo.name =  "Stefan";
\end{verbatim}
}
\end{minipage}
&
\begin{minipage}[t]{5.5cm}
{\footnotesize
\begin{verbatim}
class Info {
public:
  Info(string aname, aage)
    : name(aname), age(aage){}
  string name;
  int    age;
}
info myinfo("Peter",10);
myinfo.name = "Stefan";
\end{verbatim}
}
\end{minipage}
\\
\hline
\newpage
\multicolumn{4}{|l|}{\bf 13 Zeigervariablen, dynamischer Speicher}\\
\hline
keine
&
\begin{minipage}[t]{5.5cm}
{\footnotesize
\begin{verbatim}
var iptr : ^integer;
    i    : integer;

new( iptr );
iptr^ := 10;
dispose( iptr );
iptr := ^i; 
iptr := nil;
\end{verbatim}
}
Zeiger auf neuen Speicher {\tt new} 
oder Variablen.\\
{\tt nil} spezieller Wert f\"ur 
unm\"ogliche Adresse
\end{minipage}
&
\begin{minipage}[t]{5.5cm}
{\footnotesize
\begin{verbatim}
int  *iptr;
int   i;

iptr=(int *)malloc(sizeof(int));
*iptr= 10;
free(iptr);
iptr= &i;
iptr=0;
\end{verbatim}
}
Zeigervariablen sind Adressen.\\ 
Anforderung Spei\-cher\-blocks 
beliebiger Gr\"o\ss{}e mit {\tt malloc/calloc}.\\
Cast {\tt (int *)} n\"otig.\\
\end{minipage}
&
\begin{minipage}[t]{5.5cm}
{\footnotesize
\begin{verbatim}
int i;
int &iref=i; 
int *iptr, *i10ptr;

iref = 5; 
iptr = new int;
i10ptr = new int[10];
delete[] i10ptr;
delete iptr;
\end{verbatim}
}
Referenzvariablen {\tt \&} 
sind neue Namen f\"ur bestehende Variablen.\\
{\tt new/delete} statt {\tt malloc/free}.\\
{\tt new[]/delete[]} f\"ur dynamische Felder.
\end{minipage}
\\
\hline

\end{longtable}
\end{document}
