ในภาษาซีชาร์ปเราสามารถกำหนดหน้าที่ใหม่ให้แก่ตัวกระทำ (Operator โอเปอร์เรเตอร์) เพื่อให้มันทำงานแตกต่างไปจากการทำงานปรกติที่ถูกกำหนดไว้โดยปริยายได้ เรียกการทำเช่นนี้ว่าโอเปอร์เรเตอร์โอเวอร์โหลดดิง(operator overloading) ภาษาจาวาไม่มีคุณสมบัตินี้ และเราจะทำเช่นนี้ในภาษาซีมาตรฐานก็ไม่ได้เหมือนกัน

เราสามารถโอเวอร์โหลดตัวกระทำได้ทุกชนิด ไม่ว่าจะเป็น ตัวกระทำทางคณิตศาสตร์ (อาทิ + บวก – ลบ * คูณ / หาร) ตัวกระทำทางการเปรียบเทียบ ( อาทิ > มากกว่า < น้อยกว่า == เท่ากับ) ตัวกระทำตรรกแก่บิต (& และ | หรือ) ตัวกระทำที่ต้องการผู้ถูกกระทำ (operand) เพียงตัวเดียว (อาทิ ++ เพิ่มค่า -- ลดค่า) และอื่น ๆ

มีตัวกระทำเพียงไม่กี่แบบที่โอเวอร์โหลดไม่ได้ เช่น ตัวกระทำตรรก && และ || หรือ, ตัวกระทำสำหรับกำหนดดรรชนีของอาร์เรย์ [ ], ตัวกระทำเพื่อการแปลงค่า ( ), ตัวกระทำสร้างออพเจ็กต์ new, และตัวกระทำเพื่อกำหนดค่า = ฯลฯ

 

การโอเวอร์โหลดตัวกระทำ ๆ ได้โดยนิยามเมธอดพิเศษเพื่อการนี้โดยเฉพาะโดยมีโครงสร้างตามที่เห็นในภาพ คือจะต้องเป็นเมธอดที่มีเอ็กเซสโมดิไฟเออร์เป็นแบบพับลิก และเป็นสแตติก คำว่า return_type ในกรณีที่เป็นการโอเวอร์โหลดตัวกระทำแบบเดี่ยว (คือ unary operator อย่าง +, ~, ! และจุด) ให้แทนด้วยค่าส่งกลับซึ่งเป็นชนิดข้อมูลอะไรก็ได้ที่ต้องการ (ยกเว้น void) ในกรณีที่โอเวอร์โหลดตัวกระทำ ++ และ - - ค่าส่งกลับจะต้องเป็นชนิดข้อมูลเดียวกันกับ Type ในวงเล็บ ถ้าต้องการโอเวอร์โหลดตัวกระทำ true หรือ false ท่านจำเป็นจะต้องนิยามเมธอดสองเมธอด เมธอดแรกสำหรับนิยามค่า true และอีกอันสำหรับ false และค่าส่งกลับก็ต้องเป็นแบบบูลีนด้วย หากลืมนิยามให้ครบทั้งสอบแบบจะมีข้อความแจ้งความผิดพลาดตอนคอมไพล์ คำว่า operator ที่อยุ่หลัง return_type ที่เห็นในภาพเป็นคำเฉพาะ (คีย์เวิร์ด keyword) ที่จำเป็นต้องใส่ไว้ในตำแหน่งนั้น ความพิเศษของเมธอดชนิดนี้คือเราไม่ต้องกำหนดชื่อให้กับมัน ตำแหน่งที่ควรจะเป็นชื่อเมธอดกลายเป็นคำว่า op ซึ่งหมายถึงให้ท่านใส่ตัวกระทำที่จะโอเวอร์โหลดไว้ตรงนั้น ยกตัวอย่างเช่น หากท่านต้องการโอเวอร์โหลดตัวกระทำ + ให้ท่านใส่เครื่องหมาย + แทนคำว่า op ถัดมาในวงเล็บคือพารามิเตอร์ หากต้องการโอเวอร์โหลดตัวกระทำแบบเดี่ยว (unary operator ต้องการตัวถูกกระทำตัวเดียว) จะมีพารามิเตอร์หนึ่งตัว หากต้องการโอเวอร์โหลดตัวกระทำแบบคู่ (binary operator ต้องการตัวถูกกระทำสองตัว) ท่านจะต้องใส่พารามิเตอร์สองตัว โดย Type จะต้องเป็นคลาสหรือ struct ที่ท่านนิยามขึ้นเอง

