|
This lesson introduces C# expressions, types, and variables. It's
goal is to meet the following objectives:
- Understand what a "Variable" is.
- Learn the C# simple types.
- Obtain a basic understanding of C# expressions.
- Learn what the String type is.
- Learn how to use Arrays.
"Variables" are simply storage locations for data. You may
place data into them and retrieve their contents as part of a C#
expression. The interpretation of the data in a variable is
controlled through "Types".
C# is a strongly "Typed" language. Thus all operations on
variables are performed with consideration of what the variable's "Type"
is. There are rules that define what operations are legal in order
to maintain the integrity of the data you put in a
variable.
The C# simple types consist of the boolean type and three numberic
types - integrals, floating point, and decimal.
Listing 1-1.
Displaying Boolean Values: Boolean.cs
- using System;
class Booleans
{
public static void Main()
{
bool content =
true;
bool noContent =
false;
Console.WriteLine("It is {0} that C# Station provides C# programming
language content.",
content);
Console.WriteLine("The statement above is not {0}.",
noContent);
}
}
In Listing 1-1, the boolean values are written to the console as a part
of a sentence. The "bool" type is simply either a true or
false. When run, this program produces the following output:
- >It is True that C# Station provides C# programming language
content.
- >The statement above is not False.
The following table shows the integral types, their size, and
range.
| Type |
Size (in bits) |
Range |
| sbyte |
8 |
-128 to 127 |
| byte |
8 |
0 to 255 |
| short |
16 |
-32768 to
32767 |
| ushort |
16 |
0 to 65535 |
| int |
32 |
-2147483648
to 2147483647 |
| uint |
32 |
0 to
4294967295 |
| long |
64 |
-9223372036854775808 to 9223372036854775807 |
| ulong |
64 |
0 to
18446744073709551615 |
| char |
16 |
0 to 65535 |
Integral types are well suited for those operations involving whole
number calculations. The char type is the exception, representing a
single Unicode character. As you can see from the table above, you
have a wide range of options to choose from, depending on your
requirements.
The following table shows the floating point and decimal types, their
size, precision, and range.
| Type |
Size (in bits) |
Precision |
Range |
| float |
32 |
7 digits |
1.5 x
10-45 to 3.4 x 1038 |
| double |
64 |
15-16 digits |
5.0 x
10-324 to 1.7 x
10308 |
| decimal |
128 |
28-29 decimal places |
1.0 x
10-28 to 7.9 x
1028 |
Floating point types are used when you need to perform operations
requiring fractional representations. However, for
financial calculations, the decimal type may be your best choice.
Results are computed by building expressions. These expressions
are built by combining variables and operators together into
statements. The following table describes the allowable operators,
their precedence, and associativity.
| Category |
Operator(s) |
Associativity |
| Primary |
(x)
x.y f(x) a[x] x++ x-- new
typeof sizeof checked
unchecked |
left |
| Unary |
+
- ! ~ ++x --x
(T)x |
left |
| Multiplicative |
*
/ % |
left |
| Additive |
+ - |
left |
| Shift |
<< >> |
left |
| Relational |
<
> <= >= is |
left |
| Equality |
== != |
right |
| Logical AND |
& |
left |
| Logical XOR |
^ |
left |
| Logical OR |
| |
left |
| Conditional
AND |
&& |
left |
| Conditional
OR |
|| |
left |
| Conditional |
?: |
right |
| Assignment |
=
*= /= %= += -= <<=
>>= &= ^= |= |
right |
Left associativity means that operations are evaluated from left to
right. Right associativity mean all operations occur from right to
left, such as assignment operators where everything to the right is
evaluated before the result is placed into the variable on the left.
Listing 1-2. Unary
Operators: Unary.cs
- using System;
class Unary
{
public static void Main()
{
int unary =
0;
int
preIncrement;
int
preDecrement;
int
postIncrement;
int
postDecrement;
int
positive;
int
negative;
sbyte
bitNot;
bool
logNot;
preIncrement =
++unary;
Console.WriteLine("Pre-Increment: {0}",
preIncrement);
preDecrement = --unary;
Console.WriteLine("Pre-Decrement: {0}",
preDecrement);
postDecrement = unary--;
Console.WriteLine("Post-Decrement: {0}",
postDecrement);
postIncrement = unary++;
Console.WriteLine("Post-Increment: {0}",
postIncrement);
Console.WriteLine("Final Value of Unary: {0}",
unary);
positive =
-postIncrement;
Console.WriteLine("Positive: {0}",
positive);
negative =
+postIncrement;
Console.WriteLine("Negative: {0}",
negative);
bitNot =
0;
bitNot =
(sbyte)(~bitNot);
Console.WriteLine("Bitwise Not: {0}",
bitNot);
logNot =
false;
logNot =
!logNot;
Console.WriteLine("Logical Not: {0}", logNot);
}
}
When evaluating expressions, post-increment and post-decrement
operators return their current value and then apply the operators.
However, when using pre-increment and pre-decrement operators, the
operator is applied to the variable prior to returning the final
value.
In Listing 1-2, the "unary" variable is initialized to zero. When
the pre-increment (++x) operator is used, "unary" is incremented to 1 and
the value 1 is assigned to the "preIncrement" variable. The
pre-decrement (--x) operator turns "unary" back to a 0 and then assigns
the value to the "preDecrement" variable.
When the post-decrement (x--) operator is used, the value of "unary",
0, is placed into the "postDecrement" variable and then "unary" is
decremented to -1. Next the post increment (x++) operator moves the
current value of "unary", -1, to the "postIncrement" variable and then
increments "unary" to 0.
The variable "bitNot" is initialized to zero and the bitwise not
operator is applied. The bitwise not (~) operator flips the bits in
the variable. In this case, the binary representation of 0,
"00000000", was transformed into -1, "11111111".
Notice the expression "(sbyte)(~bitNot)". Any operation performed
on types sbyte, byte, short, or ushort return integer values. To
assign the result into the bitNot variable we had to use a cast (Type)
operator, where Type is the type you wish to convert to (in this case -
sbyte). Cast operators must be performed explicity when you go from
a larger type to a smaller type because of the potential for lost
data. Generally speaking, assigning a smaller type to a larger type
is no problem, since the larger type has room to hold the entire
value. Also be aware of the dangers of casting between signed and
unsigned types. You want to be sure to preserve the integrity of
your data. Many basic programming texts contain good descriptions of
bit representations of variables and the dangers of explicit casting.
The logical not (!) operator allows you to toggle the value of a
boolean variable. In the example, the "logNot" variable is changed
from false to true. You can expect the following output from the
above program.
- >Pre-Increment: 1
>Pre-Decrement 0
- >Post-Decrement: 0
>Post-Increment -1
- >Final Value of Unary: 0
>Positive: 1
- >Netative: -1
>Bitwise Not: -1
- >Logical Not: True
Listing 1-3. Binary
Operators: Binary.cs
- using System;
class Binary
{
public static void Main()
{
int x, y,
result;
float
floatResult;
x =
7;
y =
5;
result =
x+y;
Console.WriteLine("x+y: {0}",
result);
result =
x-y;
Console.WriteLine("x-y: {0}",
result);
result =
x*y;
Console.WriteLine("x*y: {0}",
result);
result =
x/y;
Console.WriteLine("x/y: {0}",
result);
floatResult =
(float)x/(float)y;
Console.WriteLine("x/y: {0}",
floatResult);
result =
x%y;
Console.WriteLine("x%y: {0}",
result);
result +=
x;
Console.WriteLine("result+=x: {0}", result);
}
}
Listing 1-3 shows several examples of binary operators. As you
might expect, the results of addition (+), subtraction (-), multiplication
(*), and division (/) produce the expected mathematical results.
The "floatResult" variable is a floating point type. We
explicitly cast the integer variables "x" and "y" to calculate a floating
point value.
There is also an example of the remainder(%) operator. It
performs a division operation on two values and returns the remainder.
The last statement shows another form of the assignment with operation
(+=) operator. Any time you use the assignment with operation
operator, it's the same as applying the binary operator to both the left
hand and right hand sides of the operator and putting the results into the
left hand side. The example could have been written as "result =
result + x" and returned the same value.
One type you've seen a lot in the last two lessons is the "string"
type. The "string" type is represented by a list of Unicode
characters within single quotes. i.e. "This is a string."
Another data type is the Array. Arrays can be thought of as
containers that have a list of storage locations for a specified
type. When declaring an Array, you specify the type, Array name,
dimensions, and size.
Listing 1-4. Array
Operations: Array.cs
- using System;
class Array
{
public static void Main()
{
int[] myInts = { 5, 10,
15 };
bool[][] myBools =
new bool[2][];
myBools[0]
= new bool[2];
myBools[1]
= new bool[1];
double[,]
myDoubles = new double[2,
2];
string[] myStrings =
new string[3];
Console.WriteLine("myInts[0]: {0}, myInts[1]: {1}, myInts[2]: {2}",
myInts[0], myInts[1],
myInts[2]);
myBools[0][0] = true;
myBools[0][1] = false;
myBools[1][0] = true;
Console.WriteLine("myBools[0][0]: {0}, myBools[1][0]: {1}",
myBools[0][0],
myBools[1][0]);
myDoubles[0, 0] = 3.147;
myDoubles[0, 1] = 7.157;
myDoubles[1, 1] = 2.117;
myDoubles[1, 0] =
56.00138917;
Console.WriteLine("myDoubles[0, 0]: {0}, myDoubles[1, 0]: {1}",
myDoubles[0, 0], myDoubles[1,
0]);
myStrings[0] =
"Joe";
myStrings[1] =
"Matt";
myStrings[2] =
"Robert";
Console.WriteLine("myStrings[0]: {0}, myStrings[1]: {1}, myStrings[2]:
{2}", myStrings[0], myStrings[1],
myStrings[2]);
}
}
Listing 1-4 shows different implementations of Arrays. The first
example is the "myInts" Array. It is initialized at declaration time
with explicit values.
Next is a jagged array. It is essentially an array of
arrays. We needed to use the "new" operator to instantiate the size
of the primary array and then use the new operator again for each
sub-array.
The third example is a two dimensional array. Arrays can be
multi-dimensional, with each dimension separated by a comma. it must
also be instantiated with the "new" operator.
Finally, we have the one dimensional array of strings.
In each case, you can see that array elements are accessed by
identifying the integer index for the item you wish to refer to.
Arrays sizes can be any "int" type value. Their indexes always begin
at 0.
By now you know what a C# variable is. You have learned the C#
simple data types as well as arrays and strings. You also know how
to form expressions with C# operators.
C# : Control Statement : selection
|