Short Integers

Short Integers

A word, which is a group of 16 contiguous bits or 2 bytes, can be used to hold a natural number. As we have studied, the maximum numeric value that can fit in a word is 65535. To declare a variable for such a value, you can use the var keyword and initialize the variable with a value between –32768 to 32767. Here is an example:

using System;

class Exercise
{
   static void Main()
   {
       var SchoolEffective = 1400; // Number of Students

       Console.Write("School Effective: ");
       Console.WriteLine(SchoolEffective);
   }
}

This would produce:

School Effective: 1400
Press any key to continue . . .

Since the byte is used for characters and very small numbers, whenever you plan to use a number in your program, the minimum representation you should use is a word.

A natural number is also called an integer. If you want to declare the variable using a data type, the smallest integer you can store in a word is declared with the short keyword. Because a short integer is signed by default, it can store a value that ranges from –32768 to 32767. Here is an example program that uses two short integers:

using System;

class Exercise
{
   static void Main()
   {
 short NumberOfPages;
 short Temperature;

 NumberOfPages = 842;
 Temperature   = -1544;

 Console.Write("Number of Pages of the book: ");
 Console.WriteLine(NumberOfPages);
 Console.Write("Temperature to reach during the experiment: ");
 Console.Write(Temperature);
 Console.WriteLine(" degrees\n");
   }
}

This would produce:

Number of Pages of the book: 842
Temperature to reach during the experiment: -1544 degrees

Because a short integer handles numbers that are larger than the signed byte, any variable you can declare for a signed byte can also be declared for a short variable.

A Word

A Word

Introduction

A word is a group of 16 consecutive bits. The bits are counted from right to left starting at 0:

Considered as a group of 16 bits, the most right bit of a word, bit 0, is called the least significant bit or Low Order bit or LO bit or LOBIT. The most left bit, bit 15, is called the most significant bit or High Order bit or HI bit or HIBIT. The other bits are referred to using their positions: bit 1, bit 2, bit 3, etc.

Considering that a word is made of two bytes, the group of the right 8 bits is called the least significant byte or Low Order byte or LO byte or LOBYTE. The other group is called the most significant byte or High Order byte or HI byte or HIBYTE.

The representation of a word in binary format is 0000000000000000. To make it easier to read, you can group bits by 4, like this: 0000 0000 0000 0000. Therefore, the minimum binary value represented by a word is 0000 0000 0000 0000. The minimum decimal value of a word is 0. The minimum hexadecimal value you can store in a word is 0x0000000000000000. This is also represented as 0x00000000, or 0x0000, or 0x0. All these numbers produce the same value, which is 0x0.

The maximum binary value represented by a word is 1111 1111 1111 1111. To find out the maximum decimal value of a word, you can use the base 2 formula, filling out each bit with 1:

1*2¹⁵+1*2¹⁴+1*2¹³ + 1*2¹² + 1*2¹¹ + 1*2¹⁰ + 1*2⁹ + 1*2⁸ + 1*2⁷ + 1*2⁶ + 1*2⁵ + 1*2⁴ + 1*2³ + 1*2² + 1*2¹ + 1*2⁰

= 32768 + 16384 + 8192 + 4096 + 2048 + 1024 + 512 + 256 + 128 + 64 + 32 + 16 + 8 + 4 + 2 + 1

= 65535

To find out the maximum hexadecimal number you can store in a word, replace every group of 4 bits with an f or F:

1111	1111	1111	1111
f	f	f	f
= 0xffff = 0xFFFF = 0Xffff = 0XFFFF

Signed Byte

Signed Byte

A byte number is referred to as signed if it can hold a negative of a positive value that ranges from -128 to 127, which can therefore fit in a byte. To declare a variable for that kind of value, use the sbyte keyword. Here is an example:

using System;

class NumericRepresentation
{
   static void Main()
   {
 sbyte RoomTemperature = -88;

 Console.Write("When we entered, the room temperature was ");
 Console.WriteLine(RoomTemperature);
 Console.WriteLine();
   }
}

This would produce:

When we entered, the room temperature was -88

Practical Learning: Using Bytes

