Original subtitles

Hello, and welcome to a new section.

In this section, we're going to talk all about advanced data types.

We're going to start with the define statement, which is a

preprocessor directive that really has to just do with constants.

So the defined preprocessor directive, like all other preprocessor

directives, begins with the pound symbol at the beginning of a line.

It can be preceded by spaces or tabs and it also allows for

space between the pound and the remainder of the directive.

So we've seen this before in previous preprocessor directives,

right, specifically with the include preprocessor directive.

There's another one with define.

So in c you can use this directive to define a symbolic or

manifest constants in a program.

It's all about using constants, so when you have

data that doesn't change.

The preprocessor directives run until the first new line

following the pound symbol.

So a directive is limited to one line in length.

The combination the backslash the new line is deleted before

the preprocessor begins, right.

So you can spread the directive over several physical lines if you want to.

These lines still constitute a single logical line.

So make sure you remember what a preprocessor directive is.

It's basically code that runs before the compiler.

So when it sees this preprocessor directive for define, it's

going to be running before the compiler for consonants.

It's a way of telling the compiler something.

In this case, that something is a constant.

Typically, defined statements appear first in the program

usually right at the top.

It's not required to do that. You can put them anywhere you want, but

common convention is right at the top.

Most programmers group their defined statements at the beginning of the

program or inside an include file, a lot of times they're reused.

They can be quickly referenced and shared by more than one source file.

By convention, the defined names are defined using only

uppercase letters and underscores.

So again, you typically see these common conventions.

Here is an example of how you can use the define statement specifically, for

symbolic names to program constants.

So you'd have something like define with the pound symbol, yes,

and again that's all uppercase.

It's only one word, so you don't need the underscore.

And then right after, you see the one, right.

So this is going to define the name yes and make it

equivalent to the value one.

So anytime in your program where you see yes, it's going

to interpolate that yes define and put one inside of it, right.

So it's sort of like just doing the same as doing a search and

replace with the text editor, right.

Whenever you see the name yes, it can be used subsequently

anywhere you need to have constant.

The preprocessor because it runs before the compiler is going to

replace all these occurrences of the defined with its associated text.

The defined statement has a special syntax.

There's no equal sign, right.

So you should have noticed that usually when you assign data to

variables, there's an equal sign.

But remember, this is not a variable, right.

So there's no equal sign when you have to assign one to yes.

There's also no semicolon, right.

So notice those differences.

It's special syntax.

Whenever this name appears, it's defined value of one is

automatically substituted into the program by the preprocessor.

Another example here is if you have game over equals yes since yes is

a defined statement, game over is actually going to be equal to one.

It has the same effect of assigning one to game over.

But it is a little bit more readable, and that's why one

of the reasons you use defines.

A defined name is not a variable and that's why it doesn't use the equals

operator and there's no semicolon.

You can't assign a value to it unless the result of substituting the

defined value is in fact a variable.

So let's look at some defined expressions.

Remember, expression are usually things that return information.

So definition for a name can include more than a simple

constant value, right.

It can be an expression.

And so for example, you could have a define which is named 2

pi as the product of 2 and 3.14.

So you're going to multiply these.

So all you would do is you would say define 2 pi and then right after

the space 2.0 times this number.

And then you'd be able to use this defined name Two PI

anywhere in the program where the expression is 2 times 3.14.

So instead of having to use that -- and again, it makes

it more readable, Two PI.

So you could replace the return statement of a circumference function

with the following statement.

Return two pi times r instead of having to hard code those

constants, even though 2 pi represents a constant.

You also have null.

So the defined name null is frequently used by programmers

to represent the null pointer.

We've used this in past programs.

This is a defined underneath the hood.

It's defined inside standard def.h.

So all you see if you look at that header file is define null and

it's actually 0, represents 0.

So it makes the program more readable as opposed to

putting something like 0.

You can actually say why my pointer is not equal to no as opposed to

why my pointer is not equal to 0.

So much more readable.

So to set up a while loop that will execute as long as the value of list

pointer is not equal to the null pointer, you could do that why

this pointer is not equal to null.

So what are the benefits of using this defined preprocessor?

Well, when you use this defined name for a constant value, it helps to make

the programs more readily extendable.

It also makes them more readable, as I mentioned.

You know exactly what's going on in the code if you see a name

as opposed to some constant.

So for example when you define an array, you must specify the number

of elements in the array subsequent program statements will likely

use the knowledge of the number of elements contained inside the

array to get the size and so forth.

So you're going to see it quite a bit.

So you could just say float data values 1,000, 1000 is

kind of like a magic number.

It's not very readable.

There's a good chance that when you see the statements in the

program the fact that you use this 1000 is not very readable.

You end up using it a lot for iterating through some

kind of size of the array, so you might have a for loop.

So you would use the value as an upper bound for size.

Suppose you had to increase the size of the values from one 1000

to 2000, you would then have to change all the spots in the program

that use that hard coded value.

It'd be much nicer if you had something at the top and you only

had to change it in one spot.

So what you could do is a better way of dealing with this array

bounds is to define a name and use the preprocessor directive

for the upper array bound.

So something like maximum data values and then setting that to 1000.

Now anywhere in your program, you can use maximum data values

when you declare the size of the array or inside your loop.

So if you're going through an array bound, you can just

say maximum data values.

And now if maximum data values changes, all you have to do is change

it at the top, the define statement.

So if you want to change it to 2000, you simply say define

maximum data values 2000.

So when the program is written using this preprocessor director

define, in all cases where the size of the array was used, it's

automatically going to be updated.

So that define could be the only statement in the program and you

only have to update it once as opposed to everywhere else using it.

Another nice use or another benefits of define is that the

defined statement helps make programs more portable from one

computer system to another.

So, it might be necessary to use constant values that are related

to the particular computer on which the program is running.

A lot of times we have data types and data types are different sizes

depending on if you're running on a particular architecture.

So it might have to also do with particular memory address,

file name or the number of bits contained in a computer word.

If you want to execute a program on a different machine where an int for

example is 64 bits versus 32, 4 bytes versus 8 bytes, you can basically

use the define to set this value.

So in situations when the program must be written to make use of

machine dependent values, the defined statement would be ideal.

Because it can help isolate the machine dependent values

from the program as much as possible, which makes it more

portable to another machine.

Now you may be asking yourself when should we use define versus

constant because c has a nice little keyword called const.

And so normally, if you define pi equal to 3.14159,

this is going to define pi as a symbol and the preprocessor is going to go through

all the text and replace it with that value 3.14 anywhere it sees the names pi.

Now you could have defined pi as a variable, but to tell the

compiler that its value is fixed it must not be changed, so we

could use something like const.

So you can fix the value of any variable when you declare

it by prefixing the type name with the keyword const, so we

could have done const flow pi.

This defines the value of pi as fixed, has the same effect as

using the preprocessor directive.

So the advantage of defining pi in this way is that you're now

defining as a constant numerical value with a specified type.

When you use define, pi is just a sequence of characters

that replaces all the occurrences of pi in your code.

Constant is sometimes preferred because it does

do the data type checking.

So you're going to see define preprocessor all over the place

again usually at the top of the file to represent constant.

Just remember, it has the pound symbol so it's a preprocessor

directive and it's just used to assign constants to names, makes the program

more readable and more portable.

Thank you.