All language subtitles for 9. Using a define

What is going on, guys?

And now that you're familiar with the race syntax, I want you to take a look at one or four previous

challenges where we had to read from the user a seven digits of his phone number.

And then once we've done reading these numbers, we had to find out the maximum value or index, whatever

it was.

So we simply used some for a loop, for a loop to iterate over these seven numbers.

And that was great.

We found everything we needed.

But what will happen if your phone numbers, if your phone number happens to change from seven to,

let's say, eight?

So instead of these seven digits, it was previously, now it's going to be eight digits.

Something like that can definitely happen.

Right.

And that's not a big deal.

But still, you want your program to support such changes in the future that these are things that may

happen and you want your program to be able to find the maximum value or the maximum index of that maximum

value, even if changes like this happen.

So if that's the case, basically what you will have to do in this case is to go over all the loops,

find all the places where you've used the size of the array, which was 17, the previous example,

and simply change these values, one after the other to be eight.

So you would need to change all the places that you have the number of seven to eight.

And that's not so complicated if the program is small like this one.

But what will happen if your program will be hundreds and hundreds and thousands of lines of code?

Will you go and change every line?

Just one by one.

I mean, that's that's totally will be same to do such a thing.

And what will happen if you missed just a couple of places?

You will you may have a lot of bugs.

So that's exactly when the define comes to our aid.

So let's come here, define.

And basically what it allows us to do is simply to define the size of the array in just one place in

our code.

So then instead of using the number seven, which is the size of the array, we used it here at every

point of our program instead of using seven here, here and here and so on, you will be able to use

just one defined value, meaning that whenever the size of the array changes, we will need to change

it only in one single place in our code.

And that will work like Char just changing it in one place.

And it will change everything in the code.

Everything in the program.

So let's introduce the define.

And we can see we can actually see how it's written here.

And these first line we first of all.

Right.

The define the defined word and then we specify the constant value name.

So the name here is size in a right after war.

And we specify the constant value that this given name, these size would have during all of our program.

So this line this line simply means that whenever we will have, we will write these size, define size

value in our program.

It will be we will enter, as we've written here, just the value of seven in this example.

And also here you can see then here and so on.

Whenever you are going to write size, it's equivalent, as you've written, of the number of seven

previously.

And basically, if you wanted to change.

All right.

If we wanted to change right now from seven to eight, the array, these given array.

We will do this just this line.

This line will change instead of size.

Then the value of it was previously seven.

Now we will just change it to be eight.

And it will reflect the changes during all of your programs.

So you will not need to go line by line and change the value of of the array in the loop.

Sand in the declaration phase and so on.

And these translation of the word size to the constant value that you've defined it here happens before

the compilation phase of the program.

Okay.

So that's something we will discuss in the more advanced courses.

Nothing.

This one just bear that in mind because it's important.

And you may be asking why.

Why should we even define size?

This is a constant value and not just use something like in a.

Incise and read the signs using scanner from the user and then defined in a ARAA in these given size

that we read from the user because that's basically not going to work.

This size variable that you will create is going to be a variable.

And we know that a static array expects hearing he's square brackets.

It expects a constant value.

And by default, if you create an variable, a variable and then read from the user, this variable

is going to be, well, variable.

So that will not work.

But you can try it and see what happens on your own.

That's good practice.

And although there is also another option to allocate dynamically.

Which won't be static.

You can allocate dynamically where you allocate an array of a given size that the user specifies at

runtime.

We're probably not going to talk about it also in these course.

But that's important that you will also know that there is two there are two types of fair or four raise

that you can allocate.

One of one of them is the static approach, which you can see here.

It's defined before before you run the program.

And that's why you specified as a constant value.

And there is also another dynamic approach that you can specify how much memory you want to allocate

during Iran time.

So we'll talk about it more in the advanced courses.