1. Change the Program.cs file as follows:


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace GeorgetownCleaningServices2
{
class Program
{
static void Main(string[] args)
{
byte Shirts;
byte Pants;

Shirts = 4;
Pants = 1;

Console.WriteLine("-/- Georgetown Cleaning Services -/-");
Console.WriteLine("========================");
Console.WriteLine("Item Type Qty");
Console.WriteLine("------------------------");
Console.Write("Shirts ");
Console.WriteLine(Shirts);
Console.Write("Pants ");
Console.WriteLine(Pants);
Console.WriteLine("========================");
Console.WriteLine();
}
}
}

2. Execute the program. This would produce:


-/- Georgetown Cleaning Services -/-
========================
Item Type Qty
------------------------
Shirts 4
Pants 1
========================

3. Close the DOS window

The Byte Data Type

The Byte Data Type

A byte is an unsigned number whose value can range from 0 to 255 and therefore can be stored in one byte. You can use it when you know a variable would hold a relatively small value such as people's age, the number of children of one mother, etc. To declare a variable that would hold a small natural number, use the byte keyword. Here is an example:

byte Age;

You can initialize a byte variable when declaring it or afterwards. Here is an example that uses the byte data type:

using System;

class ObjectName
{
   static void Main()
   {
 Byte Age = 14;
 Console.Write("Student Age: ");
 Console.WriteLine(Age);

 Age = 12;
 Console.Write("Student Age: ");
 Console.WriteLine(Age);
   }
}

Make sure you do not use a value that is higher than 255 for a byte variable, you would receive an error. When in doubt, or when you think that there is a possibility a variable would hold a bigger value, don't use the byte data type as it doesn't like exceeding the 255 value limit.

Alternatively, you can also use the var keyword to declare the variable and initialize it with a small number. Here is an example:

using System;

class Exercise
{
   static void Main()
   {
       var Age = 14;
       Console.Write("Student Age: ");
       Console.WriteLine(Age);

       Age = 12;
       Console.Write("Student Age: ");
       Console.WriteLine(Age);
   }
}

Instead of a decimal number, you can also initialize an integral variable with a hexadecimal value. When doing this, make sure the decimal equivalent is less than 255. Here is an example:

using System;

class Exercise
{
   static void Main()
   {
       var Number = 0xFE;

       Console.Write("Number: ");
       Console.WriteLine(Number);
   }
}

This would produce:

Number: 254
Press any key to continue . . .

Escape Sequences

Escape Sequences

An escape sequence is a special character that displays non-visibly. For example, you can use this type of character to indicate the end of line, that is, to ask the program to continue on the next line. An escape sequence is represented by a backslash character, \, followed by another character or symbol. For example, the escape sequence that moves to the next line is \n.

An escape can be included in single-quotes as in '\n'. It can also be provided in double-quotes as "\n".

The C# language recognizes other escape sequences.

Escape Sequence	Name	Description
\a	Bell (alert)	Makes a sound from the computer
\b	Backspace	Takes the cursor back
\t	Horizontal Tab	Takes the cursor to the next tab stop
\n	New line	Takes the cursor to the beginning of the next line
\v	Vertical Tab	Performs a vertical tab
\f	Form feed
\r	Carriage return	Causes a carriage return
\"	Double Quote	Displays a quotation mark (")
\'	Apostrophe	Displays an apostrophe (')
\?	Question mark	Displays a question mark
\\	Backslash	Displays a backslash (\)
\0	Null	Displays a null character

To use an escape sequence, you can also first declare a char variable and initialize it with the desired escape sequence in single-quotes.

Characters

Characters

In the English alphabet, a character is one of the following symbols: a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, and Z. Besides these readable characters, the following symbols are called digits and they are used to represent numbers: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9. In addition, some symbols on the (US QWERTY) keyboard are also called characters or symbols. They are ` ~ ! @ # $ % ^ & * ( ) - _ = + [ { ] } \ | ; : ' < ? . / , > "

Besides the English language, other languages use other or additional characters that represent verbal or written expressions.

C# recognizes that everything that can be displayed as a symbol is called a character. To declare a variable whose value would be a character, you can use the var keyword and initialize the variable with a character in single-quotes. Here is an example:

using System;

class Exercise
{
   static void Main()
   {
       var Gender = 'F';

       Console.Write("Student Gender: ");
       Console.WriteLine(Gender);
   }
}

Alternatively, you can use the char keyword. Here is an example:

using System;

class Exercise
{
   static void Main()
   {
 char Gender = 'M';

 Console.Write("Student Gender: ");
 Console.WriteLine(Gender);
   }
}

This would produce:

Student Gender: M