ในโค้ดตัวอย่างการโอเวอร์โหลดตัวกระทำแบบยูนารี
บรรทัดที่ 9 ถึง 32 คือนิยามคลาส Complex ในคลาสนี้จะมีการโอเวอร์โหลดตัวกระทำ – (เครื่องหมายลบ) ให้ทำหน้าที่แปลงข้อมูลของออพเจ็กต์จากเลขจำนวนเต็มบวกเป็นเลขจำนวนเต็มลบ
บรรทัดที่ 11,12 ประกาศสมาชิกแบบฟิลด์ที่จะใช้เป็นตัวเก็บข้อมูล
บรรทัดที่ 13-15 คือนิยามเมธอดคอนสทรักเตอร์ที่เป็นตัวดีฟอลต์
บรรทัดที่ 16-20 คือการทำโอเวอร์โหลดเมธอดคอนสทรักเตอร์เป็นแบบมีพารามิเตอร์สองตัว โดยจะนำค่าจากพารามิเตอร์ทั้งสองนี้ไปกำหนดค่าให้แก่ฟิลด์สมาชิก 

บรรทัดที่ 21-24 คือนิยามเมธอด ShowYX() ซึ่งทำหน้าที่แสดงค่าของฟิลด์สมาชิกที่คอนโซล
บรรทัดที่ 25-31 คือเมธอดที่ทำหน้าที่โอเวอร์โหลดตัวกระทำ – โปรดสังเกตว่าค่าส่งกลับและพารามิเตอร์เป็นชนิดข้อมูลเดียวกันคือ Complex ซึ่งถูกนิยามโดยคลาสนี้
บรรทัดที่ 27 สร้างออพเจ็กต์ (ที่ถูกอ้างถึงโดยตัวแปร) ชื่อ temp
บรรทัดที่ 28-29 นำค่ามาจากพารามิเตอร์คือ x และ y ของ c แล้วเปลี่ยนให้เป็นจำนวนลบ แล้วนำไปใส่ไว้ใน x และ y ของ temp จากนั้นส่งค่ากลับไปด้วยคำสั่ง return

โค้ดตัวอย่างแสดงการใช้งานตัวกระทำที่ถูกโอเวอร์โหลดคือบรรทัดที่ 37 ถึง 42
บรรทัดที่ 37 สร้างออพเจ็กต์ c1 จากคลาส Complex ที่นิยามไว้โดยเรียกคอนสทรักเตอร์แบบมีพารามิเตอร์สองตัวแล้วส่งค่า 10 และ 20 ไป
บรรทัดที่ 38 เรียกหาเมธอด ShowXY() ของออพเจ็กต์ c1 ซึ่งเผยให้เห็นว่าค่า x และ y ของ c1 มีค่าเป็น 10 และ 20 ตามลำดับ

บรรทัดที่ 39 สร้างออพเจ็กต์ c2 จากคลาส Complex ที่นิยามไว้โดยเรียกดีฟอลต์คอนสทรักเตอร์
บรรทัดที่ 40 เรียกหาเมธอด ShowXY() ของออพเจ็กต์ c2 ซึ่งเผยให้เห็นว่าค่า x และ y ของ c2 มีค่าเป็น 0 และ 0 ตามลำดับ

บรรทัดที่ 41 แสดงการเรียกใช้ตัวกระทำ – ที่ถูกโอเวอร์โหลดไว้ในคลาส Complex ซึ่งจะมีผลให้โค้ดบรรทัด 27-30 ทำงาน เมื่อสั่งให้แสดงค่าของ x และ y โดยเรียกเมธอด ShowXY()
บรรทัดที่ 42 จะพบว่าค่าของ x และ y จะเป็น -10 และ -20 ตามลำดับ

การโอเวอร์โหลดตัวกระทำแบบที่มีตัวถูกกระทำสองฝั่งหรือ binary operator มีโครงสร้างนิยามอย่างที่เห็นในภาพ จะเห็นว่าเหมือนกับโครงสร้างนิยามของการโอเวอร์โหลดตัวกระทำแบบที่มีตัวถูกกระทำฝั่งเดียวหรือ unary operator เกือบทุกประการยกเว้นในวงเล็บจะมีพารามิเตอร์เพิ่มขึ้นมาอีกหนึ่งตัว คือ Type2 ข้อกำหนดของโครงสร้างนิยามการโอเวอร์โหลดตัวกระทำแบบที่มีตัวถูกกระทำสองฝั่งคือจะต้องมีพารามิเตอร์อย่างน้อยหนึ่งตัวเป็นชนิดข้อมูลแบบคลาสหรือ struct
ขณะที่ return_type จะเป็นชนิดข้อมูลอะไรก็ได้ (ยกเว้น void) 

