Entwickler-Ecke :: Thema anzeigen - Allgemeines Stack Problem(Code)

zero_x - Di 05.02.08 16:30
Titel: Allgemeines Stack Problem(Code)

Hallo liebe Community!,

Ich hab hier mal einen Code den ich nicht versteh.

C#-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:

using System;
using System.Collections.Generic;
using System.Text;

namespace StackDemo
{
    public class Stack<T>
    {
        private T[] elements; // Speicher
        private int top;      // Füllstand

        public Stack(int size)
        {
            // lege Speicher neu an
            this.elements = new T[size];

            // initialisiere Füllstand
            this.top = 0;
        }

        // lege ein neues Element auf den Stack
        public bool Push(T newObject)
        {
            if (this.top < this.elements.Length)
            {
                this.elements[this.top++] = newObject;
                return true;
            }

            return false;
        }

        // hole ein Elemente vom Stack
        public T Pop()
        {
            if (this.top == 0)
                return default(T);

            return this.elements[--this.top];
        }
    }
}

Genau geht es um folgende Zeilen die ich nicht versteh:

C#-Quelltext

1:
2:
3:
4:
5:

public class Stack<T> // Zeile 7
this.elements = new T[size]; // Zeile 15
public bool Push(T newObject) // Zeile 22
public T Pop() // Zeile 34
return default(T); // Zeile 37

In den Zeilen sind überall ein T dabei. Was versteh ich unter dem T?

Ich wäre sehr erfreut über die Hilfe von Euch! :)

MfG
Zer0_x

Christian S. - Di 05.02.08 17:04

"Allgemeines Stack Problem"? :gruebel: Dein Problem scheint mehr zu sein, dass Du Generics [http://www.galileocomputing.de/openbook/visual_csharp/visual_csharp_07_003.htm#Xxxobkap07003040018421f02c186] nicht kennst.

Am Besten liest Du den Text, den ich verlinkt habe. Kurz gesagt, steht das "T" für einen beliebigen Datentypen. Man könnte die Stack-Klasse nun so instanzieren:

C#-Quelltext

1:	Stack<int> intStack = new Stack<int>(5);

Dann hättest Du einen Stack aus Integer-Zahlen. Am Besten verstehst Du das, wenn Du einfach mal in Deinem Quellcode alle "T"s durch "int"s ersetzt und dann schaust, was der Code macht. Mit "T" macht er dann genau das gleiche, nur bezogen auf einen beliebigen Datentypen!

zero_x - Do 07.02.08 16:06

@Christian S.: Das hab ich wohl gesucht, aber auch nicht richitg verstanden.

Nehmen wir mal einen anderen Script:

C#-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:

using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApplication1
{
    class TestGenericList
    {
        static void Main()
        {
            // int is the type argument
            GenericList<int> list = new GenericList<int>();

            for (int x = 0; x < 10; x++)
            {
                list.AddHead(x);
            }

            foreach (int i in list)
            {
                System.Console.Write(i + " ");
            }
            System.Console.WriteLine("\nDone");
        }
    }

    // type parameter T in angle brackets
    public class GenericList<T>
    {
        // The nested class is also generic on T.
        private class Node
        {
            // T used in non-generic constructor.
            public Node(T t)
            {
                next = null;
                data = t;
            }

            private Node next;
            public Node Next
            {
                get { return next; }
                set { next = value; }
            }

            // T as private member data type.
            private T data;

            // T as return type of property.
            public T Data
            {
                get { return data; }
                set { data = value; }
            }
        }

        private Node head;

        // constructor
        public GenericList()
        {
            head = null;
        }

        // T as method parameter type:
        public void AddHead(T t)
        {
            Node n = new Node(t);
            n.Next = head;
            head = n;
        }

        public IEnumerator<T> GetEnumerator()
        {
            Node current = head;

            while (current != null)
            {
                yield return current.Data;
                current = current.Next;
            }
        }
    }
}

Ich versteh das so das in der 12. Zeile eine Liste Names 'List' angelegt wird. Dann wird durch eine For-Schleife AddHead druchlaufen was den Parameter x übergibt. In der AddHead Methode wird das übergebend x zu einen t.

Nun die erste zweischen-Frage: Was hast es mit den großen T aufsich?

Nun wird ein Objekt von Node mit n instanziert. Nun wird in der 44. Zeile die Variable next mit den übergebenden Paramter überschrieben. Die Variable(Zeile 71) head wird zu n. Und das geht dann so die ganze Zeit lang.

Dann wird wieder mit einer zweiten foreach-Schleife die Werte wieder ausgegeben...

Hab ich das so alles richitig verstanden? :shock:

Christian S. - Do 07.02.08 19:05