Why We Start at Zero

Loading...

En provenance du cours de University of Colorado System

More C# Programming and Unity

51 notes

University of Colorado System

More C# Programming and Unity

51 notes

Cours 2 sur 5 dans Specialization C# Programming for Unity Game Development

This course is the second course in the specialization about learning how to develop video games using the C# programming language and the Unity game engine on Windows or Mac. Why use C# and Unity instead of some other language and game engine? Well, C# is a really good language for learning how to program and then programming professionally. Also, the Unity game engine is very popular with indie game developers; Unity games were downloaded 16,000,000,000 times in 2016! Finally, C# is one of the programming languages you can use in the Unity environment. This course assumes you have the prerequisite knowledge from the previous course in the specialization. You should make sure you have that knowledge, either by taking that previous course or from personal experience, before tackling this course. The required prerequisite knowledge is listed in the "Who this class is for" section below. Throughout this course you'll continue building your foundational C# and Unity knowledge by exploring more C# and Unity topics and finishing the Unity game you started at the end of the previous course. The material in this and the previous course is essentially our first programming course for Game Design and Development majors at UCCS. Module 1: Learn how we can store lots of data in arrays and lists and use iteration (looping) to repeat actions in your code Module 2: Learn about abstraction and how we can use it to design and implement console application classes Module 3: Learn how we can use abstraction to design and implement Unity classes Module 4: Add text output (like score!) and sound effects to your Unity games Module 5: Complete final peer review

À partir de la leçon

Arrays, Lists, and Iteration

Lesson Introduction0:32

Arrays in Theory3:47

Arrays in Practice10:17

Why We Start at Zero5:23

Ted the Collector7:02

Rencontrer les enseignants

Dr. Tim "Dr. T" Chamillard
Associate Professor
Computer Science

In this lecture we'll see why we start our array indexes at zero.

And to show you that, I have to show you some hideous, unsafe C# code that I've

never actually had to write in my professional game development career.

So don't show this to people and say Dr.

T told me this is how I should write C# code.

This is really ugly, I just need to use it to show you why we start at zero.

Okay, with that build up, let's go take a look.

Okay, here we are in that hideous code,

and I'll explain why I think it's hideous when we get to that point.

I will point out that I am initializing an array of scores here using

a different syntax from the way we saw populating array element before.

So I don't have to create a new array object by

explicitly saying = new int[5],

if I give it initial values in between these curly braces.

So the compiler is smart enough to realize that if I'm providing five different

values, then it should make an array with five elements and

they're all ints because I declared it that way over here.

So this is another way, if you know the initial values that you want in

your array, this is another way to just populate that array.

Here's where things get ugly.

So you'll notice I needed to mark this block of code that shows what

I want to show unsafe because I'm actually manipulating memory addresses directly,

and that is not one of the things that we usually do in C#.

We handle references and we let these C# one-time system

deals with how that translates to memory addresses.

But I want to actually show you memory addresses here so

I have to mark this as unsafe.

And I actually had to tell the compiler, it's okay that I have unsafe code as well

and there's some extra syntax here with fixed blocks and so on.

Here's the bottom line.

I needed to do this to show you what I wanted to show you.

In all of the commercial games I've built, and

in the two commercial games I'm currently working on, I have never had to do this.

So this was a rare occurrence.

I had to go learn how to do this so that I could show you this stuff,

because I've never needed it in my professional game development.

With that said, let's see what it outputs.

So I'm going to Ctrl+F5, and we can see that scores[0],

the zeroth element in the array, is at this address and it holds 100.

And scores[1] is at this address and it holds 95, and so on.

Now the important idea is, this address is four bytes larger than this address.

As is this, as is this, as is this.

So this makes sense to us if we remember that ints are 4 bytes large in C#.

And so we have to use 4 bytes to store each one,

which is why we're moving 4 bytes as we move between the elements.

The key to understanding why we actually start at 0 though, is that if we

know that we have an array of ints, and our compiler certainly knows that.

And if we know where the beginning of the array is,

then we can actually calculate the address by saying the beginning address of

the array plus the index times however big each element of the array is.

So for example, we're here down at element 3.

So 3 times 4 is 12, and 28, this big long number that ends in 28,

plus 12 is 40, which is exactly where element 3 is.

So we can use, and by we I mean the compiler,

can use information about the beginning address of the array and

the size of each element of the array in the index that it's provided.

And it can do some really quick math and

get us right to the memory address we're trying to get to.

Just to show you that this works for many data types, I will change this

code to store shorts instead of ints and we'll see how it's different.

We'll come back as soon as I've made those changes.

As you can see, the array now holds shorts instead of ints.

And when I run the code,

you can see that the memory addresses change by 2 instead of 4.

Because shorts are only 2 bytes whereas ints were 4 bytes.

And the math still works, so 3 times 2 is 6.

When we add 6 to 408 we get 414, which is exactly where that third element is.

And that's all the ugly code I'm willing to show you for this lecture.

To recap, the reason we use zero as our starting index for

arrays is because the index forms the basis for

a memory address offset from the base address or

the address of the first element in the array.

Explorer notre catalogue

Rejoignez-nous gratuitement et obtenez des recommendations, des mises à jour et des offres personnalisées.

Coursera propose un accès universel à la meilleure formation au monde, en partenariat avec des universités et des organisations du plus haut niveau, pour proposer des cours en ligne.

© 2018 Coursera Inc. Tous droits réservés.

Télécharger dans l'App Store

Disponible sur Google Play