Scribd
Upload
46 views

Module 5 - More About Variables

This document discusses various topics related to variables in C# including type conversions, enumerations, structs, and arrays. It covers boxing and unboxing for type conversions between value and reference types. It also explains implicit and explicit type conversions. Enumerations are used to define a set of named constants and structs are used to group related data. Finally, it discusses one-dimensional, two-dimensional, and jagged arrays.

Uploaded by

api-19796528
Copyright
© Attribution Non-Commercial (BY-NC)
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
46 views

Module 5 - More About Variables

This document discusses various topics related to variables in C# including type conversions, enumerations, structs, and arrays. It covers boxing and unboxing for type conversions between value and reference types. It also explains implicit and explicit type conversions. Enumerations are used to define a set of named constants and structs are used to group related data. Finally, it discusses one-dimensional, two-dimensional, and jagged arrays.

Uploaded by

api-19796528
Copyright
© Attribution Non-Commercial (BY-NC)
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 27

Module 5:

More About Variables

By

SRIRAM . B
Overview
 Type Conversion
 Boxing
 UnBoxing
 Implicit & Explicit Type Conversion
 Enumerations
 Structs
 Arrays
 One Dimensional
 Two Dimensional
 Jagged
Type Conversions
 Boxing

Conversion of Value type to Reference type.

int i = 10;
string s;
s = i.ToString();

Console.WriteLine(s);
Console.ReadLine();
Type Conversions

 UnBoxing
Conversion of Reference type to Value type.

int i;
string s = "10";
i = Int32.Parse(s);

Console.WriteLine(s);
Console.ReadLine();
Implicit & Explicit Conversions
 Implicit Conversion
 It requires no work on our part, and no additional code.
i.e. Converting from higher end to lower end datatype.
 Explicit Conversion

 It occurs when we explicitly ask the compiler to convert a value from one data
type to another. It requires the extra code and format of the code may depend
on the exact conversion method.

 i.e. Converting from lower end to higher end datatype requires explicit
conversion.
Example - Implicit Conversions
• int i=10;
double j;
j=i;
System.Console.WriteLine(j);

• ushort dest;
char source='A';
dest=source;

System.Console.WriteLine("\n Source: "+source.ToString());


System.Console.WriteLine("\n Dest:"+dest.ToString());
System.Console.ReadLine();
Example - Explicit Conversions
 string sSource="10";
int iDest;
iDest=Convert.ToInt32(sSource);
Console.WriteLine(iDest);

 byte bDest;
short shSource=23;
bDest=(byte)shSource;

Console.WriteLine("Source:" + shSource.ToString());
Console.WriteLine("Dest:"+bDest.ToString());/
Example - Explicit Conversions
 shSource=523;
bDest=unchecked((byte)shSource);

Console.WriteLine("Source:" + shSource.ToString());
Console.WriteLine("Dest:"+bDest.ToString());
Console.ReadLine();
Enumerations
 An enum type declaration defines a type name for a related set of constants.

 Enums are used when you need to make a choice from a fixed number of choices
at compile-time.

 Syntax :

enum typename

value 1,

value 2,

value 3,

.................

}
Enumerations..
 For example,
enum Color //Declares an enum of type int
{
Red, //Members
Green,
Blue
}

Now the value of Red is 0, Blue is 1, Green is 2

 enum Color{ Red=2, Blue,Green,Yellow };

Now Red is 2, Blue is 3, Green is 4, Yellow is 5


Enumerations..

 The value of an enum member can be assigned using a constant expression


initializer.

 In case an enum member has no initializer, its value is set as follows:

 The first enum member declared using the enum type has the value zero.

 The values of the successive enum members will have the increased value of
the previous enum member by one.

 The increased values should be within the range of values that can be
represented by the underlying enum type.
Enumerations..
 Multiple enum members can share the same associated value :-
enum Color { Red, Green, Blue, Pink=Blue }

This shows an enum that has two enum members, Blue and Pink, which have the
same associated value.

 Even though two members can have the same values associated with them it
returns an error :-