ในโค้ดตัวอย่างการแสดงการโอเวอร์โหลดตัวกระทำแบบไบนารีจะคล้ายกับตัวอย่างก่อนหน้านี้
บรรทัดที่ 9 ถึง 31 คือนิยามคลาส Complex ที่มีการโอเวอร์โหลดตัวกระทำ + (เครื่องหมายบวก) ให้ทำหน้าที่นำฟิลด์สองฟิลด์ (x และ y) จากออพเจ็กต์หนึ่งมาบวกกับ x และ y ในอีกออพเจ็กต์หนึ่ง

บรรทัดที่ 11,12 ประกาศสมาชิกแบบฟิลด์ที่จะใช้เป็นตัวเก็บข้อมูล
บรรทัดที่ 13 คือนิยามเมธอดคอนสทรักเตอร์ที่เป็นตัวดีฟอลต์
บรรทัดที่ 15-19 คือการทำโอเวอร์โหลดเมธอดคอนสทรักเตอร์เป็นแบบมีพารามิเตอร์สองตัว โดยจะนำค่าจากพารามิเตอร์ทั้งสองนี้ไปกำหนดค่าให้แก่ฟิลด์สมาชิก 

บรรทัดที่ 20-23 คือนิยามเมธอด ShowYX() ซึ่งทำหน้าที่แสดงค่าของฟิลด์สมาชิกที่คอนโซล
บรรทัดที่ 24-30 คือเมธอดที่ทำหน้าที่โอเวอร์โหลดตัวกระทำ + โปรดสังเกตว่าค่าส่งกลับและพารามิเตอร์ทั้งสองตัวเป็นชนิดข้อมูลเดียวกันคือ Complex ซึ่งถูกนิยามโดยคลาสนี้
บรรทัดที่ 26 สร้างออพเจ็กต์ (ที่ถูกอ้างถึงโดยตัวแปร) ชื่อ temp
บรรทัดที่ 27-28 นำค่ามาจากพารามิเตอร์ x และ y ของ c1 แล้วนำไปบวกกับพารามิเตอร์ x และ y ของ c2 แล้วนำไปใส่ไว้ใน x และ y ของ temp จากนั้นส่งค่ากลับไปด้วยคำสั่ง return

โค้ดตัวอย่างแสดงการใช้งานตัวกระทำที่ถูกโอเวอร์โหลดคือบรรทัดที่ 36 ถึง 42
บรรทัดที่ 36 สร้างออพเจ็กต์ c1 จากคลาส Complex ที่นิยามไว้โดยเรียกคอนสทรักเตอร์แบบมีพารามิเตอร์สองตัวแล้วส่งค่า 10 และ 20 ไป
บรรทัดที่ 37 เรียกหาเมธอด ShowXY() ของออพเจ็กต์ c1 ซึ่งเผยให้เห็นว่าค่า x และ y ของ c1 มีค่าเป็น 10 และ 20 ตามลำดับ
บรรทัดที่ 38 สร้างออพเจ็กต์ c2 จากคลาส Complex ที่นิยามไว้โดยเรียกคอนสทรักเตอร์แบบมีพารามิเตอร์สองตัวแล้วส่งค่า 10 และ 20 ไป
บรรทัดที่ 39 เรียกหาเมธอด ShowXY() ของออพเจ็กต์ c2 ซึ่งเผยให้เห็นว่าค่า x และ y ของ c2 มีค่าเป็น 20 และ 30 ตามลำดับ
บรรทัดที่ 41 แสดงการเรียกใช้ตัวกระทำ + ที่ถูกโอเวอร์โหลดไว้ในคลาส Complex ซึ่งจะมีผลให้โค้ดบรรทัด 26-29 ทำงาน เมื่อสั่งให้แสดงค่าของ x และ y โดยเรียกเมธอด ShowXY()
บรรทัดที่ 42 จะพบว่าค่าของ x และ y จะเป็น 30 และ 50 ตามลำดับ

ข้อควรระวังในการโอเวอร์โหลดตัวกระทำคือผลของมันจะตกทอดไปสู่คลาสอนุพันธ์ด้วยทั้ง ๆ ที่เรากำหนดนิยามของมันไว้เป็น static แล้ว  และคลาสอนุพันธ์จะซ่อนหรือทับการทำโอเวอร์โหลดในเบสคลาสไม่ได้ 

