CPP225

Object Oriented
Programming I

Arrays

Öğr. Gör.
İhsan Can İÇİUYAN
 2 Object Oriented Programming

Contents
 Arrays

 Initializing Arrays

 Implicitly Typed Arrays

 Array of Objects

 Multidimensional Arrays

 Passing and Receiving Arrays

 System.Array Class

 Indices and Ranges

 3 Object Oriented Programming

Arrays
 Array → a set of contiguous data points of the same type

 Elements are accessed using a numerical index.

 Consider the following example:

// Create an array of 3 integers
int[] myInts = new int[3];

// Create a 100 item string array, indexed 0 - 99

string[] myStrings = new string[100];

 The number used in the array declaration represents the total

number of items, not the upper bound.

 The lower bound of an array always begins at 0.

 4 Object Oriented Programming

Arrays
 You can fill the array elements index by index:

// Create and fill an array of 3 integers

int[] myInts = new int[3];
myInts[0] = 100;
myInts[1] = 200;
myInts[2] = 300;

// Now print each value

foreach (int i in myInts)
{
Console.WriteLine(i);
}

If you declare an array but do not explicitly fill each index,

each item will be set to the default value of the data type.
 5 Object Oriented Programming

Initializing Arrays
 You can fill the items of an array using array initialization syntax.

 You can specify each array item within the curly brackets:

int[] intArray = new int[4] { 20, 22, 23, 0 };

 When you initialize an array, you do not need to specify the size of
the array:
string[] stringArray = new string[] { "one", "two", "three" };

 The size of the array will be inferred by the number of items within
the curly brackets.

 When you initialize an array, the use of the new keyword is optional:
bool[] boolArray = { false, false, true };
 6 Object Oriented Programming

Initializing Arrays
 If there is a mismatch between the declared size and the number
of initializers, you are issued a compile-time error.

 Consider the following example:

int[] intArray = new int[2] { 20, 22, 23, 0 };

 Since there are more initializers than the size of the array, the
compiler will issue an error.

 Consider the following example:

int[] intArray = new int[4] { 20, 22 };

 Since there are fewer initializers than the size of the array, the
compiler will issue an error.
 7 Object Oriented Programming

Implicitly Typed Arrays

 The var keyword can be used to define implicitly typed arrays.

 You must use the new keyword when using this approach.

// a is really int[]
var a = new[] { 1, 10, 100, 1000 };

// b is really double[]
var b = new[] { 1, 1.5, 2, 2.5 };

// c is really string[]
var c = new[] { "hello", null, "world" };

 The items in the array’s initialization list must be of the same type.
Thus, the following generates a compile-time error:
var d = new[] { 1, "one", 2, "two", false };
 8 Object Oriented Programming

Array of Objects
 System.Object is the ultimate base class to every type.

 If you were to define an array of System.Object data types, the

subitems could be anything at all:
// An array of objects can be anything at all
object[] myObjects = new object[4];

myObjects[0] = 10;
myObjects[1] = false;
myObjects[2] = new DateTime(2024, 12, 20);
myObjects[3] = "Hello World!";

foreach (object obj in myObjects)

{
// Print the type and value for each item in array
Console.WriteLine("Type: {0}, Value: {1}", obj.GetType(), obj);
}
 9 Object Oriented Programming

Multidimensional Arrays
 C# supports two varieties of multidimensional arrays:
 Rectangular array

 Jagged array
 10 Object Oriented Programming

Multidimensional Arrays
 Rectangular array → an array of multiple dimensions, where each
row is of the same length

 You can declare and fill a rectangular array as follows:

// A rectangular array
int[,] myMatrix;
myMatrix = new int[3, 4];

// Populate (3 * 4) array
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 4; j++)
{
myMatrix[i, j] = i * j;
}
}
 11 Object Oriented Programming

Multidimensional Arrays
 Jagged array → contains some number of inner arrays, each of
which may have a different upper limit

 You can declare a jagged array as follows:

// A jagged array
// Here we have an array of 5 different arrays
int[][] myJagArray = new int[5][];

// Create the jagged array

for (int i = 0; i < myJagArray.Length; i++)
{
myJagArray[i] = new int[i + 7];
}
 12 Object Oriented Programming

Multidimensional Arrays
 You can access the elements of a jagged array as follows:

// Print each row

for (int i = 0; i < 5; i++)
{
for (int j = 0; j < myJagArray[i].Length; j++)
{
Console.Write(myJagArray[i][j] + " ");
}
Console.WriteLine();
}

 Remember that if you do not initialize the array, each element is

defaulted to zero (if the elements are numeric values).
 13 Object Oriented Programming

