[376B]

//datumzeit.cpp
//Gibt Datum&Zeit aus
#include <iostream>
#include <ctime>
 
int main()
{
  std::time_t zeit;
  std::tm *jetzt;
 
  zeit  = std::time(0);
  jetzt = std::localtime(&zeit);
 
  std::cout << jetzt->tm_mday << '.' << jetzt->tm_mon+1 << '.'
            << jetzt->tm_year+1900 << " - " << jetzt->tm_hour
            << ':' << jetzt->tm_min << std::endl;
 
  return 0;
}
 

[809B]

//namespaces.cpp
// Erklärt, was Namespaces sind, und wie man sie nutzt
 
#include <iostream>
 
//KEIN USING NAMESPACE STD
 
int i;                        //globale Variable
 
namespace nasenbaer
{
  int i;                      //Variable gehört zum Namespace "Nasenbaer"
  void sages()
  {
    ::std::cout << "Test!\n"; //::std::cout bedeutet:
                              // "gehe in den obersten Namespace,
                              // suche NS "std",
                              // suche "cout"...
  }
}
 
int main()
{
  ::i=3;                      //"::" ist der oberste NS!
                              // Kann hier auch weggelassen werden!
  ::Nasenbaer::i=5;
  ::Nasenbaer::sages();
  ::std::cout << " " << ::i << "<->" << ::Nasenbaer::i;
  ::std::cout << "\nEnde..." << std::endl;
  return 0;
}
 

[351B]

//zufall1.cpp
//Gibt "Zufallszahlen" aus...
#include <iostream>
#include <cstdlib>
 
int main()
{
  std::cout << "Zufallszahlen?\n";
  std::cout << "\"RAND_MAX\": " << RAND_MAX << "\n\n";
  std::cout << "Zahl 1: " << std::rand() << "\n";
  std::cout << "Zahl 2: " << std::rand() << "\n";
  std::cout << "Zahl 3: " << std::rand() << "\n";
  return 0;
}
 

[395B]

//zufall2.cpp
//Gibt Zufallszahlen aus...
#include <iostream>
#include <cstdlib>
#include <ctime>
 
int main()
{
  std::srand(std::time(0));
  std::cout << "Zufallszahlen!\n";
  std::cout << "\"RAND_MAX\": " << RAND_MAX << "\n\n";
  std::cout << "Zahl 1: " << std::rand() << "\n";
  std::cout << "Zahl 2: " << std::rand() << "\n";
  std::cout << "Zahl 3: " << std::rand() << "\n";
  return 0;
}
 
 

[1kB]

//textfile.cpp
// Beispiel zu Textdateien
 
#include <iostream>
#include <fstream>
 
int main()
{
  std::ifstream idatei;
  std::ofstream odatei;
  std::string   zeile;
 
  //----------------------------------------------------------------------------
  // SCHREIBEN: "test.txt"
  //----------------------------------------------------------------------------
 
    odatei.open("test.txt");
    //Abbrechen, wenn Fehler:
    if (!odatei.good())
    {
      std::cout << "Fehler: Datei kann nicht geoeffnet werden!" << std::endl;
      return -1;
    }
    odatei << "Zeile 1\n";
    odatei << "Zeile 2\n";
    odatei << "Zeile x\n";
    odatei.close();
 
  //----------------------------------------------------------------------------
  // LESEN: "test.txt"
  //----------------------------------------------------------------------------
 
    idatei.open("test.txt");
    //Abbrechen, wenn Fehler:
    if (!idatei.good())
    {
      std::cout << "Fehler: Datei nicht gefunden!" << std::endl;
      return -2;
    }
    while (idatei.good())
    {
      std::getline(idatei, zeile);     //Eine Zeile in "zeile" speichern...
      std::cout << zeile << std::endl; // ...und ausgeben
    }
    idatei.close();
 
  return 0;
}
 

[2kB]

//binfile.cpp
// Beispiel zu Binärdateien
 
#include <iostream>
#include <fstream>
 
int main()
{
  std::ifstream           idatei;
  std::ofstream           odatei;
  std::ifstream::pos_type size;
  char*                   im_ram;   //Ein Pointer auf ein char(-Array)
 
  //----------------------------------------------------------------------------  
  //Eine Binärdatei einlesen,
  // im RAM zwischenspeichern (komplett)
  // und Kopie anlegen
  //----------------------------------------------------------------------------
 
  idatei.open("test.exe", std::ios::in|std::ios::binary|std::ios::ate);
   //Halt irgendeine Datei... (Wir beginnen am Ende ("ate")
  if (idatei.good())
  {
    size=idatei.tellg();            //Größe ermitteln...
    std::clog << "Datei \"test.exe\" ist " << size << "Byte gross!" <<std::endl;
 
    im_ram=new char[size];          //Genug Arbeitsspeicher reservieren
    idatei.seekg(0, std::ios::beg); //An den Anfang... 
    idatei.read(im_ram, size);
 
    if (idatei.good()) std::clog << size << " Byte gelesen!" << std::endl;
    else               std::clog << "Fehler: 0 Byte gelesen!" << std::endl;
    idatei.close();
 
    odatei.open("test2.exe", std::ios::out|std::ios::binary|std::ios::trunc);
    if (odatei.good())
    {
      odatei.write(im_ram,size);
      if (odatei.good()) std::clog << size << " Byte geschrieben!" << std::endl;
      else              std::clog << "Fehler: 0 Byte geschrieben!" << std::endl;
      odatei.close();
    }
    else std::clog << "Fehler: Ausgabedateifehler!" << std::endl;
  }  
  else std::clog << "Fehler: Eingabedateifehler!" << std::endl;
 
  return 0;
}
 

[615B]

//filesize.cpp
// Gibt die Groesse einer Datei aus...
 
#include <iostream>
#include <fstream>
 
int main()
{
  long anfang, ende;
  std::ifstream datei("test.txt");
 
  //Abbrechen, wenn Fehler:
  if (!datei.good())
  {
    std::cout << "Fehler: Datei nicht gefunden!" << std::endl;
    return -1;
  }
 
  //Jetzt Groesse bestimmen:
  anfang=datei.tellg();         //Der Dateianfang
  datei.seekg(0,std::ios::end); //Ans Ende gehen
  ende=datei.tellg();           //Das (Datei-)Ende!
 
  datei.close();
  std::cout << "Datei \"test.txt\" ist " << (ende-anfang)
            << "Byte gross!" << std::endl;
  return 0;
}
 

[689B]

//callback.cpp
// Demonstriert den Einsatz von Funktionszeigern
 
#include <iostream>
#include <cmath>
 
void   ausgeben();
void   beenden ();
double wurzel(int,void bei_fehlern()); //Für reelle Zahlen
 
int main()
{
  //Wurzel aus "-1" ist nicht reell:
  wurzel(-1, ausgeben); //Bei Fehler: Einfach ausgeben
  wurzel(-1, beenden ); //Bei Fehler: Beenden
  return 0;
}
 
void ausgeben()
{
  std::cout << "Es ist ein nicht fataler Fehler aufgetreten!" << std::endl;
}
 
void beenden()
{
  std::cout << "Es ist ein fataler Fehler augetreten!" << std::endl;
  std::exit(-1);
}
 
double wurzel(int wovon, void bei_fehlern())
{
  if (wovon<0) bei_fehlern(); //Aua!
  else return std::sqrt(wovon);
}