ในตัวอย่างโค้ดแสดงการสืบคุณสมบัติตัวกระทำยูนารี + (เครื่องหมายบวก) ที่ถูกโอเวอร์โหลดไว้ในเบสคลาส เรานิยามคลาส FooComplex ซึ่งสืบคุณสมบัติจาก Complex
จึงได้รับคุณสมบัติตัวกระทำยูนารี + ที่ถูกโอเวอร์โหลดไว้ในคลาส Complex มาด้วยโดยอัตโนมัติ

 

จากในโค้ดตัวอย่างแสดงการใช้งานคลาส FooComplex จะเห็นว่าเราสร้างออพเจ็กต์สองตัวคือ mc1 และ mc2 จากคลาส FooComplex แต่เนื่องจากในคลาสนี้เราไม่ได้ทำโอเวอร์โหลดตัวกระทำ + ไว้ (และจะทำไม่ได้เพราะเบสคลาสทำไว้แล้ว) โค้ดบรรทัด 57 จะคอมไพล์ไม่ผ่าน นั่นคือเราไม่มีทางที่จะใช้ตัวกระทำ + กับออพเจ็กต์ที่เป็นชนิดข้อมูล FooComplex ได้อีก

ภาษาซีชาร์ปสนับสนุนพอยน์เตอร์อย่างเต็มรูปแบบ สภาพการณ์อย่างนี้ไม่ปรากฏในภาษาอื่นใดเลยนอกจากซีและซีพลัสพลัส ทำให้มันเป็นภาษาเดียว  (ซึ่งมาหลังซีพลัสพลัส)  ที่สามารถใช้พอยน์เตอร์ได้ และหากใช้อย่างเหมาะสมจะมีผลให้ประสิทธิภาพของแอพเพิ่มขึ้นได้ ที่ว่าสนับสนุนอย่างเต็มรูปแบบหมายถึงสนับสนุนคุณสมบัติต่าง ๆ โดยครบถ้วนไม่ใช่สนับสนุนอย่างครึ่ง ๆ กลาง ๆ นั่นคือเราเขียนโค้ดในภาษาซีและซีพลัสพลัสให้พอยน์เตอร์ทำสิ่งต่าง ๆ ได้อย่างไรเราก็สามารถเขียนในภาษาซีชาร์ปได้อย่างนั้นเช่นเดียวกัน ไม่ว่าจะเป็นการกระทำทางคณิตศาสตร์กับพอยน์เตอร์ การใช้พอยน์เตอร์เพื่ออ้างถึงตำแหน่งข้อมูลในหน่วยความจำ การใช้พอยน์เตอร์ร่วมกับอาร์เรย์ ไล่เรื่อยไปจนถึงเทคนิคที่ซับซ้อนขึ้นเช่นใช้พอยน์เตอร์เพื่อเก็บตำแหน่งของพอยน์เตอร์หรือการทำงานกับอาร์เรย์ของพอยน์เตอร์

พอยน์เตอร์เป็นชนิดข้อมูลแบบพิเศษที่เพิ่มขึ้นจากสองประเภทหลัก คือ แวลูไทป์ (value type) และรีเฟอร์เรนซ์ไทป์ (reference type) ส่วนพอยน์เตอร์เป็นชนิดข้อมูลชื่อ พอยน์เตอร์ไทป์ (pointer type) ชนิดข้อมูลแบบแวลูไทป์ทำหน้าที่เก็บข้อมูลโดยตรง เช่น int k = 123; ตัวแปร k จะมีค่า 123 เก็บอยู่ ส่วนชนิดข้อมูลแบบรีเฟอร์เรนซ์ไทป์ทำหน้าที่เก็บตัวอ้างอิงที่อ้างไปยังข้อมูล เช่น string s = “hello” ตัวแปร s ทำหน้าที่เก็บค่าอ้างอิงไปยังตำแหน่งที่เก็บข้อความว่า hello ในตัวแปร s ไม่ได้เก็บตัวชุดอักษร hello ส่วนชนิดข้อมูลแบบพอยน์เตอร์ทำหน้าที่เก็บเลขระบุตำแหน่งในหน่วยความจำของคอมพิวเตอร์ แนวคิดเรื่องพอยน์เตอร์มาจากภาษาเครื่อง (machine language) เพราะภายในซีพียูทุกตัวมีรีจิสเตอร์ (register) ที่ถูกกำหนดให้ทำหน้าที่เก็บค่าอ้างอิงไปยังตำแหน่งในหน่วยความจำ บางซีพียูมีรีจิสเตอร์แบบนี้หลายตัวและมีเทคนิคการอ้างถึงตำแหน่งในหน่วยความจำ (addressing technique) ได้หลายกลวิธี เมื่อภาษาซีถูกสร้างขึ้นจึงกำหนดให้มีพอยน์เตอร์เพื่อให้สามารถคอมไพล์ได้ลงรอยกับภาษาเครื่อง ภาษาซีและภาษาซีพลัสพลัส ที่แม้จะเป็นภาษาระดับสูงกว่าภาษาเครื่องหนึ่งชั้น แต่นักเขียนโค้ดยังคงมีจิตใจที่ยึดมั่นกับฮาร์ดแวร์อยู่มาก จึงเขียนโค้ดโดยใช้พอยน์เตอร์เป็นกำลังสำคัญ ขณะที่นักเขียนโค้ดภาษาซีชาร์ปส่วนใหญ่จิตหลุดพ้นจากฮาร์ดแวร์แล้ว จึงเขียนโด้ดตามคตินามธรรมโดยบริสุทธิ์ใจ ซึ่งการเขียนโค้ดแบบนี้ไม่มีความจำเป็นต้องใช้พอยน์เตอร์ เพราะสามารถใช้รีเฟอร์เรนซ์ไทป์ทดแทนได้อย่างสมบูรณ์

 