Passing and Receiving Arrays

 After you have created an array, you are free to
 pass it as an argument
 receive it as a return value

 The following method takes an incoming array of ints and prints

each member to the console:

static void PrintArray(int[] myInts)

{
for (int i = 0; i < myInts.Length; i++)
{
Console.WriteLine("Item {0} is {1}", i, myInts[i]);
}
}
 14 Object Oriented Programming

Passing and Receiving Arrays

 The following method populates an array of strings and returns it
to the caller:
static string[] GetStringArray()
{
string[] theStrings = { "Hello", "from", "World" };
return theStrings;
}
 These methods may be invoked as follows:
// Pass array as parameter
int[] ages = { 20, 22, 23, 0 };
PrintArray(ages);

// Get array as return value

string[] strs = GetStringArray();
foreach (string s in strs)
Console.WriteLine(s);
 15 Object Oriented Programming

System.Array Class
 Every array you create gathers much of its functionality from the
System.Array class.

 Following table gives some of the more interesting members of the

System.Array class.
 16 Object Oriented Programming

System.Array Class
 EX: A program that makes use of the static Reverse() and Clear()
methods to print out information about an array of string types.

 Code: 57_ArrayClass.cs

Output:
-> Here is the array:
Object Oriented Programming, Data Structures, Introduction to Algorithms,

-> The reversed array:

Introduction to Algorithms, Data Structures, Object Oriented Programming,

-> Cleared out all but one...

Introduction to Algorithms, , ,

 NB: Many members of System.Array are defined as static members

and are, therefore, called at the class level.
 17 Object Oriented Programming

Indices and Ranges

 C# provides two types and two operators for use when working with
arrays:

 System.Index → represents an index into a sequence

 System.Range → represents a subrange of indices

 Index from end operator (^) → specifies that the index is relative
to the end of the sequence

 Range operator (..) → specifies the start and end of a range as

its operands
 18 Object Oriented Programming

Indices and Ranges

 Arrays are indexed beginning with zero (0).

 The end of a sequence is the length of the sequence – 1.

 Consider the following example:

string[] courses = { "OOP", "Data Structures", "Algorithms" };

for (int i = 0; i < courses.Length; i++)

{
Index idx = i;
Console.Write(courses[idx] + ", ");
}
 19 Object Oriented Programming

Indices and Ranges

 Index from end operator (^) → lets you specify how many positions
from the end of sequence, starting with the length

 The following code prints the array in reverse:

string[] courses = { "OOP", "Data Structures", "Algorithms" };

for (int i = 1; i <= courses.Length; i++)

{
Index idx = ^i;
Console.Write(courses[idx] + ", ");
}

The last item in a sequence is one less than the actual length,
so ^0 would actually cause an error.
 20 Object Oriented Programming

Indices and Ranges

 Range operator (..) → specifies a start and end index, and allows
for access to a sub-sequence within a list

 The start of the range is inclusive,

The end of the range is exclusive.

 To pull out the first two members of the array, create ranges from 0
(the first member) to 2 (one more than the desired index position):
string[] courses = { "OOP", "Data Structures", "Algorithms" };

foreach (var itm in courses[0..2])

{
Console.Write(itm + ", ");
}
 21 Object Oriented Programming

Indices and Ranges

 Ranges can also be passed to a sequence using the Range data
type:
Range r = 0..2; // the end of the range is exclusive
foreach (var itm in courses[r])
{
Console.Write(itm + ", ");
}

 Ranges can be defined using integers or Index variables:

Index idx1 = 0;
Index idx2 = 2;
Range r = idx1..idx2; // the end of the range is exclusive
foreach (var itm in courses[r])
{
Console.Write(itm + ", ");
}
 22 Object Oriented Programming

Indices and Ranges

 If the beginning of the range is left off → the beginning of the
sequence is used

 If the end of the range is left off → the length of the range is used

 In the following, all of the ranges represent the same subset:

courses[0..3]

courses[0..^0]

courses[..]
 23 Object Oriented Programming

References
 Arrays, https://learn.microsoft.com/en-us/dotnet/csharp/language-
reference/builtin-types/arrays

 Array Class, https://learn.microsoft.com/en-us/dotnet/api/system.array

 C# Jagged Array, https://codebuns.com/csharp-intermediate/jagged-

array/

 Indices and Ranges, https://learn.microsoft.com/en-

us/dotnet/csharp/tutorials/ranges-indexes

 Index Struct, https://learn.microsoft.com/en-us/dotnet/api/system.index

 Range Struct, https://learn.microsoft.com/en-us/dotnet/api/system.range

 Member access operators, https://learn.microsoft.com/en-

us/dotnet/csharp/language-reference/operators/member-access-
operators
 24 Object Oriented Programming

That’s all for

today!