索引 操作符 指针
一：数组索引器
如果用foreach的话，需要从IEnumerable继承
public class PeopleCollection : IEnumerable
而且需要重载
IEnumerator IEnumerable.GetEnumerator()
{ return arPeople.GetEnumerator(); }
public class Person
{
public int Age;
public string FirstName, LastName;
public Person() { }
public Person(string firstName, string lastName, int age)
{
Age = age;
FirstName = firstName;
LastName = lastName;
}
public override string ToString()
{
return string.Format("Name: {0} {1}, Age: {2}", FirstName, LastName, Age);
}
}
public class PeopleCollection// : IEnumerable（使用FOREACH时会用到）
{
private ArrayList arPeople = new ArrayList();
public PeopleCollection() { }
public Person this[int index]
{
get { return (Person)arPeople[index]; }
set { arPeople.Insert(index, value); }
}
public Person GetPerson(int pos)
{ return (Person)arPeople[pos]; }
public void AddPerson(Person p)
{ arPeople.Add(p); }
public void ClearPeople()
{ arPeople.Clear(); }
public int Count
{ get { return arPeople.Count; } }
//IEnumerator IEnumerable.GetEnumerator()（使用FOREACH时会用到）
//{ return arPeople.GetEnumerator(); }
}
static void Main(string[] args)
{
Console.WriteLine("***** Fun with Indexers *****/n");
PeopleCollection myPeople = new PeopleCollection();
myPeople[0] = new Person("Homer", "Simpson", 40);
myPeople[1] = new Person("Marge", "Simpson", 38);
myPeople[2] = new Person("Lisa", "Simpson", 9);
myPeople[3] = new Person("Bart", "Simpson", 7);
myPeople[4] = new Person("Maggie", "Simpson", 2);
//foreach(Person p in myPeople)如果用FOREACH的话，需要加IEnumerable
//{
// Console.WriteLine("Name: {0} {1}", p.FirstName, p.LastName);
// Console.WriteLine("Age: {0}", p.Age);
// Console.WriteLine();
//}
//等价于
//IEnumerator enum1 = myPeople.GetEnumerator();
//do
//{
// string enum2 = (string)enum1.get_Current(); // 冗余转换
// Console.WriteLine(item);
//} while(enum1.MoveNext());
//((IDisposable)enum1).Dispose();
for (int i = 0; i < myPeople.Count; i++)
{
Console.WriteLine("Person number: {0}", i);
Console.WriteLine("Name: {0} {1}", myPeople[i].FirstName, myPeople[i].LastName);
Console.WriteLine("Age: {0}", myPeople[i].Age);
Console.WriteLine();
}
Console.ReadLine();
}
二：Sting 中的索引，
如果是String作为索引标识的话，则需要用Dictionary而非ArrayList。
public class PeopleCollection : IEnumerable
{
private Dictionary<string, Person> listPeople = new Dictionary<string, Person>();
public Person this[string name]
{
get { return listPeople[name]; }
set { listPeople[name] = value; }
}
public PeopleCollection() { }
public void ClearPeople()
{ listPeople.Clear(); }
public int Count
{ get { return listPeople.Count; } }
IEnumerator IEnumerable.GetEnumerator()
{ return listPeople.GetEnumerator(); }
}
static void Main(string[] args)
{
PeopleCollection myPeople = new PeopleCollection();
myPeople["Homer"] = new Person("Homer", "Simpson", 40);
myPeople["Marge"] = new Person("Marge", "Simpson", 38);
Person p = myPeople["Homer"];
Console.WriteLine(p);
p = myPeople["Marge"];
Console.WriteLine(p);
Console.ReadLine();
}
三：多维函数的处理
public class SomeContainer
{
private int[,] my2DintArray = new int[10, 10];
public int this[int row, int column]
{
get { return my2DintArray[row, column]; }
set { my2DintArray[row, column] = value; }
}
}
class Program
{
static void Main(string[] args)
{
SomeContainer sc = new SomeContainer();
sc[2, 3] = 5;
Console.WriteLine(sc[2, 3].ToString());
}
}
四：操作符重载，以Point为例
public struct Point : IComparable
{
private int x, y;
public Point(int xPos, int yPos)
{
x = xPos; y = yPos;
}
public override string ToString()
{
return string.Format("[{0}, {1}]", this.x, this.y);
}
public override bool Equals(object o)
{
return o.ToString() == this.ToString();
}
public override int GetHashCode()
{
return this.ToString().GetHashCode();
}
public static Point operator +(Point p1, Point p2)
{
return new Point(p1.x + p2.x, p1.y + p2.y);
}
public static Point operator +(Point p1, int change)
{
return new Point(p1.x + change, p1.y + change);
}
public static Point operator +(int change, Point p1)
{
return new Point(p1.x + change, p1.y + change);
}
public static Point operator -(Point p1, Point p2)
{
return new Point(p1.x - p2.x, p1.y - p2.y);
}
public static Point operator ++(Point p1)
{
return new Point(p1.x + 1, p1.y + 1);
}
public static Point operator --(Point p1)
{
return new Point(p1.x - 1, p1.y - 1);
}
public static bool operator <(Point p1, Point p2)
{
return (p1.CompareTo(p2) < 0);
}
public static bool operator >(Point p1, Point p2)
{
return (p1.CompareTo(p2) > 0);
}
public static bool operator <=(Point p1, Point p2)
{
return (p1.CompareTo(p2) <= 0);
}
public static bool operator >=(Point p1, Point p2)
{
return (p1.CompareTo(p2) >= 0);
}
public static bool operator ==(Point p1, Point p2)
{
return p1.Equals(p2);
}
public static bool operator !=(Point p1, Point p2)
{
return !p1.Equals(p2);
}
public int CompareTo(object obj)
{
if (obj is Point)
{
Point p = (Point)obj;
if (this.x > p.x && this.y > p.y)
return 1;
if (this.x < p.x && this.y < p.y)
return -1;
else
return 0;
}
else
throw new ArgumentException();
}
}
static void Main(string[] args)
{
Point ptOne = new Point(100, 100);
Point ptTwo = new Point(40, 40);
Console.WriteLine("ptOne = {0}", ptOne);
Console.WriteLine("ptTwo = {0}", ptTwo);
Console.WriteLine("ptOne + ptTwo: {0} ", ptOne + ptTwo);
Console.WriteLine("ptOne - ptTwo: {0} ", ptOne - ptTwo);
Point biggerPoint = ptOne + 10;
Console.WriteLine("ptOne + 10 = {0}", biggerPoint);
Console.WriteLine("10 + biggerPoint = {0}", 10 + biggerPoint);
Point ptThree = new Point(90, 5);
Console.WriteLine("ptThree = {0}", ptThree);
Console.WriteLine("ptThree += ptTwo: {0}", ptThree += ptTwo);
Point ptFour = new Point(0, 500);
Console.WriteLine("ptFour = {0}", ptFour);
Console.WriteLine("ptFour -= ptThree: {0}", ptFour -= ptThree);
Point ptFive = new Point(1, 1);
Console.WriteLine("++ptFive = {0}", ++ptFive); // [2, 2]
Console.WriteLine("--ptFive = {0}", --ptFive); // [1, 1]
Point ptSix = new Point(20, 20);
Console.WriteLine("ptSix++ = {0}", ptSix++); // [20, 20]
Console.WriteLine("ptSix-- = {0}", ptSix--); // [21, 21]
Console.WriteLine("ptOne == ptTwo : {0}", ptOne == ptTwo);
Console.WriteLine("ptOne != ptTwo : {0}", ptOne != ptTwo);
Console.WriteLine("ptOne < ptTwo : {0}", ptOne < ptTwo);
Console.WriteLine("ptOne > ptTwo : {0}", ptOne > ptTwo);
}
五：转换，隐式转换和显示转换
public struct Rectangle
{
public int Width, Height;
public Rectangle(int w, int h)
{
Width = w; Height = h;
}
public override string ToString()
{
return string.Format("[Width = {0}; Height = {1}]", Width, Height);
}
//将Square转换成Rectangle
public static implicit operator Rectangle(Square s)
{
Rectangle r;
r.Height = s.Length;
r.Width = s.Length * 2;
return r;
}
}
public struct Square
{
public int Length;
public Square(int l)
{
Length = l;
}
public override string ToString()
{
return string.Format("[Length = {0}]", Length);
}
//将Rectangle转换成Square
public static explicit operator Square(Rectangle r)
{
Square s;
s.Length = r.Height;
return s;
}
//将int转换成Square
public static implicit operator Square(int sideLength)
{
Square newSq;
newSq.Length = sideLength;
return newSq;
}
//将Square转换成int
public static explicit operator int(Square s)
{
return s.Length;
}
}
static void Main(string[] args)
{
Rectangle r = new Rectangle(15, 4);
Square s = (Square)r;
Rectangle rect = new Rectangle(10, 5);
Square sq2 = (Square)90;
int side = (int)sq2;
//implicit
Square s3;
s3.Length = 7;
Rectangle rect2 = s3;
//explicit
Square s4;
s4.Length = 3;
Rectangle rect3 = (Rectangle)s4;
}
六：不安全代码设置，unsafe
public unsafe struct Node
{
public int Value;
public Node* Left;
public Node* Right;
}
public struct Node2
{
public int Value;
public unsafe Node2* Left;
public unsafe Node2* Right;
}
struct Point
{
public int x;
public int y;
public override string ToString()
{
return string.Format("({0}, {1})", x, y);
}
}
class PointRef
{
public int x;
public int y;
public override string ToString()
{
return string.Format("({0}, {1})", x, y);
}
}
class Program
{
static void Main(string[] args)
{
int i = 10, j = 20;
SafeSwap(ref i, ref j);
unsafe
{
UnsafeSwap(&i, &j);
}
UsePointerToPoint();
UseSizeOfOperator();
}
public static void SafeSwap(ref int i, ref int j)
{
int temp = i;
i = j;
j = temp;
}
unsafe public static void UnsafeSwap(int* i, int* j)
{
int temp = *i;
*i = *j;
*j = temp;
}
unsafe static void PrintValueAndAddress()
{
int myInt;
int* ptrToMyInt = &myInt;
*ptrToMyInt = 123;
Console.WriteLine("Value of myInt {0}", myInt);
Console.WriteLine("Address of myInt {0:X}", (int)&ptrToMyInt);
}
unsafe static void SquareIntPointer(int* myIntPointer)
{
*myIntPointer *= *myIntPointer;
}
unsafe static void UsePointerToPoint()
{
Point point;
Point* p = &point;
p->x = 100;
p->y = 200;
Console.WriteLine(p->ToString());
Point point2;
Point* p2 = &point2;
(*p2).x = 100;
(*p2).y = 200;
Console.WriteLine((*p2).ToString());
}
//C#提供一个的关键字stackalloc用于申请堆栈内存。
//注意，这个申请内存分配的是栈内存，当函数执行完毕后，内存会被自动回收。
//不过我想用这个栈内存基本可以解决40％的问题，而且使用的时候不必担心内存泄漏问题。
unsafe static void UnsafeStackAlloc()
{
char* p = stackalloc char[256];
for (int k = 0; k < 256; k++)
p[k] = (char)k;
}
unsafe public static void UseAndPinPoint()
{
PointRef pt = new PointRef();
pt.x = 5;
pt.y = 6;
fixed (int* p = &pt.x)
{
// Use int* variable here!
}
Console.WriteLine("Point is: {0}", pt);
}
unsafe static void UseSizeOfOperator()
{
Console.WriteLine("The size of short is {0}.", sizeof(short));
Console.WriteLine("The size of int is {0}.", sizeof(int));
Console.WriteLine("The size of long is {0}.", sizeof(long));
Console.WriteLine("The size of Point is {0}.", sizeof(Point));
}
}