ในโค้ดตัวอย่างแสดงการประกาศและใช้งานพอยน์เตอร์บรรทัดที่ 8 ถึง 11 เป็นนิยามเมธอด Foo ซึ่งเป็นเมธอดที่มีการใช้งานพอยน์เตอร์ คำว่า unsafe ที่อยู่ข้างหน้าเมธอดเป็นคำสั่งที่จะต้องใส่ไว้ก่อนหน้าชุดคำสั่งที่ใช้งานพอยน์เตอร์ การใส่ unsafe ไม่ได้หมายความว่าโค้ดที่ตามมาจะไม่ปลอดภัย แต่หมายถึงตัวรันทามน์จะไม่ดูแลรักษาความปลอดภัยให้ คงเป็นหน้าที่ของผู้เขียนโค้ดที่จะต้องรับผิดชอบเรื่องนี้ด้วยตนเอง ในวงเล็บของส่วนประกาศเมธอด
บรรทัดที่ 8 กำหนดให้มีพารามิเตอร์ตัวเดียวชื่อ p เป็นชนิดพอยน์เตอร์แบบเลขจำนวนเต็ม
บรรทัดที่ 10 คือโค้ดตัวอย่างแสดงการทำงานของพอยน์เตอร์โดยนำค่าที่อ้างอิงด้วย p มาบวกเข้ากับจำนวน 2 โปรดสังเกตว่าเมธอดนี้ไม่มีค่าส่งกลับเพราะไม่จำเป็นต้องส่งอะไรกลับ ผลลัพธ์ของการบวกจะถูกเขียนลงไปยังหน่วยความจำตำแหน่งที่ p ชี้อยู่โดยตรง
บรรทัดที่ 14 ถึง 20 แสดงวิธีเรียกใช้เมธอด Foo
บรรทัดที่ 16 ใส่คำสั่ง unsafe ตามด้วยวงเล็บปีกกาเปิดและปิด บรรทัดคำสั่งต่าง ๆ ที่อยู่ระหว่างวงเล็บปีกกาเปิดและปิดเป็นคำสั่งที่จะมีการใช้งานพอยน์เตอร์ อาร์กิวเมนต์ของการเรียกเมธอด Foo
บรรทัดที่ 18 ใช้เครื่องหมาย & นำหน้าตัวแปร i เพื่อระบุว่าเราต้องการส่งค่าตำแหน่งหน่วยความจำของตัวแปร i ไปให้ Foo ไม่ใช่ค่าของ i (เลข 5)
บรรทัดที่ 20 จะได้ผลลัพธ์เป็น 7 เพราะในบรรทัด 10 เรานำสิ่งที่เก็บอยู่ในตำแหน่งหน่วยความจำของตัวแปร i (คือจำนวน 5) มาบวกกับจำนวน 2 แล้วนำไปเก็บยังที่เดิม ค่าของตัวแปร i จึงกลายเป็น 7 เรื่องการใช้พอยน์เตอร์ในภาษาซีชาร์ปยังมีแง่มุมที่น่าสนใจอีกหลายอย่างที่จะนำเสนอในตอนต่อไป