c# structs, operator overloading & attributes. structs ~ structures structs are similar to...
Post on 20-Dec-2015
253 views
TRANSCRIPT
C#
Structs, operator overloading &attributes
Structs ~ Structures
• Structs are similar to classes: they represent data structures with data and functions.
• Structs are different from classes: variables of a struct type directly contain the value, whereas variables of a class type contain a reference to the value (i.e. the object).
Structs 2
• Structs are value types and are said to have value semantics.
struct Point {
public int x, y;
public Point(int x, int y) {
this.x = x;
this.y = y;
}
}
Structs 3
• Classes are reference types and are said to have reference semantics.
• Point is a struct: 10; Point is a class: 100
Point a = new Point(10, 10);
Point b = a;
a.x = 100;
System.Console.WriteLine(b.x);
Constructing structs
• All struct types implicitly inherit directly from System.ValueType, and are never abstract.
• A struct is not permitted to declare a parameterless instance constructor; every struct has one implicitly.
• The default value of a struct is the value produced by setting all its value type fields to their default value and all its reference type fields to null.
• The struct value itself cannot be null.
Operators & operands
• Expressions are constructed from operands and operators.
• The operators of an expression indicate which operations to apply to the operands.
• Examples of operators include + , - , * , / , and ‘new’.
• Examples of operands include literals, fields, local variables, and expressions.
Operators
• Three kinds of operators:– Unary operators. The unary operators take one operand
and use either prefix notation (such as –x ) or postfix notation (such as x++ ).
– Binary operators. The binary operators take two operands and all use infix notation (such as x + y ).
– Ternary operator. Only one ternary operator, ?: , exists; it takes three operands and uses infix notation(c ? x : y ).
Operator overloading 1
• Certain operators can be overloaded. (Cannot overload e.g. = , && , || , ?:, method invocation or member access)
• Operator overloading permits user- defined operator implementations to be specified for operations
Operator overloading 2
• User-defined operator declarations always require at least one of the parameters to be of the class or struct type that contains the operator declaration.
• User-defined operator declarations cannot modify the syntax, precedence, or associativity of an operator.
Operator overloading exampleusing System;public struct Digit {
byte value;public Digit(byte value) { this.value = value; }public Digit(int value): this((byte) value) {}public static Digit operator+(Digit a, Digit b) {
return new Digit(a.value + b.value);}public static Digit operator-(Digit a, Digit b) {
return new Digit(a.value - b.value);} public static bool operator==(Digit a, Digit b) {
return a.value == b.value;}…
}
Attributes
• C# programmers can attach attributes to various program entities, and retrieve attribute information at run-time.
• Principally analogous to well-known declarations of program entities, e.g. method access: public, protected, and private.
• Attributes are accessible at run-time in a “reflective” manner.
Attributes 2
• A class that derives from the abstract class System.Attribute is an attribute class.
• The declaration of an attribute class defines a new kind of attribute that can be placed on a declaration.
• By convention, attribute classes are named with a suffix of ‘Attribute’.
Attribute parameters
• Attribute classes can have positional parameters and named parameters.
• Each public instance constructor for an attribute class defines a valid sequence of positional parameters for that attribute class.
• Each non-static public read-write field and property for an attribute class defines a named parameter for the attribute class.
Attribute exampleusing System;
[AttributeUsage(AttributeTargets.Class)]
public class HelpAttribute: Attribute {
public HelpAttribute(string url) { // url is a positional parameter
}
public string Topic { // Topic is a named parameter
get {…}
set {…}
}
public string Url { get {…} }
}
Attribute example (cont.)
This Help attribute class might be used as follows:[Help("http://www.mycompany.com/…/Class1.htm")]class Class1 {
…}
[Help("http://www.mycompany.com/…/Misc.htm", Topic ="Class2")] 1class Class2 {
…}
Querying attributes
using System;class Test {
static void Main() {Type type = typeof(Class1);object[] arr = type.GetCustomAttributes(typeof(HelpAttribute),
true); if (arr.Length == 0)
Console.WriteLine("Class1 has no Help attribute.");else {
HelpAttribute ha = (HelpAttribute) arr[0];Console.WriteLine("Url = {0}, Topic = {1}", ha.Url,
ha.Topic);}
} }
Using System;
class Test {
static void Main() {
string s = "Test";
string t = string.Copy(s);
Console.WriteLine(s == t);
Console.WriteLine((object)s == (object)t);
}
}
Produces: True
False
Design goals
• Simple, modern, general-purpose, object-oriented programming language.
• Software robustness, durability, and programmer productivity are important.
• Not intended to compete directly on performance and size with C or assembly language.
Hello, World
• Source stored in one or more text files with a file extension of .cs
• compiled with a command line likecsc hello.cs
using System;
class Hello {
static void Main() {
Console.WriteLine("hello, world");
}
}
Language details
• C# is a standard proposal from ECMA Technical Committee 39, Task Group 2 (TG2)
• C# does not contain a standard class library• Common Language Infrastructure (CLI) is a
standard for a library and execution environment• CLI is a standard proposal from Task Group 3
Unified type system
using System;
class Test {
static void Main() {
Console.WriteLine(3.ToString());
}
}
Boxing/unboxing
• ” This type system unification provides value types with the benefits of object-ness without introducing unnecessary overhead.”
class Test {
static void Main() {
int i = 123;
object o = i; // boxing
int j = (int) o; // unboxing
}
}
Casting
• Implicit casting
• Explicit casting
Example of reference passingusing System;class Test {
static void Swap(ref int a, ref int b) {int t = a;a = b;b = t;
}static void Main() {
int x = 1;int y = 2;Console.WriteLine("pre: x = {0}, y = {1}", x, y);Swap(ref x, ref y);Console.WriteLine("post: x = {0}, y = {1}", x, y);
}}
Produces: pre: x = 1, y = 2post: x = 2, y = 1 2
Parameters
• Value parameter
• Reference parameter
• Output parameter
• Parameter array
Value parameters
• Used for ’in’ passing to a method
• Value is copied to method’s scope
Example of value passing
using System;
class Test {
static void F(int p) {
Console.WriteLine("p = {0}", p);
p++;
}
static void Main() {
int a = 1;
Console.WriteLine("pre: a = {0}", a);
F(a);
Console.WriteLine("post: a = {0}", a);
}
}
Produces: pre: a = 1
p = 1
post: a = 1
Example of output parameters
using System;class Test {
static void Divide(int a, int b, out int result, out int remainder) {result = a / b;remainder = a % b;
}static void Main() {
for (int i = 1; i < 10; i++)for (int j = 1; j < 10; j++) {
int ans, r; 18
Divide(i, j, out ans, out r);Console.WriteLine("{0} / {1} = {2}r{3}", i, j, ans,
r);}
}}
Properties & Indices
Delegates