// Solutions to "Richard Kaiser: C++ with Borland C++Builder", ISBN: 3540010270
// Copyright Richard Kaiser, 2004, All rights reserved
// oder doch besser weglassen ???


// --------------- Aufgaben 1 und 2 ------------------------
#include "CQuadrat.h"
#include "CKreis.h"

// "CQuadrat.cpp" und ??? "CKreis.cpp" werden mit "Projekt|Dem Projekt
// hinzufügen" dem Projekt hinzugefügt

void Aufg1_2()
{
Quadrat q(10);
Form1->Memo1->Lines->Add(q.toStr());
Form1->Memo1->Lines->Add(q.Umfang());
Form1->Memo1->Lines->Add(q.Flaeche());
Quadrat* pq=new Quadrat(10);
Form1->Memo1->Lines->Add(pq->toStr());
Form1->Memo1->Lines->Add(pq->Umfang());
Form1->Memo1->Lines->Add(pq->Flaeche());

Kreis k(10);
Form1->Memo1->Lines->Add(k.toStr());
Form1->Memo1->Lines->Add(k.Umfang());
Form1->Memo1->Lines->Add(k.Flaeche());
Kreis* pk=new Kreis(10);
Form1->Memo1->Lines->Add(pk->toStr());
Form1->Memo1->Lines->Add(pk->Umfang());
Form1->Memo1->Lines->Add(pk->Flaeche());
}


// --------------- Aufgaben 3 ------------------------------

void Aufg_3()
{
/*
3. Bei der Änderung einer Klassendefinition (also insbesondere der in der
   Klasse definierten inline-Funktion) muss der Compiler alle Dateien
   übersetzen, die diese Datei mit #include verwenden.

   Wenn dagegen die Funktionsdefinition einer außerhalb der Klasse
   definierten Funktion geändert wird, muss nur diese Datei neu kompiliert
   werden.

   Dieser geringere Aufwand beim Kompilieren hat allerdings eine längere
   Laufzeit des Programms zur Folge, da die Funktionen dann nicht mehr
   inline sind.

   Auch wenn diese Überlegungen prinzipiell eher gegen als für inline-
   Funktionen sprechen, können diese Nachteile oft vernachlässigt werden.
   Bei inline-Funktionen mit wenig Anweisungen kann der bei einer Expansion
   erzeugte Code sogar kleiner sein als der für einen Funktionsaufruf.
*/
}

// --------------- Aufgaben 4 ------------------------------

class CountNew {
  static int count_;
 public:
  static int count() { return count_; }

  void* operator new(size_t size)
  {
   count_++;
   return ::new C;
  };
  void* operator new[](size_t size)
  {
    count_++;
    return ::operator new(size);
  };
  void operator delete(void *p)
  {
   count_--;
    ::delete(p);
  };
  void operator delete[](void *p)
  {
    count_--;
    ::delete[](p);
  };
};

int CountNew::count_=0;

void Aufg_4()
{
CountNew* p1=new CountNew;
delete p1;

CountNew* p2=new CountNew[10];
delete[] p2;
}


// --------------- Aufgaben 5 ------------------------------

class Singleton {
  static Singleton* instance_;
 public:
  static Singleton* Instance();
  int data; // besser private und Zugriffsfunktionen
 private: // protected, falls Singleton als Basisklasse verwendet werden soll
  Singleton(){data=17;};
};

Singleton* Singleton::Instance()
{
  if (instance_==0)
    instance_=new Singleton();
  return instance_;
};

Singleton* Singleton::instance_=0;

Singleton* p1=Singleton::Instance();

void Aufg_Singleton()
{
Singleton* p2=Singleton::Instance();
// p2->data=19;
Form1->Memo1->Lines->Add(IntToStr(p1->data)); // p1->data=19
// falls p1 ein gewöhnliches globales Objekt wäre, hätte die
// globale Variable den Wert 17
}

