Templates??

Kort? Ok: http://www.4p8.com/eric.brasseur/cppcen.html#l13

Hvis har jeg forstået det rigtigt, så er en template en række funktioner med samme navn, hvor funktionerne kan optræde som forskellige typer?
Er det rigtigt?

Jeps. det må vøre den lange forklaring ;-) De hedder også polymorfi. De moderne
oversættere kan ovenikøbet finde ud af at oversætte det korrekt. Der var en tidlig
C++ oversætter fra Borland, som gik helt i kage hvis der var for mange templates -
noget med en 64kB grænse.

(Du mener nok: "hvor *parametrene* kan optræde som forskellige typer":)

Imidlertid er jeg ikke i stand til at sige præcis hvad din kodestump betyder. Det
er noget med en API funktion, som henter en eller anden standard information i Windows,
og så afleverer den i en ønsket type T. Formentlig fordi den nogle gange skal fortolkes
som tal, nogle gange som en pointer.

Templates er ganske rigtigt -som navnet siger- en slags skabelons-klasse, hvor man kan lave sine definitioner, funktioner osv. helt uafhængigt af hvilken data type der siden skal "stoppes ned" i den. I mange lærebøger betegnes templates som den tekniske måde at lave ADT-Abstract Data Types på.

Fra C++ Builder har jeg fundet:

template <class T> class Vector
{
  T *data;
  int size;
public:
  Vector(int);
  ~Vector( ) { delete[ ] data; }
  T& operator[ ] (int i) { return data[i]; }
};
template <class T> Vector<T>::Vector(int n)
{
  data = new T[n];
  size = n;
};

int main()
{
  Vector<int> x(5);  // Generate a vector to store five integers
  for (int i = 0; i < 5; ++i)
      x[i] = i;              //  Initialize the vector.

  return o;

}

Standard eksemplet på en ADT er en (FIFO) stak - her en til int's og en til char's:

template <class T> class Stack
{
  T        *pStack;
  int      nTop;
  int      nSize;

  public:
  Stack(int n);
  ~Stack( ) { delete[] pStack; }

  // Functions.
  bool      Empty(void)  {
                          return nTop == 0;
                        } // Empty
  int      Top(void)    {
                          return nTop;
                        } // Top
  int      Size(void)  {
                          return nSize;
                        } // Size
  T        Pop(void)    { if (nTop > 0)
                            nTop--;
                          return pStack[nTop];
                        } // Pop
  void      Push(T v)    {
                          pStack[nTop] = v;
                          if (nTop < nSize)
                            nTop++;
                        } // Push
};
template <class T> Stack<T>::Stack(int n)
{
  pStack = new T[n];
  nSize  = n;
  nTop  = 0;
} // Constructor

int main()
{
  Stack<int>  intX(10);
  Stack<char> charX(26);
  int        i;

  // Integer stack.
  for (i = 0; i < intX.Size(); ++i)
    intX.Push(i+1);
  while (!intX.Empty())
    cprintf("%02d,  ", intX.Pop());
  cprintf("\r\n");

  // Character stack.
  for (i = 0; i < charX.Size(); ++i)
    charX.Push((char)('A'+i));
  while (!charX.Empty())
    cprintf("%d, ", charX.Pop());
  cprintf("\r\n");

  // Leave input on screen until key pressed.
  getch();
  return 0;
} // Stack example.

Programmet udskriver -pga. FIFO princippet- først 10, 9, ..., 2, 1 og dernæst Z, Y, X ... A.