enum Color { Red= Pink, Green, Blue, Pink }


Example 1 - Enumerations
using System;
namespace sampleEnum
{
class sampleEnum
{
enum Days { Sun = 1, Mon, Tue = 7, Wed, Thu,
Fri, Sat };

static void Main(string[] args)


{
int x = (int)Days.Sun;
int y = (int)Days.Fri;
int z = Convert.ToInt16(Days.Wed);
Console.WriteLine("Sun = {0}", x);
Console.WriteLine("Fri = {0}\n", y);
Console.WriteLine("wed = {0}\n", z);
}
}
}
Structs
 A structure is a derived data type that allows a programmer to group data
elements belonging to the different data types.

 A struct type is a value type that can contain constructors, constants, fields,
methods, properties, indexers, operators and nested types.

 Syntax :-
<modifier> struct <structurename>
{
<members> \\ Elements in the structure called Members
<members>
}
Modifier may be public, private, protected & internal
Example 1 - Stuct
using System;
namespace Structure
{
class sampleStructure
{
static void Main(string[] args)
{
xxx x = new xxx(10);
Console.WriteLine(x.i);
x.abc();
Console.ReadLine();
}
struct xxx
{
public int i;
public xxx(int j)
{
i = j;
}
public void abc()
{
System.Console.WriteLine("abc");
}
}
}
}
Arrays
 An array is a data structure that contains a collection of elements of the
same type, which are referenced by a common name.

 All elements in an array occupy continuous memory locations.

 Each element in the array is referred to by the array name and the array
subscript number also known as the index number.

 The subscript number of an array starts from 0.

 Arrays in C-Sharp can be single– or multi–dimensional, each row have same size.

 The most commonly used array type is single–dimensional.

 Rows of different size is called Jagged Arrays i.e., Array of Arrays


Arrays Creation
 Array Declaration
int [ ] MyIntArray;
 Memory Allocation
MyIntArray = new int[5];
 Initialization
MyIntArray[0]=1 // Assigns a value 1 to the first element
MyIntArray[1]=2 // Assigns a value 2 to the second element
MyIntArray[2]=3 // Assigns a value 3 to the third element
MyIntArray[3]=4 // Assigns a value 4 to the fourth element
MyIntArray[4]=5 // Assigns a value 5 to the fifth element
 Example :-
int[ ] MyIntArray = new int[5]; int[ ] MyIntArray ={1,2,3,4,5};
int[ ] MyIntArray =new int[5]{1,2,3,4,5};
Example - Arrays

using System;
class Array_type
{
public static void Main()
{
int[ ]arr;
arr=new int[3];
Console.WriteLine(“Initialising the array”);
for (int i=0; i<3; i++)
{
arr[i]=i;
}
Example - Arrays

Console.WriteLine(“Displaying the contents of


array”);
for (int j=0; j<3; j++)
{
Console.WriteLine(arr[j]);
}
}
}

Output of the code is:


0
1
2
Jagged Arrays
 In Single, Multi-dimensional arrays each row has the same size.

 Rows with different size are called Jagged Arrays, To do this we need to have an
array where each element is another array. i.e., Array of Arrays
 Syntax :-

int [ ] [ ] jagged;

jagged = new int [2][ ];

jagged [0] = new int [3];

jagged [1] = new int [4];

int [ ] [ ] jagged = {new int [ ] {1,2,3}, new int [ ] {1,2} };


Example – Jagged Arrays
Using System;
namespace Arrays
{
class jaggedarrays
{
public static void Main()
{
int[ ] [ ] jagged = {new int [] {1,2,3},
new int [] {1,2}} ;
Example – Jagged Arrays..
foreach(int[ ] a in jagged)
{
foreach(int x in a)
{
Console.WriteLine(x);
}
}
}
More About Variables - Flashback
 Type Conversion
 Boxing
 UnBoxing
 Implicit & Explicit Type Conversion
 Enumerations
 Structs
 Arrays
 One Dimensional
 Two Dimensional
 Jagged
Session Ends
Exercise
Relax

You might also like