STRINGS OPERATORS AND EXPRESSIONS
ON C# . [DOT] NET
Strings
• Reference type
• Represents a string of Unicode characters
string studentName;
string courseName = "Programming I";
string twoLines = “Line1\nLine2”;
Making Data Constant
• Add the keyword const to a declaration
• Value cannot be changed
• Standard naming convention
• Syntax
– const type identifier = expression;
const double TAX_RATE = 0.0675;
const int SPEED = 70;
const char HIGHEST_GRADE = ‘A’;
Assignment Statements
• Used to change the value of the variable
– Assignment operator (=)
• Syntax
variable = expression;
• Expression can be:
– Another variable
– Compatible literal value
– Mathematical equation
– Call to a method that returns a compatible value
– Combination of one or more items in this list
Examples of Assignment Statements
double accountBalance, weight;
decimal amountOwed, deficitValue;
bool isFinished;
accountBalance = 4783.68;
weight = 1.7E-3; //scientific notation may be used
amountOwed = 3000.50m; // m or M must be suffixed to
// decimal
deficitValue = -322888672.50M;
isFinished = false;
int count = 0, newValue = 25;
string aSaying, fileLocation;
aSaying = “First day of the rest of your life!\n ";
fileLocation = @”C:\CSharpProjects\Chapter2”;
// declared previously as a bool
count = newValue;
@ placed before a string literal signals that the characters inside the double quotation marks should be interpreted verbatim
Figure 3-5 Impact of assignment statement
Arithmetic Operations
• Simplest form of an assignment statement
resultVariable = operand1 operator operand2;
• Readability
– Space before and after every operator
+ Operator on a StringConcatenation
Fundamental Precedence Order of operators
• Precedence order from high to low
( ) - elements within parentheses
*, /, % - multiplicative
+, - - additive
• Computation proceeds from left to right (left associative) within each precedence category
• Increment and Decrement Operations
– Unary operator
num++; // num = num + 1;
--value1; // value = value – 1;
– Preincrement/predecrement versus post
int num = 30;
System.Console.WriteLine(num++); // Displays 30
System.Console.WriteLine(num); // Display 31
System.Console.WriteLine(--num); // Displays 30
Compound Operations
• Accumulation
– +=
Order of Operations
• Parentheses () – above *, / and % in precedence
• Associativity of operators
– Left
– Right
Mixed Expressions
• Implicit type coercion
– Changes int data type into a double
– No implicit conversion from double to int
Figure 3-12 Syntax error generated for assigning a double to an int
• Explicit type coercion
– Cast
– (type) expression
– examAverage = (exam1 + exam2 + exam3) / (double) count;
int value1 = 0, anotherNumber = 75;
double value2 = 100.99, anotherDouble = 100;
value1 = (int) value2; // value1 = 100
value2 = (double) anotherNumber; // value2 = 75.0
Formatting Output
• You can format data by adding dollar signs, percent symbols, and/or commas to separate digits
• You can suppress leading zeros
• You can pad a value with special characters
– Place characters to the left or right of the significant digits
• Use format specifiers
Numeric Format Specifiers
Custom Numeric Format Specifiers
Formatting Output :
What is an Expression?
• The most basic expression consists of an operator, two operands and an assignment. The following is an example of an expression:
• int theResult = 1 + 2; In the above example the (+) operator is used to add two operands (1 and 2) together. The assignment operator (=) subsequently assigns the result of the addition to an integer variable namedtheResult. The operands could just have easily been variables or constants (or a mixture of each) instead of the actual numerical values used in the example.
• In the remainder of this chapter we will look at the various types of operators available in C#.
The Basic Assignment Operator
• We have already looked at the most basic of assignment operators, the = operator. This assignment operator simply assigns the result of an expression to a variable. In essence the = assignment operator takes two operands. The left hand operand is the variable to which a value is to be assigned and the right hand operand is the value to be assigned. The right hand operand is, more often than not, an expression which performs some type of arithmetic or logical evaluation. The following examples are all valid uses of the assignment operator:
• x = 10; // Assigns the value 10 to a variable named x x = y + z; // Assigns the result of variable y added to variable z to variable x x = y; // Assigns the value of variable y to variable x Assignment operators may also be chained to assign the same value to multiple variables. For example, the following code example assigns the value 20 to the x, y and z variables:
• int x, y, z; x = y = z = 20;
C# Arithmetic Operators
• C# provides a range of operators for the purpose of creating mathematical expressions. These operators primarily fall into the category of binary operators in that they take two operands. The exception is the unary negative operator (-) which serves to indicate that a value is negative rather than positive. This contrasts with the subtraction operator (-) which takes two operands (i.e. one value to be subtracted from another). For example:
• int x = -10; // Unary - operator used to assign -10 to a variable named x x = y - z; // Subtraction operator. Subtracts z from y
• Note that multiple operators may be used in a single expression.
• For example:
• x = y * 10 + z - 5 / 4; Whilst the above code is perfectly valid it is important to be aware that C# does not evaluate the expression from left to right or right to left, but rather in an order specified by the precedence of the various operators. Operator precedence is an important topic to understand since it impacts the result of a calculation and will be covered in detail the next section.
C# Operator Precedence
• When humans evaluate expressions, they usually do so starting at the left of the expression and working towards the right. For example, working from left to right we get a result of 300 from the following expression:
• 10 + 20 * 10 = 300
• This is because we, as humans, add 10 to 20, resulting in 30 and then multiply that by 10 to arrive at 300. Ask C# to perform the same calculation and you get a very different answer:
• int x; x = 10 + 20 * 10; System.Console.WriteLine (x) The above code, when compiled and executed, will output the result 210.
• This is a direct result of operator precedence. C# has a set of rules that tell it in which order operators should be evaluated in an expression. Clearly, C# considers the multiplication operator (*) to be of a higher precedence than the addition (+) operator.
• Fortunately the precedence built into C# can be overridden by surrounding the lower priority section of an expression with parentheses. For example:
• int x; x = (10 + 20) * 10; System.Console.WriteLine (x) In the above example, the expression fragment enclosed in parentheses is evaluated before the higher precedence multiplication resulting in a value of 300.
• The following table outlines the C# operator precedence order from highest precedence to lowest:
Compound Assignment Operators
• C# provides a number of operators designed to combine an assignment with a mathematical or logical operation. These are primarily of use when performing an evaluation where the result is to be stored in one of the operands. For example, one might write an expression as follows:
• x = x + y; The above expression adds the value contained in variable x to the value contained in variable y and stores the result in variable x. This can be simplified using the addition compound assignment operator:
• x += y The above expression performs exactly the same task as x = x + y but saves the programmer some typing.
• n addition to mathematical and assignment operators, C# also includes set of logical operators useful for performing comparisons. These operators all return a Boolean (bool) true or false result depending on the result of the comparison. These operators are binary in that they work with two operands.
• Comparison operators are most frequently used in constructing program flow control. For example an if statement may be constructed based on whether one value matches another:
• if (x == y) System.Console.WriteLine ("x is equal to y"); The result of a comparison may also be stored in a bool variable. For example, the following code will result in a true value being stored in the variable result:
• bool result; int x = 10; int y = 20; result = x < y;
Boolean Logical Operators
• Another set of operators which return boolean true and false values are the C# boolean logical operators. These operators both return boolean results and take boolean values as operands. The key operators are NOT (!), AND (&&), OR (||) and XOR (^).
• The NOT (!) operator simply inverts the current value of a boolean variable, or the result of an expression. For example, if a variable named flag is currently true, prefixing the variable with a '!' character will invert the value to be false:
• bool flag = true; //variable is true bool secondFlag; secondFlag = !flag; // secondFlag set to false The OR (||) operator returns true if one of its two operands evaluates to true, otherwise it returns false. For example, the following example evaluates to true because at least one of the expressions either side of the OR operator is true:
• if ((10 < 20) || (20 < 10)) System.Console.WriteLine("Expression is true"); The AND (&&) operator returns true only if both operands evaluate to be true. The following example will return false because only one of the two operand expressions evaluates to true:
• if ((10 < 20) && (20 < 10)) System.Console.WriteLine("Expression is true"); The XOR (^) operator returns true if one and only one of the two operands evaluates to true. For example, the following example will return true since only one operator evaluates to be true:
• if ((10 < 20) ^ (20 < 10)) System.Console.WriteLine("Expression is true"); If both operands evaluated to be true, or both were false the expression with return false.
The Ternary Operator
• C# uses something called a ternary operator to provide a shortcut way of making decisions. The syntax of the ternary operator is as follows:
• [condition] ? [true expression] : [false expression]
• The way this works is that [condition] is replaced with an expression that will return either true or false. If the result is true then the expression that replaces the [true expression] is evaluated. Conversely, if the result was false then the [false expression] is evaluated. Let's see this in action:
• int x = 10; int y = 20; System.Console.WriteLine( x > y ? x : y );
No comments:
Post a Comment