All language subtitles for Learn C# Programming – Full Course with Mini-Projects (English_ASR)

this comprehensive C course will take

you from the basics of C programming to

advanced concepts all while integrating

exciting mini projects to solidify your

learning this course offers a structured

path through essential topics such as

syntax object oriented programming data

structures and more ABA teaches this

course and he will help you understand C

both theoretically and also gain

practical experience in applying your

knowledge to real world scenarios hey

there free ABA here join me in Walking

you through everything you need to get a

setup with cop let's have a quick walk

through the course contents to let you

know what to install for you we'll start

with installing the visual studio

program required to develop C

applications you'll learn about data

types including integers strings and

many more and how to manipulate them

inside your code next we'll dive into

control flow you'll discover how to use

conditional statements and Loops to

control the flow of your program's

execution strings are essential in many

applications you'll Master powerful

string functions in C allowing you to

manipulate and transform Text

effortlessly data structures are crucial

for organizing and managing data from

arrays to collections you'll explore

various data structures in C and learn

how to use them effectively functions

are the backbone of any program you'll

uncover the power of functions in C

including how to create and call them to

organize your code no program is immune

to errors you'll learn how to handle

exceptions gracefully in C ensuring that

your applications remain robust and

reliable debugging is a crucial skill

for any developer you'll discover how to

use visual studios's powerful debugging

tools to identify and fix bugs in your C

code efficiently finally we'll delve

into object-oriented programming you'll

learn the principles of object-oriented

programming how to use classes objects

inheritance and polymorphism to create

modular and maintainable code by the end

of this course you'll have a solid

understanding of C programming and be

well equipped to tackle a wide range of

software development challenges thanks

for tuning in let's get

started so in order to start developing

with C we need to install the latest

version of visual studio in this case

it's currently 2022 so let's head over

Google and type in Visual Studio 2022

download we will be presented with two

links we have this one and this one we

want to use a second one which says

download visual studio tools so if you

press on that and now will present it

with the download area we have three

additions Community professional

Enterprise Community is free for

students open source contributors and

individuals which is exactly what we

need for the content of this course we

have the professional Enterprise Edition

which paed for and only used by bigger

companies or smaller teams so let's go

ahead and press free download the

download will start straight

away after the download is complete

let's start the installer so double

click on the executable and press yes to

allow it for admin permissions it'll pop

up like this Visual Studio installer

before you get started we need to set up

a few things you can configure your

installation you can read the privacy

policy in the software terms if you'd

like or you can just press continue so

it's getting the visual studio installed

already so so when you get to this

section everything here is all the

different packages and tools you can

install within Visual Studio 2022 the

main one that we're concerned within the

content to this CA is the neck desktop

environment so you can go ahead and

press this one it will then tell you in

the bottom right hand corner the total

space required is 6.52 GB please make

sure you have enough storage space

available for this and then you can go

ahead and press install if you want to

check out other packages you can have a

scroll through and read any other

packages you may need and may want to

install like I said the the only one

required for this course is the net

desktop

environment you can also deal with noj

development python development web

development if you need to deal with

individual components like specific

versions you can access it here if you

need some more languages installed you

can access it here this should

automatically select your default

language for you that's based on your

systems language and if you want it to

you can also change the installation

location in case you want to install it

on a different drive or you just want it

in a different folder so now that we

selected the neck desktop environment

we can go ahead and press the

installation button we do have two

options down here we have it install

while downloading and a download all

then install if you have a reasonably

fast computer you can stick with the

install while downloading and it will do

the installation and the downloading at

the same time if you have a slow

computer it's preferred that you use

this option to download it first and

then install it just means that it won't

slow down your computer too much so you

can go for this one and press install

now the installation will begin so now

that Visual Studio is finished finish

installing it will say done installing

Visual Studio has been successfully

installed we recommend rebooting soon to

clean up any remaining files so this

just means restart on your computer just

so it has a chance to clean up any files

that were kept during the installation

process so we can just press okay if you

have any other the versions of Visual

Studio installed they'll also show up

down here and now that Visual Studio

Community 2022 is installed we can just

press

launch so now it'll prompt you to sign

into Visual Studio we should definitely

sign in but just for now I'm going to

skip but feel free to create an account

or sign in if you already have one

existing we can skip this and then we

get to choose your theme I personally

prefer the Dark theme but you can go

with blue blue extra contrast or the

light mode so let's select dark and hit

start Visual Studio it will do a first

time

setup and it's already done and we're

already inside Visual Studio 2022 so

that's it for the visual studio

installation so now that we got Visual

Studio 2022 installed let's see how to

create your first project so once you've

opened Visual Studio 2022 you'll see

this window popping up you can clone a

repository from things like GitHub in as

you devops or open a project that you

already have or open a folder which may

have projects inside or you can create

one from scratch if you don't want to do

any of these options you can just open

the visual studio program just on its

own by clicking continue without code so

let's go down the create a project path

so click on create a new project and

we'll get a list of all these different

projects inside our system to be able to

use the ones we're going to be be

focusing on on this course is going to

be C in the languages dropdown box and

the platform is going to be windows and

the project type is going to be console

and they have one that uses net core

which is for Linux Mac and windows and

one that uses the Net Framework which is

Windows so we want to go for this one so

press on this one and then press

next here we have our project name our

location and our console app so we can

start with the project name and say my

first

project as you can see it'll start

copying over to the solution name as

well and it tells you where the project

will be created into so I'll be creating

a folder called my first project which

is the solution name plus my first

project which is the project name inside

that folder if we change the solution

name you'll see update you can see here

now we have multiple T's because we

appended the solution name the solution

name is almost like a folder that holds

lots of projects inside so to begin with

we'll have one solution that has one

project inside and then later on in the

course if you feel like you want to add

more projects to it you can just add

more to this solution so let's get

started and press

create so now we've created our very

first project and just to explain what's

here we have a static main void which is

the main entry point to our program if

you do a lowercase M then the system is

not going to recognize this main

function because the down NET Framework

requires this function to be found in

order to run a c console app and you can

see here in the errors the program

program does not contain a static main

function and you can see it's capital M

and C programming language is K

sensitive so make sure to include it so

now you understand how to use Visual

Studio 2022 to create a project and also

know where the main entry point is in C

let's get started with a Hello World

example to kick off this

course so as we know our main entry

point to our application is the static

void main if we go inside here and press

enter then we can actually start writing

some code inside here just a quick note

before we

continue static void main is inside the

class program and the class program is

inside the namespace hello world and the

reason why you can tell this is because

of the curly braces the curly braces of

hello world begins here and ends here

and Within These curly braces we have a

class program and also within the class

program we have the styo

men so just between these curly braces

we want to type console. right line or

open the brackets and we can type in

some speech marks and we can simply Type

Hello World there you go so as you can

see now system has actually been

highlighted so if we just delete this

line you can see now system has been gr

out and the reason why is it says it's

unnecessary because it hasn't been

used so if you undo it then this comes

up because I showed you before that

console right line is actually within

the system Library what happens if we

delete

it if we delete it then it doesn't know

where console exists from and because

that just said system we can actually

just use system. console. right line and

then open the brackets and type in hello

world and now this works again and the

reason why this works it's because we

don't have to Define that we're using

system we could just use it straight in

here if you have multiple lines like

this then you don't want to be using

system right at the start ideally you

want to have the reference to it at the

top of the screen and then use it

throughout so now that we've included

back in the project you can see that now

these have turned gray and it says that

it can be simplified if we press the

little light bulb and we can say

simplify member and it doesn't really

matter because we can just delete the

rest now so now that we've WR hello

world let's press F5 which is a shortcut

to the start

button as you can see well you couldn't

really see because the program closed

too quickly and the reason for that is

printed hello world to the console and

then it didn't do anything else cuz

there's nothing else for it to do so the

console simply

closed we can use another command called

console read Line open the brackets and

close the brackets and have a semicolon

at the end all this does is it waits

here until the user inputs something

reads the next line of characters from

the standard input

stream so although the program will

actually be reading stuff we just want

this line to stop the application from

closing so now if you press F5 and run

the program you can see it actually says

hello world and it's just waiting here

flashing and this flashing means it just

started this console read line so it

doesn't matter what we type into here it

just WS for us to press enter and it

soon as we press enter this line

executes and the program finishes

congratulations you just wrote your

first C program welcome to the amazing

journey of

programming so let's look at how to make

VAR Ables in our C code let's start

every code with a console read line and

then we can hit F5 just to make sure our

console doesn't

close so let's begin with an integer so

integers are whole numbers so we can

just say int age equals

23 so what we've actually done here is

we've said we want an INT we want to

call it age already made it equal to 23

this is called initializing and

declaring in the same line

so what you could do alternatively is

you can end the semicolon here and it

just says int Edge and then on the next

line you can write ede equals 23 so this

is declaring it in the first line and

then give it an initial value in the

second line if they're right underneath

each other like this case then you may

as well just make it together because

then you have less lines of code the

reason why it says it's a green under

line it's because it's the unnecessary

assignment because we're not actually

using ede so let's just point age to the

console if we make some new lines and we

can type in in console. right line and

then press tab to finish it we can write

Edge and if we run our code using F5 we

can see that 23 gets print out to the

screen so now that we've worked on the

Edge Let's explore all data types let's

define a long variable so let's start

with the type long followed by space and

then the variable name that we want and

let's add equals and type in a very big

number so now if we hover over it it

says it's a system int32 and int32 is

actually an integer but we're telling it

it's a long which makes no sense we have

an in 64 here but when we hover over the

number it comes up as n32 and the reason

for that is when C sees that you just

have a number typed in like this you

will always assume that it is an integer

to tell the compiler that you indeed

want this to be processed as a long

number then you can put a capital l

right at the end now if we hover over it

it says in

64 and this says in 64 so now we've got

it working and we've got the long there

so now we can take another console right

line and just print this out to the

screen and just a helpful tip if you

type in CW and press tab twice then you

get the console right line it's very

easy to write your code and then you can

type in big followed by a tab and it'll

come up straight away so as you can see

they're both being printed to the

console

now so now that we've made positive

numbers we can also make these negative

by simply just putting a negative sign

behind them there we go and just to to

show you how big these numbers are what

we can do we can type in int. max value

and then make another one using contr D

and type in int. Min

value so you can see integers can be

positive 2.1 billion or netive - 2.1

billion and if we do the same for

long you can see that long is a very

very big number because instead of being

an INT 32 it's an in 64 which which

takes up a lot more memory so now we've

covered whole numbers let's have a look

at decimals so we can have a double

negative for example and we can say it's

-

55.2 and in this case when you just have

a number typed in like this and it's got

a decimal point in it it will always

register it as a double but just to make

sure just as we're doing with the long

you can actually just put a capital D at

the

end now if we print this out to the

screen and also print out how big these

numbers can

be max value and Min value and print

this out so we get our minus 55.2 and

you can see that these numbers can be

very big e+ 308 means it's this number

times by 10 the^ of 308 which is a very

big number and we also have that as a

negative so we have float let's call

this precision and make equal

5.1 and then put a semic call the end

now we've got a problem here this is

trying to register as a double but we

don't want to register a double we want

to register as a float and this is the

same issue we have the long so when you

type any number that has a decimal point

in it the C compiler will always

register as a double the same way when

you type in a whole number it'll always

register as an INT so in this case we

need to put a capital f at the end and

it'll process this as you

float so now we can print this

out and then let's just print out the

max values and the Min values just to

show you what that looks

like so as you can see here we have our

number printed out and again we have

quite a big number 3.4 * by 10 to the^

of 38 so again it's a big number and we

have that positive and negative so quite

a big range of

numbers and the last one we're going to

cover is decimal for things like money

and currency

14.99 and again in this case it's trying

to assign a double into a decimal so in

order to denote what a decimal is you

can put a capital M right at the

end and for one last time let's print

out the

money and the decimal. max value contrl

D and then we'll do Min

value and you can see here that this is

a really big number as well and it's

even bigger than the

long so we have our number printed and

the Max and the minimum values so now

that we've understood that how to

declare a variable I have an extra

little tip for you so if we had three

variables int X an INT Y and an INT

Z and let's say you're always going to

declare them together like this you can

actually miss out and do X comma y comma

Z and that will do exactly the same

thing there you go and that's really

neat and it's a lot better let's say for

example you had these variables but you

actually had them set to something like

equals 10 equals 20 equal 30 this is

still practical but it might look a

little

uglier so you can actually type them in

straight into here and if you comment

these out again then it still works you

can even put these onto new lines like

this just so it looks a bit neater just

prevents you from typing the additional

int each time if they're all going to be

the same variable type so that's it for

the numbers inside our code so let's

just have a quick recap so in order to

Define a variable you want to use the

data type in this case an integer

followed by the variable name and then

you can either add a semicolon at that

point or you can add equals to give it a

value this is just called declaring a

value and this is called initializing a

value if you want to decide you want to

change the variable further down your

program for example age equals 50 here

then this is fine and this is now called

an

assignment it's called initialization

because as soon as you make it you give

it a value and then in later on in the

code if you give it another value this

is called simply assigning a value this

is just called assigning it a

value so now that we can store numbers

in C let's see how we can store

characters and letters so as you know

from the introduction we have a string

variable so let's call that name and

make it equal to

Aba please note that when you're

defining a string and giving it a value

that this value needs to be in speech

marks if you put it in quotation marks

it will not accept this because that's

the notation to declare a Char which

we'll get on to next so on the next line

we can do a Char letter equals and we

can't have something like this because

the Char will only accept One Singular

character so we have to wrap it around

the quotation mark once you've wrapped

it around the quotation mark then it

will accept it so let's print these two

to the screen so CW tab tab and we can

just print these to the screen and if we

just run the code you can see that we've

got the values entered in

here we can start to write

stuff your name

is and then we can output this and we

can also put it on one

line if we do a console right and a

console right then maybe we can take the

callon off and just have it space and we

can say your name is ABBA and we' see

that additional a because that's the

right line for the letter so we can

space it out with an empty console right

line and and they'll add a gap between

them both there we

go so now we know how to declare a

string variable and give it a value and

we can declare a Char variable and also

give it a value just a quick recap when

you're declaring and initializing string

variables you need to put the value in

speech marks but when you're declaring

and initializing a Char you don't have

to put it in speech marks you put them

in apostrophes whenever you see

apostrophes that that can only ever

refer to One Singular character when you

see a speech mark it could be one or

more characters

also things can be empty this just means

the string is empty this is also a valid

character it just means that we're

storing a string but it has no value

with a Char that's not exactly the same

you can't store an empty character

literal it has to be given something

Charles get defaulted at back sl0 which

is just a default character but don't

worry about that too much now we'll go

into Escape characters which is the back

SL layer on in the course for now just

note that whenever you declare a string

variable we need to put it in the speech

marks and when we declaring a Char

variable we need the quotation

mark So now that we know how to define

numbers in C and to also Define strings

and characters then let's look at how to

convert between them both so let's take

some similar code from our first video

and we can Define it age the number the

negative the Precision and the money and

we give it the same values from the

first video we simply just print them

out to the console here and if we just

run we can see them all but this doesn't

help us cuz we're just statically typing

in the numbers what if these these will

actually process a string and we want to

convert them into an INT so just above

each of the variables we're going to

make another variable so we can say a

string text age equals

-23 and then for the age what we're

going to use is this function called

convert to int 32 and we can put in the

string inside the brackets and what this

is now saying is we're taking our string

text Edge which is equal to -23 and

we're passing it into this function

convert to in32 and the reason why it's

in 32 is because an INT is by definition

an in32 which is a 32bit signed integer

so what we want to do here is convert

for our text age into int32 and store it

back into our int and hopefully we

should see the same value when we hit

run 23 so now that's actually went from

a string variable and then went into our

integer and we've printed out as an

integer and it's no longer a string

variable now we can do the same for the

other ones so we can have a string text

big number and make it equal to this

value just in the quotation

marks now we're typing this value in the

quotation marks we don't need to put the

L at the end the L is just to tell the

compiler that we want to use in 64 if we

take the L away then it's going to think

it wants in 32 this is not re applicable

when it comes to text because we're

going to explicitly stay on the next

line we want to convert to N64 so the

compiler already knows that it's in 64

for and we don't need to put an L at the

end now let's make sure this works and

there we go so what we should end up

with is the console should look exactly

the same as how we had it at the start

of the video but actually what we're

doing is converting it from a string

into the applicable value string text

negative equal -

55.2 and then in here we can do convert

to double add the text negative inside

here and let's just run it to check

and we still have the same value so it's

going well have a string text

Precision make it equal to

this and then instead of this we can

have a convert two and in this case it's

actually going to be a single and the

reason why it's a single when you hover

of a float the definition for a float is

indeed a single so we can add that in

text precision and we're just going to

do the last one and just check it out Al

together text money equals

14.99 and then instead of this we can

have a

convert and let's have a look at this a

decimal is indeed a decimal so we can

say two decimal and then add the text

money

in perfect now if you run the line of

code we can see that all of these values

are exactly as we had them now they're

being represented by their official

descriptions Based On A String

conversion as I mentioned before in the

error video the problem you'll have with

this is if this value actually has a

character inside you will get a runtime

error this can be fixed in the future

when we look at how to resolve these

errors and we can have exception

handling and use functions like try pass

so we can try and avoid these exceptions

occurring because when these exceptions

occur the rest of our code does not run

and it becomes fatal at this

point but for now don't worry about this

too much just get used to the notation

and how these things

work so this is video we're going to

focus on the Boolean data type so we can

make a Boolean data type by saying Bo

value equals

true this Boolean value is literally

just a true or false value we can store

anything in here and maybe something

like bull is M and we can just say it

true and later on our code boings are

used to make decisions we'll cover this

in the next section of this course but

boings are mainly used for making

decisions if one thing is equal to

another thing then we can take another

path or if something is true or

something is false then we can do

another path for example if you make an

output to the user you could check if

this value is true and if the value is

true then you can address the user as a

male and if the value is false then you

can address the user as a female these

are the kind of things that booleans can

help us with and just like any variable

if you want to assign it later on you

can just assign it again and if we print

these out to the

screen just like that you'll just see

the value is true and the value is false

appear on the screen as of right now in

the course there's not a whole lot to do

with boing just understand that they can

hold a true or false

value so now that we know how to define

different variables and how to convert

between them let's see how we can

perform operations on different data

types let's say we could have an INT age

equals 23 and then what we can do to

that age is we can say Age ++ and what

this age will do is it will actually

just increment age by one and if we do

age minus minus it will decrement it by

one so if we just print it out after and

after this as well what we'll notice is

there'll be no change because it'll go

forward one and then back one there we

go went from 23 plus plus to 24 and then

minus minus to

23 that's one of the important operators

that you'll see a lot especially during

the next section of this course so

another way to be able to add one to a

variable or anything to a variable we

can replace this with age equals age + 1

and what we're seeing here we want age

to have the value of itself added to one

which will give us the same result as

doing h++ another way of writing this is

a quick shorthand is you can say AG plus

equals 1 these three things are doing

exactly the same thing when you do an

age Plus+ you can only increment by one

and only one these two options give you

the flexibility of having something like

10 these two are doing exactly the same

a AG equal AG + 10 and this is going to

read exactly the same thing it's is when

you use plus equals it will take the

value of the current variable and add it

to 10 which exactly what this line does

to make it a lot shorter you can use age

plus equals and then just put the value

at the end just in case you forget to

mention age twice so now if we just get

rid of these two lines of code and we

can just have a look and see if this

runs so now the value should be 33

perfect and now as we said we're going

to cover plusus time and divide so just

as you did with plus equals you can

actually do a minus equals as well which

will give us 13 and you can do a times

equals which should give us

230 now if we try to do divide equals

we're going to run into an

issue it says

2 23 / 10 is

2.3 and when you take 2.3 and make it

into an integer it's just going to

truncate the3 and leave you with two

with integers if you add two integers or

take away two integers or times them

you'll always end up with an integer if

you divide two integers you don't know

what you'll end with for example if you

make this into 20 then you'll always end

up with two but that's not always the

case as you just saw 23 / 10 is 2.3 so

if you're ever going to do any division

it's best to actually make this a double

cuz now that we do the division we

actually get 2.3 which is technically

the right value so you can add minus

times and divide any variables that you

want these are just demonstrated in int

and double but you can do this the Flor

the decimal Etc so let's have a look and

see what the plus and the minus

operators do when you've got a string

variable so we can have a string name

equals

abber and then we can say the name plus

equals is

programming and then we can just print

out name to the screen and see what

happens there you go you've actually

just joined two strings together they're

completely separate from each other and

we've made them string

together so if we try to do a minus

equals you can't really remove from a

string because a string is just text

it'll be very difficult for the compiler

and for the C language to be able to

determine what's currently in the string

and whether you can remove it or not

this is not something that's built into

the language this is not something

that's built into the language so let's

remove that and we can have the same

thing with the

CH now the problem with the ch

is if we add a to B then let's see what

happens to the

output what it will try and do is

actually get the uni code values for

both of these items and try and add them

together as integer

variables so when you add a and b it

will take the unic code value and you

will actually get a capital A with a

squiggle at the top and if we open

character map you can see that this

squiggle at the top is right here a

which is unic cord 61 and 61 actually

means 97 because it's 6 * by 16 + the 1

and b means it's 6 * 16 which is 96 +

the 2 so you have 97 and 98 and if you

add them two values together you'll get

the hex code which is C3 just for this

character so what you're doing is you're

kind of adding them both together and

you're producing weird results so unless

you really want to do this then you

should be worryed about adding two

characters together one more thing to

note about when you're doing Plus+ let's

bring another int variable and we just

say int I equals z then we can do I ++

and then if we print out I the value

should be one which is fine what if we

did

i++ but we did Plus+ I so the value is

still going to be one but what happens

if we put this I ++ straight into these

brackets let's try and run it and you'll

still get the value of zero that's

strange because we've said I ++ and what

happens when you do Plus+ at the front

it will actually execute this and return

the value of I and then do the Plus+ so

if you actually print the value of I

after you'll realize that now it becomes

one after if you ever had a situation

where you need to increment first and

then use the value you can use plus plus

I now if you run it you should see the

value is one twice the difference is

that as the plus plus is before the

variable name it tells the compiler

please do this action first and then

return back the I if you don't want that

behavior then use I

++ finding the remainder between the

division of two integer variables can be

very handy when you're determining

whether a number is even or odd let's

look at an example let's have it in

first Nome design the value of 10 and in

second Nome and give it the value of

three now if we just printed the screen

first num divided by second n what do

you think you'll get so the value of

this in the calculator will be 3.3

reoccurring so we'd actually just get

three because it's truncating it because

of the

integer so now what happens if we need

the remainder between both of these you

could actually work this out by seeing

how many times three would be divided by

10 as close as possible and you see the

value is three and then 3 * by 3 is 9

which will give you one left over for

the 10 but that's a bit too long in our

code so we have something called a

modulus operator so we can actually

change this divide for a percentage sign

and what this will output is it will

only give us the remainder so let's say

10 / 3 is

3.3 as we've just said but the remainder

is different remainder is exactly how

you learned it at

school 10 / 3 is actually 3 remainder

one because 3 * 3 is 9 and then you have

one left over to get 10 so that'll be 3

* 3 which is equal to 9 and then one

left over to get to 10 so now let's run

our code and see if we do actually get

one there we go so the best way to

determine if a value is actually odd or

even is to divide it by two so we can

say 10 modulus 2 and if the value is

zero then that means the value for first

nor is actually even if the value is one

then it's OD let's see how this works

out if we had 10 modulus 2 then the

value is zero because 10 can be

divisible by two perfectly let's say we

had 11 modulus 2 the closest multiple to

11 is 10 which is 5 and then we have one

left over so you just have the remainder

is equal to one and if we just keep

going up in the chain we'll realize that

it's the same pattern every single time

you go up a value the value just toggles

so when we print this out to the console

and the value is actually zero that

means the number is even and if we make

the number odd on purpose and then rerun

the code you can see that it's a number

one now which means this value is now

odd let's look at a couple examples and

see if you can figure out the answer if

we do a th000 modulus 90 what do you

think the value will be and let's write

a couple more if we do 100 modulus 90

and maybe something like 71 1 modulus 10

so have a think about this in your head

and see if you can figure out the

answers pause the video and see if you

are

correct let's take a look at the

answers so we can see we have 10 10 and

1 so the closest multiple to 1,000 from

90 is

990 so we have 10 left over to get to

1,000 and the same goes here the closest

multiple of 100 to 90 is just indeed 90

so we only have 10 to get from 90 to 100

and in this case the closest multiple of

71 to 10 is 70 and we have one to get up

to 71 therefore these two answers are

indeed

correct so now that we know how to

really Define a variable by specifying

their type follow by the name and giving

it a value let's see how we can do a

very easy way of defining a variable so

normally we would type in Edge what we

can use this VAR keyword what this means

is the compiler will figure out what

type it needs to be based on the value

we initialize it with so if we just make

a variable called age then it's not

going to like it because you need to

give it a value this doesn't give the

compiler enough information to figure

out what this variable is going to be

just because it says age this is just

text to the compiler this does not mean

anything so if you make it equal to 23

then the compiler can see that this is

indeed in 32 because it knows that so

now if you hover over a VAR it says in

32 now let's try and do this for the big

number

our big number equals

90,000 and what will happen now is

because it's Define as in32 it's going

to say this is in32 as well and this is

the same issue we had we'll move first

defining the long variable in the first

video we need to explicitly give it an L

just so this knows that it's N64 and now

the VAR has updated to an

N64 instead of rewriting each one we can

just change each of v and inspect what

happens double

double and now we have a float single

single and finally the decimal we have a

decimal and we have a decimal and the

same thing goes for a string we can say

VAR name equals ABA and we can have a

VAR letter equals a there we go and

they'll both register as there pickable

data types as a string and as a Char and

if we just print this out to the screen

to make sure everything's working fine

and run the code you can see that

everything is exactly how we'd expect so

just a quick recap you don't have to do

this at the end of the day this will be

exactly the same as writing this because

when our code gets compiled down it

doesn't matter what these things are cuz

the compiler will deal with it however

way it wants to this is just for us to

read it in some cases if the value is

very obvious like as we know an age

cannot really be a point 23.1 years old

no one says that in real life when you

get asked your age so we can just assume

that this value is going to be in an

integer and that's fine because that's

an easy number that's an easy example

but if we say we want a negative or a

big number then it doesn't really tell

us what we're meant to be like this big

number could be somewhere up to 2.1

billion which is what an integer

supports but in this case if it's going

to be a big number and we specified the

L then we're going to need a really big

number bigger than 2.1 billion so in my

honest opinion it' be very beneficial to

only use VAR if it's very obvious what

the variable is going to be and want

it's being assigned to using VAR too

much might hurt the readability of your

code in the future because you have to

inspect each variable individually to

read what the type is going to be if

you're scrolling through your code and

you can see that this is along very

quickly and you don't have to hover over

it then it can improve your read time

this is really important as readability

of code will make more sense when it

comes to Big projects when you have 20

30 lines just like this project then it

makes almost no difference cuz it only

takes a couple of seconds when you have

big functions big software when you work

at a job then it's going to be very

difficult to be able to find your way

around and to understand what's going on

especially if you're new to the code

something very simple like this where

you know you're defining a name it's

very obvious and VAR will be accepted

fine because you can tell that this is

always going to be a string there's no

other data type in C get specified by a

speech mark whereas when you're defining

numbers it can be very very hard to

understand what different data types

that people are using throughout the

code especially when these numbers are

not of statically typed in they might be

inputs from the console from the user

from a different function from anywhere

so having good variable names along with

their explicit types will be very handy

to understand code in the

future so now that you've understood how

to make a variable let's look at a

concept called constants so we defined a

variable called vat and we set it to 20

just to represent the 20% V in the UK

now later on in the program we can

actually change it to anything we want

and that's because it's a variable

variables can change in certain

circumstances like vat you might not

want to change it and you want to

disable the ability to change it to the

code if it's done accidentally let's say

for example you're making a banking

application and you wanted to fix the V

and you don't want anyone else to change

it you can add this keyword called const

right before the Declaration and now

when you go to reassign it you'll get an

error message and it says at the left

hand side of the assignment so anything

before the equal sign has to be a very

Able Property or indexer and in this

case if you hover over vat it states

that it's a local constant local because

there's no access modifier before it and

constant because we specified the con

keyword so now if we try and run the

code we'll actually get a compile error

because the vat cannot be changed so if

we remove that and then we just print it

out to the console using CW tab tab and

then we can put vat in the brackets and

press F5 and now we can see our 20 being

printed

so let's try and calculate some values

using this code if you have an INT

balance make it equal to 1,000 and let's

say we wanted to calculate the vat based

off this then you'd have to do a little

bit of a complicated calculation you

have to take the balance and because the

vat is a percentage we need to convert

it from decimal to percentage so if we

do times and then open the parentheses

we can insert

vat divided by 100 and just to make sure

that this gets process as a double we

want write 100 D cuz right now it's in

32 and if we leave this as an integer

division then we'll lose any decimal

places and decimal places are very

important when it comes to percentages

so we put a 100 D at the end now you can

see it says double so it'll actually

calculate as if it was a decimal number

so now if we print that to the screen so

we can see here that 20% of the balance

is indeed 200 instead of having to do

this calculation each time what we can

actually do is make another const this

time making a double because we're not

sure what the output of this division

will be and we don't want to truncate it

so we want it as a double and we can say

percent vat and what we can do here when

we assign the value just because it's a

constant it means that we can't change

the value but that also means we can

read it as many times as we want so we

can say the percentage V is actually the

current V that we've got specified here

divided by

100d this will give us the vat from a

number form into a decimal form form so

now when we do this calculation if we

duplicate this line using contrl D we

can remove these entire brackets and

literally replace it with percentage vat

and you should see we get the same

values

perfect this can be very helpful in the

future if you have things like version

numbers in your code you can have

version 1.0 and then if you ever specify

this version later on in your code you

can just change it once up and it will

change the rest this can be very helpful

you'll avoid a lot of typos and you

won't have to to redeclare this value

several times if you had three different

occasions where you displaying the

version number in your code then it's

going to be problematic once you update

the version number and you have to

change every single occurrence and you

might miss them so inserting it once and

only having to change it once is the

preferred option just to note with

constants when you compile your code all

the constants will actually do is do a

find and replace so it will take this

vat and find all references of v and

just drop the 20 in

there so this is more of a feature for

maintaining your code from a user and

programmer's perspective rather than

anything to do with the compiler because

when it compiles it just removes all the

constant anywhere and then you're left

over with the literal values that we've

gave it nonetheless this is still

something very handy to learn and to use

throughout your

code first you want to Define a variable

to hold your name so we can just say

string name equals abber perfect so

that's the first one achieved says

Define a variable to hold your phone

number number so at first this could be

quite easy we could say int number

equals and then we can start to type our

number in here so now that's our number

completed let's move on to holding your

age and we can just have an INT age

equals

23 print variables line by line to the

screen so we can use CW tab tab and type

in name and we can use contrl D to copy

and paste the line then we can do number

crl D again and then we can use ede now

if we run the code let's see what

happens

here we've actually hit a slight problem

it says 1 2 3 4 for the number but I'm

pretty sure that I started it off with

zero this is a problem with storing your

number as an integer as a number zeros

at the front don't really matter if we

had a 100 zeros here then it's not going

to change the actual value the only time

zeros matter is if it's throughout the

number or towards the end that actually

changes the number but if we have lots

of zeros at the start then it doesn't

change anything so what you actually

want to do in order to store a number is

you want to store it as a

string therefore when you run the code

it will actually rain the zero that we

typed in so now that we've accomplished

all of these let's see how we can Define

the variables using the VAR keyword so

if we hover over these you can see that

it's picking up that it's a string and a

string here and finally this is an

integer so what we can do very simply is

just change these to VAR and then let's

hover over the variables and just see if

the tool tip reads the correct data type

string string and integer and if you run

the code you should see no

difference so in this exercise I want

you to create and initialize two integer

variables make a variable to work out

the remainder output the remainder to

the screen and then change the first

integer variable to another number

recalculate the remainder and output the

new remainder to the screen so let's

take this step by step so first we need

to create an initialize two ins let's

say int num 1 equals to 10 int num 2

equals to two make a variable to work

out the remainder so we can have an INT

remainder equals to and if you remember

how to do the remainder it uses the

modulus symbol which is the percentage

sign so we can say num one percentage

num

two now it says output remainder to the

screen so we can use CW tubtub add

remainder in and hit run and just for

now we can see that the remainder is

indeed zero if the remainder is zero

then that means 10 is even because 10

modulus 2 gives a zero and if it's zero

then that means it's even if the

remainder was one then it would mean

it's odd so if we try 11 remainer two we

get one so 11 is indeed an odd number so

let's change this back to 10 and then it

says change the first into variable to

another number so just after here we

could say num one equals 11 and then

recalculate the remainder so we

essentially just need to do this section

again and we don't need to write in

before these two variables cuz int is

only use when you're declaring it this

is reassigning the

variable so we'll reassign variable num

one to 11 and then we reassign the

remainder to the calculation again and

now we can use the exact same line of

code above to print out the remainder to

the screen now you can see that it's 0er

and one it's zero because 10 is even and

it's one because 11 is

odd so far throughout the course we've

been using console right line to Output

stuff to the screen for example I can

output hello my name is Aba and we can

see it in the console the issue is so

far we haven't really brought any code

to be able to read in values from the

console so let's explore that option

right now so in the console Library we

have a console right line but what you

don't realize is we can also use this

console right line to ask the user a

question and to let the user type

something in so let's use CW tab tab and

say enter your

name with a callon and then end the

quotation

marks and then in order to return a

value from the console into your program

we need to use console.readline and if

you hover over readline let's have a

read at description reads the next line

of characters from the standard input

stream perfect this is exactly what we

want to do right now it's use at the end

of our code code just to stop the

console from closing so we can actually

see the output so if we just run this

right now we actually get the

opportunity to type but when we press

enter our program closes this is because

in this case we're simply using readline

just to wait until the user has pressed

enter so so our program doesn't close

but what you don't actually see is this

is returning as a string which means

that anything that we type into here and

when we press enter it actually gets a

return back to the code but we're not

doing anything with it because we don't

care at this point so now let's actually

do something that will make us care

about the user's input so we can make a

new string variable and assign it to

console readline and it should give us

the ability to store Whatever Gets

entered inside the console so we can

just do string name and we can end the

semicolon here and if you wanted to on

the next line you could do name equals

console do

readline or if you wanted to have it all

in one line then you can get rid of the

semicolon and bring it up like this this

is the preferred method as both lines

were on top of each other and it wasn't

really necessary to split them here

we're doing a declaration of string name

and an initialization and given it the

value of console. readline and this is

whatever value the user is going to type

in let's run our code and see what

happens enter your name abber now when I

press enter it successfully started ABA

inside this string name variable and now

it's waiting at this line the console

read line just just right here so when I

press enter the program closes so now

that we've made a variable and not done

anything with it let's print out to the

screen to make sure that something's

actually worked so if we use CW tab tab

and we type in name in the brackets and

we can run this code again and let's see

what happens as soon as I type in abber

and press enter then this second abber

is actually the variable printing out to

the screen so here it says enter your

name with a colon and normally when you

see the colon it sometimes lets you type

on the same line so if you'd prefer the

user to type on the same line then we

actually have another function for that

instead of using right line we can just

use right and the difference between

right line and right is the right line

will actually have a Terminator at the

end of the line to tell the console that

he wants to push everything after it

onto the next line whereas console.

right will just print it out to the

screen and not worry about any new lines

let's try run it now and now we can type

in abber as you can see it's a little

close to the colon so we can fix that in

a second so you press enter you can see

now that comes up on the second line

so we just put a space after the callon

just to give it a bit of room now if you

type in Abba you can see that there's a

bit of a gap and it's quite nicer to

look at now if we press enter you can

see that AB has been stored

successfully so what we can do now is

maybe ask for your age so we can have a

console.

right enter your age call on space and

then do a string age equals console.

readline and then we can have a age

output as well and let's see how that

works so we can say abber then say 23

and press enter and now we have abber

stored within the name variable and have

23 stored within the age variable so

let's try and output a string that's a

bit more meaningful to the user let's

clean this console up and see what we

can do so we don't need to Output their

result back to the console because they

literally just type that in and we don't

want to have this line because we just

use that as an example so if we run the

code right now it'll look better but it

does look a lot more structured enter

your name and then enter your age so now

when you press enter the program will

just close so let's try and output these

two variables in a formatted fashion so

as you now know we can use console. WR

to print a lot of stuff on one line so

we can use console. right and we can say

your name is and then add a space and

finish that line there and then

duplicate it down we can write name

duplicate that down and say space and

your age is duplicate that one down and

then we can type in age and let's see

what happens now abber

23 there we go so we actually have the

name output and the age output all on

one line if we all change these to right

lines then they're going to be on

separate lines and it's not going to

look very nice nice so I'm just going to

introduce you to a notation called

string concatenation this is the notion

of being able to concatenate two

different strings which just means to

add one string onto another as you can

see this is taken up four lines of code

and it's getting a bit ugly the better

and easier way to do this is by

containing it all within one line so we

can have a console right line and we can

take the first section your name is keep

the space at the end we can end the

speech marks and put a plus and then we

can send name so now we've just added

these two together if we just comment

out the rest of them and run the code

and you can see that they should be on

one line there you go so we can say your

name is Aba and let's just keep changing

the plus symbol so we can say and your

age is another space and the speech

marks and plus the age now we've got all

of this contained within one line and it

looks a lot better enter your name Abba

enter your age 23 and now you can see

exactly the same output but reduced to

one

line as you can see these three lines

are all stuck to each other so if you

wanted to add a blank line between these

two you can just put an MC console right

line just in here and what this will do

is simply just print the right line

character to the screen which will force

the console to make it on the next line

just like so here's the console right

line from the empty line that we just

wrote and this is the console right line

to Output the Val values so now that

you've understood how to read values in

from the console let's try and convert

some values as I showed you how to do

earlier on in the cuse you can actually

convert these strings into integers

ideally you want to store variables in

their data types as we covered before

ages should not be stored as strings

they should be stored as integers but if

you try and change this to an INT then

you're going to have an issue console

read line will return back a string so

therefore it can't implicitly convert

from a string to an integer so we need

to do this in two steps we can rename

this to age input and then on the line

underneath it we can say int age equals

convert to int 32 and then add age input

in these

brackets there we go and now when we

actually print the line of code nothing

should actually

change your name is abber and your age

is 23 but now what's actually changed is

we're storing the variables in the

correct format this is the ideal method

because in the next section when we

cover if statements you'll realize why

this is very important if you wanted to

minimize the amount of steps you need to

convert this then you can actually move

the console read line and get rid of the

string input variable and we can just

paste it straight into the bracket of

the converter in 32 and you can get rid

of the string input variable and

everything will work the same h 23 and

now it's working exactly the same if

this is too many steps for you or if

this looks too complicated then just

please revert it back just to keep it

the same way for the time

being so now we've learned how to read

in values from the console and output

them back to the screen now let's see

how we can use if statements to divert

our code into multiple paths so in the

previous section I told you that it's

very crucial for our code to have this

int age and the reason why is age is

meant to be stored as a number and not

as a string so we read it in first as a

string and then convert it to an integer

using this function and store it into

our age variable this is the reason why

so our condition goes as follows we

would write the word if and between the

brackets this needs to be evaluated to

either a true or false value and then we

can have the curly braces to tell us

what to do if this becomes true so in

this case you want to just check if our

age input is greater than or equal to 18

let's say this was an entrance to a

place that only allowed overes to enter

so we can do age input which refer es

the age input variable and we can use

the operators equals greater than

greater than or equal to less than or

less than or equal to or not equal to so

these are all the different options that

we have we can say if the age input is

equal to

18 perfect so now that we've read in the

age input we can check if it's 18 let's

just process a message in here says you

are 18 and let's have a look and see if

this works

18 now I press enter it says you are

18 but this is the problem with storing

everything as a string and then trying

to use it as if it was a number if I

type in 18 followed by a space as you

can see there's a blank space here now

and press enter you can see that it

doesn't come up and the reason why is

it's processing it like this with a

space at the end in order to avoid

situations like this this is why we

would convert it to a number and the

reason why we're using equals to here is

we can't use greater than or equal to

because strings can't be greater than or

equal to another string they can only

ever be equal to or not equal to string

is just text so if something equals to

something then it's fine the only way

that we can use these different

operators is if we actually interact

with our integer variable now let's see

how we can use this so we can say age

equals equals 18 and now you can see we

actually reference it as a number now

let's run the code if I do 18 Follow by

space it still works and the reason why

is it actually dismisses that space when

it's converting into the integer so now

a just started as an integer and we can

actually manipulate this a bit better so

instead of saying you are 18 we can say

you are 18 or older and now instead of

doing equal to we can have greater than

if we have greater than then we're

actually dismissing the number 18

because if the age is greater than 18 so

this will read like this and 18 is not

greater than 18 so this will return back

false what we actually want to use is

greater than or equal to if the age that

we've inputed is greater than or equal

to 18 then you are 18 hence the equal to

are greater than if you're older so now

let's try and run this AB 23 perfect you

are 18 or older let's change so let's

change some other if statements to add

some additional conditions so we can say

else if and the only reason why it would

come into this bracket if this condition

returns false it will move down the next

condition in the else chain if this was

wrote as a separate if statement then

this would run completely independently

from this one if you're going to have

chained if statements you need to make

sure that you chain them correctly in

this case I want to check if it ages

between 18 and 25 and then move on to a

different age bracket and these two

things are grouped together so we should

have this as an else if because with an

edge bracket you can only be of one age

bracket and not multiple so we can say

if age is greater than or equal to 25

and we can copy this and we can say you

are 25 or older now let's see what

happens enter your name abber and let's

just say that I am

35 it says you're 18 or older but I told

it the program I was 35 now the problem

we're facing is any value that's over 18

will always enter inside here and it

will skip over this one completely this

is not the behavior that we want so so

what we can do in our if statements is

we can use the double pipe which

represents or or the double Ampersand

which represents and and we can change

some conditions in here to make sure

that you implement some sort of range so

we can actually have a range between 18

and 25 so we can say if the age is

greater than or equal to 18 and the age

is less than or equal to 25 and we can

tweak this message you are between 18

and

25 and let's just run that for now and

see what happens abber 25 now it says 18

and

25 so now that we've got between 18 and

25 here we can tweak this to be greater

than equal to

26 if you're 25 will enter this

condition and if you're 26 or older into

this condition so let's test that now if

we enter

35 now it says your 26 older that's

perfect because now that we've

implemented range checking it gives us

the ability to differentiate between

different age groups more precisely

let's Show an example of how to use the

R so if we just have a block comment

around all of this we can write an if

statement in here and we can say if the

age is smaller than zero or the age is

bigger than 150 then we can output to

the screen in valid Age and what this is

saying is if we're less than zero and

notice that this is less than zero so

this value will actually start at minus

one and this value start at 150 is minus

one or less or over 150 then this will

happen notice why it's an or one of

these need to be true in order for this

to be true when you've got an and both

sides need to be true in order for this

condition to invalu it is true so let's

try our code we can say Abu and we put

minus one and now it says invalid age

which is perfect because this is our

range checking and we can try again with

151 as it's just outside the range it

will say invalid age and if we have an

else on here we can print valid

age notice there is no condition in here

if you have an open else like this it

means If This Were to return false it

will always do this regardless of any

condition in this case it's perfectly

reasonable to do this because we know

that any values that are underneath zero

or over 150 is invalid and anything

between 0 and 150 is indeed valid what

you can do instead is actually move

these if statements inside here so

instead of just printing out valid age

we can actually check the age as

well so let's run this now and we can

say Aba minus one and it will only print

out invalid age and then move on because

once it reads the this line of code it

will actually skip over the L's and

finish up down here and now if you enter

a real

value you are between 18 and 25 so let's

follow the path it got to here and

realize that the range check was

actually correct so jumped out of this

curly brace and went to the else because

this had returned false we jump into

this else and now we start checking if

ages between 18 and 25 which it was

because our age variable is 23 then it

outputed this to the screen

now if we do the same thing but have 35

instead then it follows the exact same

path except towards here this will

return back false and then it will check

the next condition if age is over 26

then we'll return

this so now let's just make a quick

multiplication program using if

statement to see if you can get the

answer correct so let's just comment

everything

out and we'll start the next section

underneath

so let's make a console. write and ask

the user to enter the first

number and then we can say int number a

equals convert to in32 and the value

that we want to convert is a console.

readline which is whatever the user

entered from the console again if you're

unfamiliar with this format you can just

type it in manually number a input

equals console read line and then we can

put the number input in here now if you

use shift and highlight these lines and

press contrl D we can duplicate this

entire section and we can say enter the

second number change a to B change a to

B and then finally change a to B perfect

so now we've got enter the first number

and enter the second number and we can

say our

answer equal to number a multi by number

B and then we can have a console. WR

value of we can add to it number A plus

an X Plus number B and then finally plus

a callon for the user to type in and

then we can say string answer input

equals console. readline and then

int actual answer equals convert to in32

and then we can have the input in

here so now that we've got one number

from the console the second number from

the console we're just making a variable

that will multiply them together and

store inside answer and then we're just

going to ask the user what's the value

of number a times my number B and they

can input that we store it as a string

and then convert it to an integer and

store the answer into actual answer so

now just after the section we can write

an if statement that says if the answer

equals to the actual answer then we can

say Well

done and else and the reason why we

don't need to condition this else

because with equals to the only opposite

thing you can have is if it's not equal

to so if you really wanted to you could

also write if answer is not equal to

actual answer then in here you can say

close but it was wrong you don't

actually need this this is just for

learning purposes because this will

return back false if they're not equal

to each other so this statement is just

a given if they're not equal to each

other then we can just assume that

they're not equal to each other so we

don't need this additional statement if

this condition evaluates to being false

then that means they're not equal to

each other we don't need this additional

check to check if they're not equal to

each other because that's a given if

this returns back false so we can just

leave this as an else let's try run the

code 10 10 value of 10 * 10 100 now it

says well done and let's just try that

again and we can enter a different value

90 Clause but it was wrong so let's just

have have a quick

recap so in the previous section we

talked about how to input from the

console and we generated this line of

code which will output your name and

your age in one line to the console and

then we looked at how we can use these

different operators in our if statements

and we did some range check in to check

if the age was between 18 and 25 and it

would output something to the screen and

if it was over 26 you'd get a different

output to the screen and then we took

that a little bit further and started

using the r operator

if the age is smaller than zero or it's

greater than 150 then it must be invalid

and if this condition returns false it

must be between 0 and 150 so we can come

into this L's bracket and inside here we

can do our range checkin from the

previous bit of code we can check the

ranges between 18 and 25 and print a

value or if it's over 26 we can print

another value and you can keep changing

these if you want you could have 26 to

40 and 40 to 60 Etc Etc that's up to

you so this is just a quick little

program to simulate multiplication

program we can enter the first number

using console. WR and then we start it

as a string and we put that string into

the converter in32 function to give us

back an integer variable and we do

exactly the same thing for the second

number and then we make a variable to

store both numbers multiplied by each

other we ask the user what is the value

of number a Times by number B and we

give them an opportunity to type in a

value we read that value in convert it

to an integer store it as an into actual

answer and then in our if statement we

say if the answer is equal to the actual

answer then we print well done to the

screen double equals are used for

equality and single equals are used for

assignment don't get them mixed up we

don't need an else condition in here

because if this returns true then this

will execute if this is indeed false

that they're not equal to each other

then we always want to do this section

and we don't need to put an additional

if statement inside here if you wanted

to but it's not necessary you can have

lse if answer is not equal to actual

answer but this is just extra code and

it hurts the readability and it should

be

avoided if statements are one of the

methods we can decide different paths in

our code the next method we can use is

called switch statements so let's write

a little program so we can demonstrate

this so we can just have a console right

enter date of the week and we can have

in date equals convert to in32 and we

can place our console. readline inside

the brackets so we take whatever the

user typed into the console and then

place it inside here and inside here

we're going to convert whatever they've

typed in to an integer 32 and star it

into our D variable so if we just print

this out to the screen to make sure it's

working

fine if we just type in seven we can see

that seven is returned so it's all

working so normally what we do is type

if D equals equals 1 and then we can add

the Cy braces and use CW tab tab and we

can print out Munday now if you run the

code and try use number one then Monday

works and that's fine and then let's do

another LS if and we can say day equals

equals 2 and then we can print

Tuesday perfect so if we try that

now there we go so now we have the

ability to print out Monday and Tuesday

to the console depending what day the

week the user enters but since we're

going to have have seven different paths

because we got seven days of the week

then sometimes it might be better and

cleaner to use a switch statement so

let's have a look at the syntax so we

can type in switch and then inside the

brackets it's what variable we want to

have a switch on so in this case we want

to be using the day variable so we can

add D in the brackets this is not a

condition in the brackets this is just

telling us what variable we're going to

be using for the switch statement so

let's open the curly braces after and

inside here instead of having paths like

this we're going to use cases so this

can be translated to in the case of

number one we can do this in the case of

number two we can do this so let's try

and see how it works we can type in case

followed by number one and then add a

callon and then we can type out our

Monday in here and then we need to

follow each case off by finishing the

section off with a break this break's

very essential and you'll get a syntax

error if you don't put it in so now if

we do case two and we do exactly the

same thing there we go and if I dis miss

the break then you'll realize that it

says it cannot fall out so we have to

use a break just the compiler knows that

we want to break here the reason why

this break is placed inside here is

because what we can do is we can say

case two and then add another one in

here called case 3 and what this now

reads is if we enter two it says choose

there and if we enter three It also says

choose it so what you can do is you can

actually chain so this would be

equivalent to writing if D equals 2 or D

equals equals 3 now this is exact

translation these two are exactly the

same as of right now we have D equal

equal 1 which is our K1 and then equals

2 Ral 3 is right here if we go into the

case 2 path it will fall in the case 3

so we're saying for this break is we

want to end this section here so now if

we just revert this back and continue

the

chain I'll just skip this part just so

it's a little bit quicker

there we go so now that we've got all

seven days of the week let's just see if

it works let's try six and we have

Saturday so now we're kind of missing

something from here the only thing we're

missing is having our external lse just

in case the user types something invalid

so normally we would write something

like this enter value between 1 and 7

just to make sure that the user knows

what they're

doing now we don't seem to have anything

inside here that gives us the

opportunity to invalid so we have this

keyword called default and it works

exactly the same as the case except what

this will do is this is basically the

word that replaces else so we can

literally take this line of code and

place it again over here and add

ourselves a break this is exactly the

same as doing our L statement inside

here if none of these cases match this

variable then it'll go into the default

and Contin as normal so if we type in

zero we should see the message twice

because it's executing for the if

statement and executing down here and

let's do eight and you see the message

again so now that the case statement is

fully working let's just comment out the

if statement and make sure that it still

works one Monday let's just try another

one and we can do seven for Sunday so

just a quick recap case statements are

used by using the keyword switch

followed by the variable in question and

then if you want to check if this

variable number is equal to something

you put that something straight after

the word case followed by a colon and

then you can insert multiple lines of

Corde inside here and make sure you end

that line with a break if you want to

chain multiple like Dayal 2 or Dayal 3

then you can add the case above right

here so the case of zero or the case of

two it will do this little section so

it'll print out Tuesday if the user

enters zero or the user enters two of

course in this case we don't actually

want that after you filled out all of

the code make sure you add something

called the default the default is

equivalent to an lse keyword in our if

statement just to catch all the values

in case the user type something

incorrect and you want to let them know

what they should be typing

instead so now that we explored

different paths in our code using IF

statements and switch statements let's

have a look at how we can iterate

through our code an iteration in code is

just the ability to be able to Loop and

do a certain task so let's say we wanted

to print high to the console several

times then we just have to copy and

paste it down and this will be five

separate lines that do exactly the same

thing this will essentially achieve what

we want the problem is you just have

exactly the same code copy and pasted so

what we can do if we just block comment

this line for the time being we can

write something called a for Loop a for

Loop gives us the ability to Loop a

certain amount of times depending on the

parameters that we give it so this is

the syntax you can type for open the

bracket and we have to use a variable so

we can declare a new variable straight

into these brackets we can say inti

equals z and then have a semicolon and

there's three different sections to this

the first one is the variable decoration

and initialization and the second one is

the condition so in this case we want to

do this task five times so you want to

say I is less than five then we end that

semicolon there and now for the third

task every time this for Loop goes

around we want to increase I by one

because we want to go in steps of one so

we can do

i++ alternativ if you don't like using

Plus+ you can say I = I + 1 or to make

that quicker you could say I + equal 1 I

personally just prefer using Plus+ and

you'll see that everywhere else there is

certain cases where you would actually

want to change this to a different value

like I +al 2 and we'll show you that in

a second so this for Loop now says we

want to go from I equals 0 and once this

condition returns back false when I is

equal to 5 or greater then we want to

stop this for Loop every time this for

Loop goes around so in hits this curly

brace and comes back around we want to

do this action and in this case it's I

++ so if we just use console right line

and print out the value I we can see

what happens when the follow

runs you can see that the value of I is

increasing one each time and after the

fifth time is increased the value is

actually five so now this statement is

false because the value of I is equal to

five so therefore this is now false and

the for Loop is ended so now that we've

verified that you can repeat it five

times using this code we no longer want

to print I we want to print our high so

let's paste that inside the bracket and

run the code now you can see that these

two values will be exactly the same as

printing it out to the console just like

this but now we have a lot less code so

let's have a look at another example we

can say 4 in I equal 0 and we can say I

is less than or equal to 10 and then we

can do I + = 2 and then if we just print

I to the console so what this is now

saying is I want to go from zero all way

till 10 and I want to go up two times

each time so what this will be achieving

is printing out all of the even numbers

between 0 and

10 let's try and run

it now we can see we have all the even

numbers printed out between 0 and 10

because we're going up in

twos if we start this at one for example

and still keep every parameter exactly

the same then we'll be getting all of

the even numbers between 1 and 10 11 is

missing because our condition stops at

less than or equ equal to 10 what you

can also do with for Loops is you can

let the user determine what this value

is going to be let's test that so if we

block comment this section out what we

can do is we can appen this little

section so we can have a console. right

how many times do you want to say hi can

have a callon followed by speech marks

and then we can say in Loop counter

equals convert to in32 and we can have

console read line inside the

brackets how many times you want to say

hi the user types in the value you take

the console read line as a string

convert it to an integer and start

inside loop

counter so now what needs to change

inside here the five is what determines

how many times that we're going to Loop

so in this case we actually want to just

Loop by whatever the user types in the

counter let's just type five and make

sure it works and if we just type one it

works if we type zero however it will

just skip over the for Loop and the

reason for that is if you're going from

0o to I is less than zero then this is

immediately going to be false so then

the for Loop is just going to get

skipped immediately there is nothing to

do if the user is typed in zero which is

perfectly reasonable and you can type in

a really big number like a 100 and it

will output them all to the

screen if the user types in zero then

nothing's going to come up so you always

want to be able to let the user know if

there's something wrong so we can say if

the loop counter equals equals to zero

or maybe we can change this to less than

or equal to because it could type in

minus numbers as well we could just say

a conso right line using CW tab tab

sorry please enter a value above zero

and then if this condition has returned

back false then inside our else

statement we don't need to give it an

else if because if it's less than or

equal to zero then we want to process

the other values because it has to be

greater or equal to one

so when this is false this section has

to be greater than or equal to one so we

can just place our fall Loop inside here

and that's fine and let's try to run the

code now and if we type in zero please

enter a value of zero and if we just try

any negative values we'll get the same

message if you want to print additional

code in here you can literally do

anything you want you can even ask the

user what they want to print up here and

then you can replace this with a message

for example we could have a string

message

and we can just change this to hello

world and this could be something that

you reading from the console so we can

say message and we can put that in here

and if we print that there we

go so we can just say console.

right what do you want to repeat and

then we can read this

in and actually it might be easier if we

change this Loop counter to Second so if

you highlight the section hold alt and

press down arrow twice we can move it

down and say and how many times do you

want to repeat it there we go so now

what we can do is we can use this

message inside here and then Loop

depending on how many times the user

typed in whatever so we can type in

hello world get this exact value and we

can say 10 times there we go so now this

entire program is fully customized by

the users

input so let's just have a quick recap

so we started off this code I print in

the console right line five times to the

screen we wrote Our simple far Loop that

went from in I equals 0 to I is less

than five and we did I ++ because we

want to count up in ones you can place

the high inside here and it'll print it

five times for us so now we've made our

code from five lines down to just three

lines for the follow and then we allowed

the user to type in how many times that

they want to repeat it and we change the

condition from I is less than 5 to I is

less than whatever the user has typed in

installed within the loop counter and

then we hit a problem where if we

entered zero anything less than zero the

for Loop would just not run and it might

look like some things went wrong so we

added a little if statement in here to

make sure that the user has entered a

value above zero and if they haven't we

can let them know we don't need another

if statement in here because if this has

returned back false we can assume that

the value is something that we can work

with we later tailored the program so we

can change this message that was fixed

to I to something that the user can type

in

manually so now that we know how to use

for Loops let's have a look at while

Loops for loops and while Loops still

iterate through code but they're used in

slightly different contexts for Loops

are used mainly when you know how many

times you can iterate through as in this

example we're going to print to the

console exactly 10 times but in a while

loop you might print until a condition

is true for example if you asking the

user to type a number and they kept

typing in something else you don't know

how many times it's going to take the

user to type in correctly so in that

case you would use a y Loop if you

executing a certain amount of code and

you're only doing it a fixed amount of

times then it's always best to use a for

Loop so first let's try and convert this

simple for Loop that just prints I to

the console 10

times just like so from zero all the way

till 9 so let's comment out this for

Loop and have a look at this syntax for

the while loop so type the world while

and then in here we have our condition

and then we can open our curly braces

and while this condition returns back

true it will always go inside the curly

braces and when this condition returns

back false then we'll exit the while

loop so let's try and mimic exactly what

we're doing inside here there's three

sections to the for Loop we Define the

variable that we're going to use for the

for Loop counter and we give it an

initial value we give it the stopping

condition and we give it how many many

times the value needs to go up every

time the for Loop iterates in the while

loop situation we only have the

condition available so let's take our

condition and paste it straight into

here and now we need to store our

variable so just because it's a y Loop

and we can't store it inside here we

have to do it outside the while loop so

let's make it in I and we'll make it

equal to zero so we've got our variable

we've got our condition now we need to

set

i++ so inside the Y Loop we can say i++

and then now we've achieved this entire

line and successfully converted it let's

try and put the console right line in

and see what

happens and let's run the

code so it's going from 1 all the way

till 10 and the reason why it's going

from 1 till 10 not from 0 to 10 is

because the i++ is at the start let's

move it down online using alt and down

arrow key to move it down and let's run

it again and you can see it goes from

zero till 9 and if we just block comment

this out

and undo the for

Loop you can see that they're doing

exactly the same thing so let's bring

the Y loop

back and as you can see what we have is

we've defined our I variable made it

equals to zero while the I variable is

less than the value of 10 we print the I

to the console and increment I by one

and we keep looping this until this

statement returns back false and then we

exit the Y Loop and jump underneath the

the curly braces and hit the console

read line and this is the output that

we've got so now I've just copied the

code from the if statement video and

let's make this code a little bit better

so let's comment out our while loop and

our for Loop that was just used for

explanation purposes and this is the

code that you've saw earlier on in the C

we read in the first number Star as a

string use that string to convert to an

integer star number a and Then star

number B and these two blocks are

exactly the same except you have enter

first number and enter second number

and we store number a and store number B

then we store the value of them both

multiplied inside our int answer

variable then we ask the user what's the

value of both answers times together

give them a chance to input their value

convert it to an integer and then we

check the value and print well done of

Cl but it was wrong now if we run this

code again and we type in 10 and 10 and

we know the value is 100 but let's just

type in 90 now this is kind of a

problematic user case we've asked the

user to type in a value and they've got

it wrong and then when they press enter

the program just closes there's no

opportunity to Loop or try this again so

what we can do is add a y Loop in here

and we can say while the answer is

incorrect we can keep asking the user to

keep on guessing so instead of reading

the input here let's turn this little

section into a question what's the value

of number a * number B and instead of

allowing an input here let's just put a

question mark and then let's add a

console right line just to give a little

bit of a gap and then in order to do our

while loop we actually want to create a

boan variable just to track if the

answer has been correct or

not this is the section that we want to

loop around in the while loop we want to

read in the user's answer check it

output a message and then give them the

opportunity to read in another value so

they can guess again while the answer is

not equal to the actual answer

then we can loop around our code so we

have to modify a few things here so we

can't just take this code and place it

inside the problem with doing this is

the variables that we want to check

answer is outside of this y Loop but

actual answer is inside and the reason

why there's a red line here says it does

not exist in the current context because

we're trying to check a variable that

hasn't been defined yet so what we can

do is take the Declaration for the

actual answer and place it outside here

and make it equal to zero and instead of

redeclaring it inside the while loop we

can take this in and get rid of it so we

set the actual answers to zero set the

answer to the multiplication while the

answer is not equal to the actual answer

then we want to loop around so we don't

actually need another check in here this

while loop will keep on repeating if the

answer is incorrect so we don't need a

path for correct and incorrect if this

while loop still continues then the

answer will always be incorrect so what

we can do to double check is we can say

if the answer answer does not equal the

actual answer then we can place this

message inside here and get rid of this

branch and then after the while loop has

continued we can say Well done so let's

just read through the code while the

answer is not equal to the actual answer

and when this while loop first enters

it's going to be true because you're

going to have 10 * 10 which is 100 and

the value of answer is zero so this will

return back true because these two

values are not equal to each other then

we're going to ask the user to enter the

value then we're going to read into the

actual answer check if they're not equal

to each other and then we output a

message because we're asking a question

here we want to ask another one using a

console right Line enter your answer

callon here we go so let's have a look

and see how this

works 100 100 what's the value 100 * 100

and let's just get it wrong on purpose

90 CLA but is wrong and now we get to

answer again

and we can keep answering this as many

times as we want until we reach the

correct answer which in this case is

10,000 and we've got the answer well

done so to make the console look a

little bit better cuz this is all in one

block we can separate these with console

right lines maybe after this line we can

print out a new line and then after each

guess we can print out another new line

so after each guess we'll be down here

we can just print out a blank console

right line and just after you ask them

to enter the second number we can print

another one here and let's just see how

that looks 10 10 now it looks a lot

better because you ask the user to input

the numbers then you ask them the

question and then you get the answer and

then it keeps looping around like

this so there's a little gap between

each one so you can efficiently read it

instead of it all being closed off

together now if you answer it correctly

100 now it says well done and when we

press enter again the program now closes

so that was using a while loop and now

we have something else called a do while

and a do while is very close to a while

except that the while will only happen

if this condition returns back true and

a do while will always happen once and

it'll check the condition at the end so

let's have a look and see how this works

so we write the word do and then we have

the curly braces and then after it we

have our while condition and let's just

copy the condition from the old while

loop and we can say answer is not equal

to actual answer so as you can see with

a while loop it will always check the

condition first first and then it opens

the curly braces in the do there is no

condition it will always do everything

inside the curly braces once and then it

will check this while condition if this

condition is still true then it'll loop

around and check it every time but it

will only check it at the end while

Loops will check the condition as the

first thing it does and then check it

every iteration so let's move our cord

down into here and let's just comment

out our while loop just to see how this

works and if we run it again to make

sure it's working fine 10 10 90 90 50

and then finally 100 and it says well

done so you could be thinking what are

the differences between a while loop and

a do while in certain cases you want the

while loop to make sure that this

condition is true before even continuing

in this specific case we always want the

user to answer the question it doesn't

matter if it executes once because

actually that's the behavior that we

want we've asked the user a question

right here so we want to always be

looping at least one time the while loop

user case doesn't quite apply here

because we don't necessarily have to

check if they've answered correctly if

they haven't even inputed a value yet we

always want to be able to give them the

option to do it once and then we check

their answer at the end they could get

it on the first answer 10 10 100 and

it'll still be fine the same is true

with a while loop but it'll be easier

and it makes more sense to read your

code when you have a while loop you can

see that this bit of code depends on a

condition whereas in a do while the

first iteration does not depend on

anything but the second and third and so

forth depend on the condition so

depending on your user case and what

situation you want to use it you should

either pick a while loop which will only

occur through a condition or pick a do

while that will occur once or multiple

times after the first condition has

passed

so when you have if statements that are

pretty basic you can actually make them

quite easy to read through the

conditional operator also known as the

tary operator so let's see how this

works let's say we have an INT age and

we set it to a minus value and we know

that this value can never be someone's

age because it's negative but let's say

that we have a situation where you ask

the user for their age and they've

accidentally typed in -10 and we know

that that value is not actually true so

we could write something like this age

is greater than or equal to zero then we

can print out

valid and then in the else we can take

this console right line and we can print

out invalid so that means if we run our

code now you can see that it says

invalid and if we change it to positive

10 now it says valid so this seems a

little bit long we are just checking one

condition printing a value and printing

another value if that condition returns

back false so our conditional operator

works like this we have a condition

followed by question mark then the value

if it returns true then the value if it

returns false let's see how you can

rewrite this if statement into one

simple line so let's take this in

steps these two values are both strings

that we've typed in so let's make a

string and we can call it result and

let's make it equal to our Turner

operator so the first step is to get the

condition and the condition in this case

is if the age is greater than equal to

zero we can follow that by a question

mark and then if this returns back true

we want the string to say valid and we

can have a call on and if it returns

back false then we want the string to

say invalid and we can add a semicolon

and then straight after it we can just

have a console right line that just says

result as you can see now that we get it

twice we can verify one comes from the

if statement and one comes from the turn

operator and now if we make this say

positive 10 then you can see it both

says valid so if we comment out the if

statement and just see this running on

its own just to double check there we go

and because this is just returning back

a string we can actually just take all

of this code in the conditional operator

and paste it straight into the console

right line so you run the line of code

now we get exactly the same thing if

this hurts the readability of your code

then it's best to just store it and then

use it after if you can read this code

and it's better for you in the long run

later on you might want to dismiss this

variable and do it straight inside the

brackets just to save a variable and

then print itto the screen straight away

it'll be better for memory if you just

print it out straight away but if you're

not familiar with this notation yet and

you want to get used to it then that's

fine as well so a quick recap we had an

if statement with a condition and if

this returned back true we printed valid

and if it return back false we' print

invalid and this is pretty simple the

only difference between these two paths

is this string literal that we've typed

into here so we can pull the string

values out and place them in our

conditional operator we can say string

result is equal to if the age is greater

than or equal to zero then we store

valid inside result and if it's not

greater than equal to zero then we can

St invalid straight in our string after

we've stored this value we can print

results straight to the screen which

will either give us valid or

invalid when when you're dividing two

numbers you might get an ugly output

just like

this the user sometimes doesn't want to

see such long decimal places and maybe

you just want to prevent it to

81.3 in order to do this we need to use

a format pattern so the language

understands what we're trying to achieve

so if we make another console right line

what we can do is use string. format and

inside the brackets we can give it a

format and then the object that we want

to format so in this case the object in

the second parameter is our value so

let's open some speech marks go to the

next parameter using the comma and just

type in our value and then inside the

speech marks we want to type in the

pattern if you type in curly braces as

zero then zero represents the first

valid you in this list we can do a space

followed by curly braces one and then

add another comma and we can add a

thousand and what this means is value

will get place where zero is and 1,000

will get Place one is so let's run this

and you see the exact same thing's

happened plus dis place and now we have

the Thousand which follows this pattern

exactly if this is confusing don't worry

too much about it I have the next

section all about string functions so

let's get rid of the one followed by the

thousand and run it again and we should

see the output being exactly the same

there we go so now let's see how we can

make this better in terms of decimal

places so just after the zero and the

zero represents the first value we can

add a call on and this column will tell

us what format we want the value to be

displayed as we can type in

0. and what this means is all the

numbers before the decimal place will

get displayed and only two numbers after

the decimal place will get displayed so

let's try run this now and you can see

that the code output is a lot cleaner

one thing to note though by default this

will round it up 0.37 becomes

0.4 not to worry though cuz this is what

the user will see on the screen and it

won't affect the actual value of the

variable if we print out value straight

after you'll see that the difference

hasn't been changed it's still 0.3 in

the original variable so that's one

method of doing it what we can do now is

just use controll D and copy it down and

we can use different formats to show you

what it looks like if we remove the 0

and then one of the zeros and leave it

like this and it gains one decimal place

each time you'll see what the output

looks like we just have the 81 which

essentially makes it into an integer

because it's a whole number then we have

81.0 and the reason why it's 0 is cuz

0.3 will round down as it's under

0.5 the 03 is going to round down as

it's under 05 so it'll round down to

zero and then finally we have the

81.4 and just like before this will

round down

to4 and just like before this will round

down to

0.4 this will round down to 0 four let's

say you wanted to get rid of trailing

zeros because you don't want them then

you can actually change this zero to a

hashtag once you run the hashtag then it

will trim off any trailing zeros so what

this means is it will try and put it in

this format but if this format happens

to be a zero then it will just keep it

like this and if you just have 81 dot

then it'll also get rid of the dot for

you so then you just left with

81 it's really up to you as the

programmer what you want to display

depending on what context I'm just given

you the options that you have available

so let's say we want to work with money

now and we have a 10d / by a 3D and what

that value would be is somewhere between

3333 and this will be reoccurring cuz

it's exactly 1/3 the reason why I've got

D's in here is because these are

registering as doubles if you type the

value in normally it'll get registers at

in 32 and the problem with in32 is when

you do this division it will process the

division as an integer and then store it

as a a double the issue with that is in

this case and in this case both values

will get truncated let me demonstrate if

I remove the D from both sides and down

in here it will'll see what the

difference is and let's print out money

and let's see what's happened in the

first case this isn't actually an issue

because we have a decimal place here

which means this will be a double so an

integer divid by double will give us a

double but we just place the D here just

so we don't forget and it makes the

compiler's job a lot easier cuz it

doesn't have to convert it from an

integer to a double and in this case we

have an INT that's divided by an INT so

we'll get 3.3 reoccurring but because

it's processing as an integer then we

just get three being displayed and this

is not the intended result so let's just

replace these back to D's and we'll see

what we get now which is the 3.3 perfect

so let's say that we want to display

this as actual currency because you

never see it displayed like this it's

always to two decimal places just as

follows so we can follow the same

approach as

above we can do string.

format 0 callon 0.0 and the curly brace

and then common money cuz that's the

variable in reference now if we run that

let's see what happens

3.33 that's perfect and now what we can

do in here because this is the pattern

we can actually type in anything before

after this and it won't affect the

pattern just like so we've added some

Extra Spaces in here so if we get rid of

these spaces we can actually just play

is a pound sign in front of it and then

let's see what happens when we run it

perfect so now we actually have some

money and we can say in here £10

/3 equals this and now our output looks

a little bit better because we have some

formatting now the issue is when we

start getting into negatives let's see

what happens so we can say -10 IDE by 3

equals something and when we run we'll

see that the format is actually

incorrect now you never see the negative

symbol after the pound symbol it's

always this way around in this case what

we're doing is we're telling the

compiler hey we only want to see two

decimal places but always keep in this

format the pound sign followed by the

value and the value of money is -3 so

it'll Place -3 inside here and then add

the pound sign before it but we don't

exactly want that so we can add some

something called a culture info but we

can also give it some other formatting

some other way so let's explore some

other

options if you use money to string then

what we're actually doing here is using

the double variable and converting it to

a string I me get passed back a string

representative of this value and that's

fine and when we run the code you'll see

no difference between these two at this

point they're both being converted to

Strings but what we can do in this case

is when we open these brackets it tells

us there one of four what does this mean

exactly so in our two- string function

we have four ways that we can call this

function the first way you give nothing

in the

brackets and if we press the down arrow

the second way is to give it a format

provider the Third Way is just a string

format and the fourth way is both a

format and a provider so we'll use all

of these in a second but let's explore

the easiest one if you add a string in

there which gives us the third overload

string format and we can just type in a

Capital C let's just see what

happens perfect so now we have the best

format display to us and the reason why

this works is the C program will

recognize that the format of C is

telling us that we want to display

currency so then it's going to your

local machine and figuring out where you

are based on your date and time just

down here when you have adjust dat and

time it will figure it out based on this

we have UTC time and we have the date

and time listed up here based on that

information it can figure out that we

are indeed in the UK and we want to

display a pound sign and because the

program knows that it's - 3.33 it'll put

the pound sign in the right location so

now that we've explored C let's have a

look at the other ones that are

available so if we use contrl D and copy

this down three times we can use C 0 C1

and C2 and now if you run this again

you'll see what the output gets you c

will get you currency in it most native

form which is what we're used to using

in the UK c0 will only return you back

with the whole number C1 will give you

one decimal place and C2 mimic C on its

own as they're displaying the same

values now this is where it gets

interesting if you want to display

different currencies then you're going

to have to use this thing called a

culture info which will be able to

retrieve back different currency formats

based on a certain country code that you

give the

function so let's have a look and see

how that works if we scroll to the top

we can add a new library called system.

globalization inside globalization we

have a culture info so let's see how we

can tailor these to make it look a lot

better if you're worried about different

currencies so we us CW tab tab and we do

the same thing money. two string we add

our C and this is where our format

provider fits in so we can start type in

culture info it should come up like this

press enter and inside this is a class

that's why it went green if we press dot

then we get the current culture the

current culture will decide based on the

machine that the program is running on

if this program is running on a cloud

computer and the cloud computer is

stored in Europe then it might display

euros and if it's stored in America then

it'll display dollars so you want to

avoid using current culture if you're

going to scale your program worldwide in

the case of this example I'm going to

leave it because as you can see when I

run it it will display the same thing as

as the other ones because this one will

also recognize that my current culture

is UK and I'm also telling it to use the

current culture so in both of these

cases it's figured out that my current

culture is indeed the UK and it's

started using the pound sign but let's

say we want to give it a different

culture then what we can do if we

duplicate this line using contr D and

remove this section just after the dot

we can actually say create specific

culture and inside the parentheses we

can actually add a string and it says

here a predefined culture name or the

name of existing culture info object the

name is not case sensitive so in the

case of the UK you have English GB and

now we need another bracket at the end

and then if we use control D to copy

this down we can change GB to us let's

run this again and see what

happens these two don't actually output

anything different because we're just

doing the normal culture and then we're

telling it to find the GB culture which

is exactly the same thing for me so we

get these two values exactly the same

and apparently it's picking up that in

the US you have brackets around your

negative values which I can't personally

validate but this is how it's showing up

so let's try some other cultures and see

what happens so you can try Au for

Australian then you can see that they

actually use a negative followed by the

pound sign and then the value so even

though they're both in dollars one's US

Dollars and one is Australian dollars

and apparently the US uses brackets for

the negative values but Australians use

the negative value like we do so let's

just have a quick recap so we can

display the value just like this but

we'll have a problem with multiple

decimal places we can use these format

options to give us zero decimal places

one or two decimal places and then when

we use this format the problem with it

was when you display negative numbers

you get a nasty format where the

negative value actually comes after the

pound sign which is not correct and you

don't want to Output that to your users

instead you should use the C format to

tell the compiler that you want to

process this as a currency currency

processing is better because the

software will understand that the value

you're trying to represent depends on a

certain strict format just as follows

you don't want the negative to be here

instead of before it because that

doesn't look very nice to the end user

alternatively you could use this C info

if you're going to scale your program

scale your program means that it's going

to live on servers and this culture info

especially the current culture depends

on where the program is being run on

because it depends on the system time

different servers will have different

dat times set because they'll be in

different countries so you want to be

careful and if you want to display in a

certain currency you can create a

culture specification and pass the

country code inside the brackets and

then you'll get the correct output and

it doesn't matter where your program

lives if you always want to gener

generate in pound symbols then you

always use create specific culture and

always specify

NGB upon doing so you always get the

pound sign and it doesn't matter where

your program

lives so throughout this course you've

seen this notation a lot print out value

using console right to give the user an

opportunity to write on the same line

reading their value as a string and

store it in a variable and then use that

variable to convert it to an integer 32

and we're passing the string input

inside here and then we convert it to an

integer if we run the code you can see

that this actually works perfectly

assuming you actually enter a real

number like 10 we press enter and it

works and it outputs back to the screen

using this console right line and if you

press this restart button we can start

the program again and let's say we

accidentally type a character like L and

we press enter and we've get a format

exception now this is problematic

because our program will now close if we

press continue it doesn't even hit this

line or this as soon as it hits the

exception here our program just closes

if we use debug start with debugging and

now we're actually running the program

outside of visual studio so we won't get

that pop up when the error happens let's

see what happens if we type this in now

we can say 10p and press enter and now

we get that the program has stopped

working you've probably seen this pop up

a lot throughout Windows in different

versions of Windows because when a

program has a fatal error or an

exception you see there's pop up appear

here and the only thing you can do is

either debug or close it normally the

debug option isn't available but because

this is a c program and it's made

through Visual Studio and the visual

studio is being installed on the system

then it gives us the option but really

all we can do here is just terminate the

program it doesn't matter what happened

because we can't recover this if we

press close then it's literally just

going to close down it's going to tell

us the exception and then press any key

to continue and as soon as you press any

key then the program just closes so this

is very fatal for our code since if we

had some precious data stored in here or

anywhere else in the program it is now

lost before we can do anything this is

problematic and we want to avoid this

the best way to do this is to use

something called try pass right here the

program is assuming that your string

input is a perfect input and then you're

immediately converting it to an integer

now like I said what if this had 10 H in

it the program is going to cause an

exception and then the program is going

to close so let's see what we can do

with this trass function so the notation

is int.

trass the first parameter is a string s

string s is a string containing a number

to convert so what this trip pass

function will do as it says here

converts the string representation of a

number to its 32 bits signed integer

equivalent a return value indicates

whether the conversion succeeded okay

perfect so we'll get into that in a

second so our string s is a string

containing our number to convert and in

this case we want to be using the num

input so we copy and paste that down and

then we add a comma cuz we have more

than one parameter now we have an out in

result when this method returns result

which is our integer contains the 32bit

sign integer equivalent of the number

contained in S and S in this case is our

first parameter which is num input if

the conversion succeeded then we get the

value inside our result

or zero if the conversion failed the

conversion fails if the parameter s is

null or string empty is not of the

correct format or it represents a number

that's less or more than the maximum

value that the integer can store this

paramet is past uninitialize any value

originally supplies in result will be

overwritten let's dive in to see what

this means because it's an out in result

what this means is we can actually

process a variable inside here like intn

so we can say out num and what this will

do is when this line executes it will

try and convert num input and place the

value inside num so we don't need to run

this convert anymore we can just specify

that num is equal to zero so we've read

in the string that contains our 10 H and

we have our Nome that contains zero

let's just remove this console right

line so now we have our variable set up

let's see what happens if we do a

console right line and just print num

after this let's see what happens to the

code so if we type in 10 H and press

enter the value of num is zero but what

you notice now the program hasn't closed

because it's tried to pass it instead of

just passing it automatically and then

cause an exception so the reason why Try

pass is called try pass is first it

tries and then if it succeeds this will

contain the value and if it doesn't

succeed this will contain zero to know

if the number has actually been

converted we actually have to use the

bull return value so what this means is

because it returns us back a bull we can

store it inside a bull and we can give

it the name of success bu success equals

in. trass we try and pass the num input

and we place the value inside num the

reason why having this bu success is

very very essential let's say for

example the user actually enters

zero so technically as of this point num

zero is actually correct because we've '

got zero and we initialize it to zero

but of course after the trip pass runs

this is still going to be zero now we

don't know if the value zero is because

this has succeeded or the value is zero

because we initialized it to zero let me

demonstrate if I type in a zero here is

this zero being converted because this

was successful or is it presenting me

zero because this has been initialized

to zero and the only way we can know is

because our tripod pass will return us

back with true if s was converted

successfully otherwise false we can

actually write an if statement in here

if success open the curly braces and we

can start to type something in here so

we can take our console right line and

place it up here using alt and up Arrow

key and then in the lse we can say

failed to

convert so now we have a mini setup here

if it's been success uccessful we print

out the number if it hasn't been

successful then it'll go into this path

and it'll print fail to convert let's

have a look and see how this works now

if I press zero and I see Zero that

means it's followed down the success

path and this zero actually means it's

converted my input instead of just the

value that it's being initialized by if

you run the code again and type in 10 H

then we actually see it says fail to

convert and why that happened is we have

10 H appear and then this will return

back false when it tries to convert num

input and then after it hits this line

since success will be false it will

Dodge this path going into this path and

output fail to convert what you can do

if you really wanted to is you could

wrap this around in a while loop so

let's see what we can do so we can

specify a success and make that equal to

true and then we can add a while loop

with success in there and then open the

curly braces and put all of this code

inside here now we're going to have some

errors because we got success twice but

what we can do which will be a lot

easier is we can place this straight

inside our bracket and the reason why is

because this returns us back at booing

so we don't need to store it and then

use it another thing we can do is

instead of having Inn and then num right

here you can actually make this a

declaration as well so if we just remove

this value we can write out

in n and this will do exactly the same

thing it just uses less variables while

our success is true we come into here

and run this code if we failed to

convert then we still want it to be true

so we can loop around if we've converted

it and the value is successful then we

can actually make our success at this

point false cuz that will stop the W

loop from going around let's run the

code we can type in 10 H 10 a 10 a etc

etc and as soon as we type in a real

number then it will print it out and the

while loop will cancel and now right

here we're start on the console readline

now if we press enter the program will

close so let's have a

recap we use inter. trass so we can try

and pass a value before the program

assumes that the value is in the correct

format we give it a string variable and

it returns us back with a fresh new

integer called num or whatever you want

to call it inside here we we can place

this straight inside the condition of an

if statement because this function

returns us back with a true or false

value otherwise known as a bull if this

has been successful we stop the while

loop and print the value out to the

screen and if it hasn't been successful

then we print fail to convert and

because our success is still true it

will Lo back around to the start of the

while loop and ask the user to input

another value to try and convert this

while loop will only exit if it's indeed

been successful ful and the only way it

can exit is by having the success being

equal to false and the only way that can

happen is by having a successful

conversion the use of trass in every

program is very essential because if you

have a faat exception then your program

will close and you will lose all the

data the problem with that is you might

lose anything that you haven't processed

yet at that given point in your program

so you want to try and use triy pass

because you'll avoid any potential

exceptions and you can let the user know

if the conversion has been successful or

not and write yourself the same while

loop just like this so you can tell the

user hey you inputed it incorrectly but

this is how to do it right and make sure

that your program doesn't execute

incorrectly and make sure your program

doesn't just close unexpectedly and then

an error will be

caused in this exercise I want you to

print out some sort of times table and

what I mean by this is you want to ask

the user to input a number for the table

and then write WR a for Loop to print

out the x times table X is depend on the

value that they entered if they enter 10

in here then this will be the 10 times

table let's get started so we can have

our normal console.

write enter a

number and then use our int number

equals to convert to int32 and we can

say console. read line because we want

to read whatever the user types in then

we can have a four in I equals z i is is

less than 10 we're only going to print

up to the 10 * table so 1 * Something 2

* something all the way up to 10 times

the value that they

entered immediately we acknowledge an

error here when you do your 10 times

table for example you do 1 * 10 2 * 10

and so on and so forth the issue here is

we're going from 0 to 10 but because

it's less than 10 we're actually going

from 0 to 9 so let's change this to 1

and then less than or equal to 10 10 in

both cases we were actually looping the

same amount of times the issue is this

was starting on one and the other one

was starting on zero and the first one

was finishing on nine and this one's

finishing on 10 and we want them to go

from 1 till 10 instead of from 0 till 9

even though that's the same amount of

iterations it gives us different

values so in here we can just have a

console right line and this is how it's

going to work we're going to have our

first number times about our second

number and that's going to be equal to

something so our first number is our

value of I cuz that will say 1 *

Something 2 * something and so forth our

second number is whatever the user has

typed into the calculation which will be

number and our third number is going to

be the actual result of the calculation

which are these two times together so we

can have I star number and that should

be it let's run it and give it a shot

we can do our 10 times table and if we

press enter you can see that it's fully

working this will be our I variable

going down the side the second number is

what the user typed in and the third

number is this multiplied by this gives

you the output let's run it again with a

bigger number and it seems to handle

okay and because this is an integer

you'll expect to work okay up until

around 2.1 billion which is a big number

for some time tables anyway so just just

a quick recap we looped through from 1

till 10 instead of from 0 till 9 because

we made sure that when we do our

multiplications we don't want to start

the value at 0er * something we want to

start the first one at 1 * something and

we don't want to end at 9 we want to end

at 10 so using 1 and less than or equal

to 10 will get us the values that go

from 1 till 10 and that will make our

output look a lot more concise we're

using conditional format in here adding

the zero and curly braces and then the

one and then the two and in order to

insert the values in it's a comma

delimited list after the speech marks

the first one goes in the right order

zero is I one is number two is I times

the number running that code we'll get

this output there you

go so in this exercise I want you to

have a look and see if you can make the

Fizz bus game fiz buuz game is one of

the most popular interview questions

you'll come across

and the way to do this is to create a

for loop from one to something in this

case I'm just going to use 15 and inside

the for Loop you want to decide if the

numbers divisible by three and five then

you want to print Fizz buzz if it's

divisible by three then it's Fizz five

it's buzz and if it doesn't fall into

any of them categories then you want to

simply just print the number out to the

screen let's get started so we can have

a four and because we know how many we

want to do we want to do in I less than

15 i++

and then inside here we need to use the

modulus operator which is the percentage

sign so if you remember from the

tutorial in order to figure out if a

number is odd or even you could do the

number modulus 2 and if that value is

one then it must mean it's odd and if

that value is zero it must mean it's

even but what we can also differentiate

from here is if 10 modulus 2 equals 0

then that means that 10 is divisible by

2 but also it is even and if it's even

that means it's divisible by two if it's

not divisible by two that means it's not

even and therefore it's odd so in this

case if we try to divide three and five

we can have the same calculation but we

can work out differently so 10 modulus 3

actually gives us a value of one because

it's three remainder one so if this

value is anything other than zero then

we know that these two were not

divisible by each other 9 percentage 3

equal 0 which means it's divisible by it

so in our if statement we can say if I

which is the number that we're currently

up to

percentage 3 equals equals to zero and

because we want to check for five as

well we want to say and I percentage 5

equal equals to Zer and that means

they're both divisible by each other so

we can do a console right line and we

can say fiz buzz and then in our lse if

we're going to check if it's three and

we can repurpose this exact condition

because this just checks if it's

divisible by three and then we can print

Fizz and then if we copy this exact

structure down and change this to a five

to check if it's divisible by five then

we can print out buzz and in the worst

case scenario where none of them get

applied then we can simply print I to

the screen and actually there's no point

in starting at zero because normally

these start at one so we'll just do one

and we can make it 15 by making it less

than or equal to so instead of before it

was actually going from 0 to 14 now it's

going from 1 to 15 and they will tell

you this in the interview they might say

counting from 1 to 100 print out all of

the Fizz buzzers so let's run the code

and see what's going

on one two fizz fizz is actually three

so three is divisible by three then you

have four and then five is divisible by

five so you get buzz and six goes into

three so you get Fizz nine you get Fizz

because it's divisible by three then 10

/ 5 gives you buzz 11 12 goes into three

so you've got Fizz and finally when you

hit 15 it goes into three and goes into

five so we get Fizz buzz and the way to

increase this to 100 is by simply

changing this to 100 if you need to and

you can scroll through the entire input

and you can see all the history if you

wanted to make this slightly efficient

what you could actually do is store the

Boolean values for these calculations

before you can store the values for

these calculations before so we can say

bu 3 div equals false and bull 5 div

equals false and what we can do at the

start of each of the for Loop is we can

say three div equals this value and five

div also equals this

value and then every time we find a

calculation for three or calculation for

five we can replace it with either three

div or five div so let's change this one

here and this one here and our five here

and here and because these are values

now we want to actually store them as

true or falses so we don't need to check

if they're equal to zero so we can just

remove them so we can say if three div

and five div are both true and they'll

only be true if these two are both zero

now if we run the code and just make it

15 again just we have a shorter output

you can see that our code is exact the

same the reason why this is more

efficient is we're only doing this

calculation twice whereas before we were

doing it twice for three and twice for

five now we're doing it once storing it

and then making use of it this is a lot

more memory efficient than having to

calculate it every single time it

computes a lot faster and it's better

for readability if the rules of the game

happen to change and this was divisible

by four or six then you could just

change it very easily whereas in the

previous example you would have to

change in every single

case in C when you're constructing

strings that have backs slashes you're

going to need to use double backslash

and the reason for this is the first

backslash is an indication that it's

actually going to be an escape character

you're going to put an escape character

in and then put the character that you

want to display and the reason for that

is they've chose backslash as the

designated character so you can use

backslash and then a backs slash to to

show one backslash only and what this

means is it will use the first backslash

as a reference so it knows that it's

going to process the next character as

an escape character and what these

Escape characters are you can have

things like T for tab and for new line

and you can even use speech marks

because if you outputting some dialogue

and you wanted to say something like

this he

said and then you added your own quote

in there if you want to put something in

quotes then you can't because the speech

mark dictates that this is the end of

the string literal that's why it's cting

it off like this and then now it's not

recognizing that something is just WR

here and what it's actually doing is

you've got two strings specified one

that says he said space and one that's

just empty and then you just have this

something that's just in the middle of

course we actually want to insert the

speech marks within another pair of

speech marks marks this is where the

backslash comes in so you can insert a

backslash before here and this is now

acceptable and the same thing with the

normal backslash because the backslash

character is also going to be the Escape

character then you need a double

backslash so then that equals to a

single backslash when you print it out

let's Show an example so we have C colon

sl/ slash which will return us back a

single slash but visually right now it's

a double slash but when it gets

processed or outputed to the screen

you'll see that it's a single slash so

this common example is when you're

constructing a path together and you

want to use backslashes to denote the

different directories so let's output

this to the screen and see what

happens and as you can see we have a

single backslash because of the Escape

character we don't see both of them and

if we print the speech out to the screen

just to show you that as well then we

can see that there's only the speech

marks around the something and we don't

have the backslash you can tell when an

escape character is being used because

it goes a slight hint of yellow instead

of the normal color for a string so now

that we've worked out that this is how

this works let's see a way that we can

undo this to make it easier for us so

you've used the dollar sign for string

interpolation and you've used the plus

just to concatenate two variables

together and just as a quick example it

looked something like this your name is

and then the name variable and using the

plus you would say your name is followed

by a space and the quotation marks and

do plus name that's fine and now we have

another one so similar to how we place a

dollar sign before the speech marks we

have a verbum identifier and what this

means because it says verbatim it just

means whatever you see is whatever

happens so let's try and Define this

path a slightly different way but still

containing the exact same information

that you see when you print out to the

screen

so let's have a look we can reassign the

path value and just before the speech

marks we can put it at symbol and this

at symbol means it will actually negate

all of the Escape characters it will

process a single backlash as a single

backslash let's take this line of code

and place inside here now what you see

is that tint of yellow is no longer

there so if we print this past to the

screen let's see what

happens we actually get the double

backslash because it's ignoring all the

Escape characters which means if we take

them all out this actually looks exactly

how we want and you don't have to worry

about the Escape

characters there you

go these two are identical even though

one is being displayed using Escape

characters and one's using the verbatim

identifier please note that if you're

going to use the back sln for example

and I'll just demonstrate at the end of

this new line test and if we run that

code again you'll see that it's printed

the path on one line the back sln has

made it go on to the next line and now

it's printing new line test on a

dedicated line that's fine the problem

is if you use a back sln or a back SLT

or any of these Escape characters during

the at symbol then it's going to process

it as literal characters which means you

can't mix a back sln with an at symbol

AS this is just taking the text verbatim

so if we try and run the code now you'll

see the back sln will actually appear in

the code if you wanted to do this then

maybe you could remove the back sln and

add a plus at the end and then make

another string that just has a back

slash n and then this string will not be

processed as a Verbatim string because

we don't have the at symbol right before

it so then we can have the exact same

thing here just to show you

this so now the these two are identical

again just as shown here and as shown

here the difference being that we can't

specify a back sln in the same string we

actually have to concatenate them

together because of the verbatim

identifier so let's have a look at

speech

marks so if we have a string name and we

can make this equal to hello and then

someone and we said before that we have

to use the backslash so we can activate

the Escape characters and that will work

and if we just print that to the screen

to make sure then we get hello someone

in the speech marks if we add the verbum

identify at the start then we see we've

got an error it's trying to process it

differently this is a little Quirk with

the verbatim identifier if you want to

insert a speech marks you actually want

a double speech mark on either side the

double speech marks will get processed

as a single speech mark because it's

within a speech mark the verb identifier

needs to know that you're specifying a

speech mark and this acts as the same

reason why you have a backslash here

it's slightly quirky doing it this way

but it still works as per you

expect and when you're specifying

something like name and we can say hello

someone so let's print name to the

screen and make sure it works in this

case we don't actually need to specify

any sort of Escape character because the

quotation mark is a separate character

to the speech mark and it doesn't

interrupt anything by placing a

quotation mark inside the string just

represents that as its own character

let's run that and make sure it works

there you go so just as a quick recap

Escape characters are very essential

because we can use things like back SLT

to give us a tab character in our

console output this can be very helpful

cuz you can almost mimic the use of

columns inside our console output you'll

notice that back sln is used quite a lot

in the console output so you can

separate lines without having to use

multiple console right

lines if you have a single backslash you

can't have it on its own if the string

is not a Verbatim string you have to

pair it with another character otherwise

you will get a syntax error if you want

to use the verbatim string then you can

put an add symbol before the string

definition and then it will ignore all

of the Escape characters for example

using backs sln Within These speech

marks will mean that the back sln will

literally be printed to the screen and

you won't get get the new line

functionality that backlash M provides

when you want to print speech marks to

the screen using the verbatim identifier

you have to use a double speech marks in

order for it to show up and as you can

see it slightly goes yellow and that's

the similar notation as using Escape

character when you don't have an a

Verbatim string if you're using other

characters that are similar to a speech

mark like a quotation mark because this

doesn't interrupt the syntax of the

language then this is fine because a

character can just be in inside a string

and to the compiler this is just a

character even though they are very

similar the quotation mark doesn't

affect the speech

mark the most common approach for

outputting values to the console is by

having this format you type something in

as a static string and then you add a

variable to it but when you're doing

long sentences this format can get messy

quite quickly so this will just output

both of these on separate lines the name

follow follow by the name variable and

the age followed by the age variable I

just have a console right line to split

up these two sections just so you can

see it visually in the console so if we

run this code you can see that both the

outputs are exactly the same and the

reason why is we can use this back sln

what this back sln is doing is inserting

a new line character just where my

cursor is here which is forcing the age

to jump onto the next line the reason

why this is a slightly different shade

to the age text is because it's an

Escape character back sln means new line

we'll explain this in a further video in

this section so don't worry about that

just know that it means that it produces

a new line so as you can see since we're

adding the name followed by the name and

then the age followed by the age then

it's getting a bit long and a little bit

tedious it's not too bad in this case

because we're not really printing out a

sentence we're just going straight to

another line but let's see what this is

going to look like if we start dealing

with more multiple pits of data your

name is followed by the name and then we

can add a comma and your age is and then

add the age and as you can see while

we're structuring a sentence then it

gets a little bit long we have to

remember to put in the spaces otherwise

our code is going to look funky when we

print out to the screen and the reason

for that is there's no spaces between

the name and the age variables so let's

put them back in and make sure the

output looks all

right now that the output looks like

this let's explore composite formatting

and what this means is we can get rid of

all of these plus symbols and replace it

with curly braces so let's actually

output this string again but just output

it completely static your name is

abber and your age is

23 and now if we've run this you'll see

that both outputs are identical this is

because I know the values for the string

variables appear here and I can input it

straight into here so now that we know

what our sentence is going to be we

don't need to add any pluses what we do

need to do is remove our variables so in

the case of this sentence our name

variable is here and our age variable is

here so we can replace this with this

curly brace notation we can have curly

braces and then we want to start this

value at

zero throughout the string you want to

have these values starting from zero and

going up incrementally from left to

right so our next variable would be our

23 and we can store it like this now

that it's got your name zero and your

age one let's see what happens when you

output it then we just get this and this

is very confusing that's because we're

not done yet so now that we've got our

string typed in we can actually place a

comma in here and now it lets us put any

object in and any object could be a

string an in a double or any data type

so we want to insert the values inside

here going from left to right so our

name is first and then we do a comma and

we type in Age and what this now says is

the name will get replaced by the curly

brace zero and the age will get replaced

by the curly brace one so now if we run

the code let's see what happens and now

you'll see that the output is exactly

the same and now look at the difference

between these two lines you'll see that

these multiple amount of Plus es and not

confusing and let's say you forget this

one then you're going to get a syntax

error and it's a bit frustrating to keep

on typing when you're trying to join

things together now we can clearly see

that this Flo is like a sentence and

this space here looks very unnatural but

this space here looks like it's part of

the sentence which makes our code a bit

more

complete and the same goes if you want

to print something like this and let's

convert this one so if we copy this line

down into here and we just remove the

spaces then it can look something like

this name followed by the name we don't

actually need this space here because

we're going to be going into a brake

line we can replace our name with curly

braces zero and our age with curly

braces one and then straight after we

can type name and age and if we output

this we'll see it's exactly the same

there we go so just a quick recap

printing strings and any other variables

to the screen has been not normally

achieved by doing a string followed by a

plus and then adding another variable to

it adding more than one can be a little

bit complicated and hard to track of all

the spaces that you're going to put in

and you might accidentally miss one of

them like this one here or this one here

are very crucial to the output if you

miss this one then it's going to say is

followed by the name all together with

no space we then introduce composite

formatting which lets us use this

notation of curly bra Z

and curly brace one to give us the

ability to store some variables outside

of the string and then insert them in

dynamically we took both of these

examples and made them down here using

composite

formatting so let's explore a new method

of concatenation that makes this look a

lot better the reason why this is an

issue is you have spaces in here and

sometimes you might forget these spaces

and it could mess up your program this

string here looks very very unnatural

because you're forcing the space but

when you run it you'll see that it is

actually what you expect the spaces are

complete and it makes perfect sense but

when you're writing it it kind of looks

a little bit stupid because you're

forcing the space and then adding a plus

and then the name and then another plus

and then another static string and this

just get a little bit long to type it's

fine when you have a smaller sentence

like this but when the program starts to

grow then it could be a little bit

problematic and you'll have a lot of

syntax ER is when you forget to type in

all the pluses luckily this can be fixed

let's duplicate this line down and let's

see what we can do so we have this thing

called string interpolation and it uses

a dollar sign as a reference we can

place the dollar sign before the

quotation marks and then what you can do

is you can actually keep this as one big

sentence so let's remove all of the

values and have it like this so now of

course this actually doesn't print out

variables because we've just replaced it

with text so if we just run this then

it's completely messed up because now

we're not using our variables and this

can be easily fixed because we've used

our dollar sign now we can actually wrap

our variables in this curly brace and

now you can see it went white if I

double click on it you can see that it's

referencing the

variable wrapping the variables in the

curly brace means that they can actually

be processed variables even though they

are still within the speech marks please

do not remove the dollar sign because

now this will be interpreted as string

text as you can see here putting a

dollar sign at the start will make into

string interpolation and then we get the

ability to have our brackets this can

make string concatenation very easy to

do because you don't have to worry about

all the pluses and adding them together

and don't have to worry about the spaces

as well this looks more like a natural

sentence and what you can do for

practice is you can actually just type

out the sentence your name is Aba your

age is 23 and then from there you can

actually just break down the variables

and know that you'll need one here so

you can replace that with name and then

you'll know you'll need one here so you

can replace that one with age and then

you can place the dollar sign right at

the end and then there you go you have

your solution this method means that

it's a lot cleaner to read easier to

maintain and make changes in the future

and that's the whole point of

programming if your code base is very

difficult to go around and understand

what's going on and potentially make

changes in the future then you've

already made a bad step and you don't

want to get into these nasty habits it's

fine if you're just going to have

something like this where it's not

really complicated at all a string plus

another string that's quite simple and

that's fine you don't have to go the

extra effort to put in the dollar sign

and wrap it around in the curly braces

even though I personally still would

because in my personal opinion this

looks a lot

better than having it like that you can

see that it's a lot neater it takes up

less code and you can see visually that

you're using a specific variable and you

don't have to worry too much about the

spaces because this looks like a real

sentence another method of string

concatenation which is the idea of

taking strings or objects and add them

together to form a sentence of sorts we

can say your name is followed by space

and then add the name followed by space

add your ages and then add the actual

age variable and we can also write the

exact same line using string

interpolation or composite formatting

just like this and like this we can

specify the dollar symbol and put our

variable in the bracket which is shown

here and here and for the composite

formatting we can take the content where

our variable would go and replace it

with incremental numbers 0er and one

wrapped around in a curly brace and then

specify in the correct order zero takes

a value of name and one takes a value of

age if we run this code you'll see that

that the outputs are

identical so let's explore this other

method we have a string test for example

and then inside the string Library we

have this function called concat and it

can takeing any amount of parameters

that we want to give it so we could say

your name is space and the quotation

marks and then we can add a comma and

then we can say we want to add the name

and then another comma and we want to

add and your

ages and the speech marks add add a

comma add the age variable and that's it

and we could just use CW tab tab and

type in test and let's run it and see

what happens and now as you can see we

get the exact same output and because

this just returns us back with the

string we can also just take this entire

line and paste it straight into the

console right line you don't necessarily

have to store it but you can if you want

to and there you go all methods produce

the same output another way you can use

this concap function is by giving it

array we haven't covered array so far so

I'm just going to show you this for

demonstration purposes don't worry about

understanding it so just a quick

explanation arrays are just ways of

storing multiple of the same data type

so if we have these three names inside

our names we can actually use the

console to print them all out so we can

say string. concat and then we can

concat the names together which will

just add all of these three together now

the problem is when you run it you'll

see they're stuck together so what you

could do is just add a space between

them and as you can see this is getting

a little bit tedious

now there's other methods that we can

use to concat some arrays together and

I'll show you that in the next section

but for now don't worry about it this is

concentrating on the string concat

function and we'll just demonstrate that

again so if we run the line of code we

can see that they're all the same so now

that you have four different methods of

printing out exactly the same

information you might be asking yourself

what's the best method I personally

prefer to use the string interpolation

because with this one you can easily

miss the spaces and you could produce a

bad output and it might be stuck

together it's fine when you can see the

lines right in front of you and you can

easily identify the spaces but when

you're adding about 10 variables

together then it could be a problem the

reason why like string interpolation

using the dollar signs and the variables

in the curly braces is that you don't

have to rely on missing out spaces

because it actually forms a sentence and

you just replace the values with your

variable composite format in which is

this one is very efficient and very nice

to look at because it allows you to

specify the sentence and then plug in

the variables after the only problem

with this is if you were to change this

value in the future or to change a

sentence you have to make sure that the

numbers add up just like in the first

example if you only have a short

sentence then this isn't really an issue

since you can see it all visually and

you also got to realize that these need

to be in the right order because if you

put Age first then it's going to put age

in this one and name in the second one

and that's going to be problematic

because it now mess up the sentence

using string interpolation you don't

actually have to worry about anything

because if you wanted to change this to

say your age is then you simply just do

this and that's very easy to do because

in this case you'd say your age is and

then you'd have to change a string and

then now that this is zero we need to

change this from being age and this one

to be name whereas in the first example

you could just easily change the value

in the curly braces instead of changing

this reference and the end reference

conar is not widely used just because

you have all of these methods available

where you can easily add stuff together

but there could be user cases later on

down the line where uses just so it's a

bit more obvious and it helps the

readability of your code and maintain

within a big project or just on your

personal projects when you're looking

back at your previous

code when you create an initialized a

string variable you might want to give

it the value of an empty quot and this

will just default the value to

essentially nothing you're giving it a

value but at the same time the value

doesn't actually contain any sort of

characters if we print this out to the

screen then you won't really see

anything this video is going to focus on

string.empty and string. empty will

actually just represent these quotation

marks string.empty will represent these

speech marks so what we can do is we can

type in string using a DOT and then we

can type in empty just like that we've

initialize our string name to a value of

empty now this isn't necessarily used

when you're declaring an initializing it

because this is almost identical to just

defining a string on its own main reason

why this is used let's say we actually

ask them user to input their name so we

can say a console. right enter your name

and then we can take this string

variable move it down using alt and then

arrow keys and remove this and let's

initialize it to a console. readline to

read in the value from the

console and now what we can do is using

our is string interpolation method that

we just learned we can print to the user

your name is and then the name in The

Curly braces now let's just see what

happens so let's actually type our name

in abber and it says your name is ABBA

but what if the user just types nothing

and just presses enter Then it still

says your name is blank now let's see

what we can do here we don't necessarily

want to say your name is blank we want

to check what this value is so we can

say if the name is not equal to empty

quotation marks then we can output your

name is and then then else we can say

name is empty

and then if we run it now and press

enter it says name is empty so we can

use string. empty instead of these

quotation

marks this looks a lot better when

you're trying to compare it your

name is and then when we press enter

it says name is empty this just helps to

keep your code a lot tidier just so you

don't have to write the two quotes if

you accidentally put a space in there

now your if statement is incorrect if

you always use string. empty then it

just helps you to make sure that your

code is going to to be maintainable and

readable in the future reading string.

empty gives you a better representation

of what's going on instead of two open

quotes if there is a situation where you

want to check if one string equals

another string then you can do the

following if message equals equals

compare then we can print out same and

then else we can print out

different and as we can see here they

both have a capital H and they both say

hello so they should be identical let's

run the code and find out so they say

same which is exactly what we'd expect

so we have another method of being able

to do this so even though we can apply

equals equals to two strings it's

normally better practice to use equals

and then place the other string inside

the brackets so you're saying if message

equals compare now if you run the code

you'll see that it's the same

output in certain circumstances where

you want to ask what the user has

entered enter your name and then we can

use a string name equals console.

readline we can say if the name does not

equal to empty strings then from there

what we can do is type in your name is

plus

name and then we get some output

your name is but since we're

checking if it's not equal to that that

means they've entered something in let's

see if there's another way that we can

actually write this so if we just

duplicate it and comment it out so we

got it for reference so what we want to

do is we're checking if name is not

equal to empty quotes so we can say name

do equals empty quotes but what this is

telling us if the name equals empty

quotes then we should do this so then

what we can do when we learn about the

if statements is we can use the not

operator and we can say if the name not

equals to empty quotes then we proceed

with this line else we can just

say and valid name

input let's run that and see what

happens if you type in then it

passes fine and if we type in nothing

then we get an invalid name input the

reason why equals equals and the equals

function are different is because lower

level using equals equals will actually

compare the reference in the memory and

the reference in the memory is what's

used up when you actually create these

variables so what this is doing is it's

comparing the value that's actually

stored in memory to the other one that's

stored in memory now the problem is when

it comes to something like arrays where

you actually have the same value but

they're slightly different let me

demonstrate so I'm just going to use

this code because we haven't covered

arrays yet so I'm just showing you an

example if we have a chart array that

literally says hello and then we can use

this line of code to join them together

but this is actually an object instead

of a string but if you see what we can

do in the if statement we can say if the

message which is equal to hello we can

use message. equals and we got the new

compare and this is actually an object

so now we're comparing a string with an

object and generically speaking an

object can hold any sort of value

because all of these variables that are

strings in double Etc they're all deriv

from something called an object which is

just a very generic way of storing

information so since these two data

types are little bit different they

still evaluate the same thing what the

equals function is doing is actually

checking the literal values of the

variables instead of checking the values

that are held inside the memory address

location and the difference here is even

though we have a character array that is

giving us the values hello and our

string is also given us the value of

hello if we run this line of code that

uses do equals then you'll actually see

that the second same actually represents

the bottom if statement so what that's

doing is it's actually giving us back

the comparison saying that it's true and

it is indeed true because hello is is

literally equal to hello but if you were

to use the double

equals then what you'll realize when you

run the code is now it'll say it's

different because what it's doing now is

it's taking a string object and

comparing it to an object and they are

not different because of their memory

and that's what the equals equals is

comparing it's not only comparing the

value it's comparing the memory address

location and that's going to be vastly

confusing because you don't want to hit

these situations so it's always best to

use the equals function because the

equals function is concerned about the

values rather than where they are in

your memory I hope that made sense and

it wasn't just confusing but basically

when you use equals equals it checks the

values that are actually wrote in your

computer's memory instead of the value

itself it will do both it will check the

memory and check the value whereas when

use do equals it is only concerned about

the values and that's all that matters

when we're doing an if statement like

this we're checking if they're both the

same so it shouldn't really matter how

and where they are stored the only thing

that matters is the values contained

within the variable we're only caring

about the values and not where they're

stored so when we have a string variable

defined in C we have it like this and

when we print it out to the console we

get the entire string being

displayed but what if you want to return

the first element back and not the rest

then what are your options so in the

later video in the of course we covered

the substring function and technically

you could go from the first character

till the second character and you will

just get C back so that's index zero

till index one and you'll get the cback

now the problem with that is that's an

extra function call of something that

should be quite simple and it is a

message is a string and strings tend to

be an array of characters which is

similar to this we haven't learned about

array so far and we'll cover that in the

next section but what an array

essentially is is it lets you store

multiple of that data type so we could

have a chart array that holds exactly

the same value and each position will

hold each one of these characters and

the reason why I'm mentioning this is

because with strings you can use the

square bracket notation so if you add

some square brackets at the end it says

here it returns back a Char and it takes

in an index gets the CH object at the

specified position in the current string

object so if we use message zero you can

see that returns us back with a ch ch

right here gets the CH object so we can

call this on a string and it can return

us back with a character because like I

said with the array of characters that's

essentially what a string is each one of

these is just its own independent

character and a string lets you pair

them all together so if we print this

out then we should get C because it's

zerob based so if we copy this down and

use

one 2 and three then what should we get

we get

C then we get actually nothing

technically because it's a space

character and then the third character

which is the fourth in the list because

it's zero based is going to be our I so

let's just print this out to the screen

see what happens there we go so even

though we don't see it visually there's

actually a space character right there

and that's the third character in The

List which is right here so of course we

don't tend to know how long the string

is unless we can see it visually and if

you were to reference one of these

values and the string is not actually

that long then you have a problem let's

demonstrate if we have the string just

called C and let's comment out the rest

then that's only two characters so only

zero and one will be applicable these

two will return back something let's

have a look and see what happens so the

first character and the second character

will run fine and let's put a console

read line in there just to break it up

so the other code doesn't run yet if we

run the code we get our C and that's the

max length of our string so far it's

zero and one now if we press enter let's

see what happens we get an index out of

range exception index was outside the

bounds of the array and the reason for

that is we only have two characters

inside our message and we're trying to

display the third and the fourth this is

problematic because we literally don't

have any of them characters to

display so what we can do instead is

actually write ourselves a little Loop

to go through the entire string and

return us back all of these character

positions instead of us just guessing

how long the string is so if we return

this string back to normal and then just

after this little section we can write a

for Loop in I equals 0 and I is less

than message and then we have access to

dot length this gets the number of

characters in the current string so we

don't have to worry about the maximum

length in the square brackets we can

always rely on dot length because we

don't have to keep track of it and the

language can know that for us and give

us the

value in this case we're going from zero

to whatever the length of these

characters are and then in here we can

actually just conso right line and we

can do the same notation we did here

we're saying we want to print the

message but not only the message we want

to print the index and the index is

going to be I in this case because we

start at zero since it's zero based and

then we're going to the last character

so let's print this and see what

happens so now we get C Is Awesome from

here down to the bottom c is awesome

print on every single line and that's a

little bit annoying to read so what we

could do is just change this to a

console right and maybe we can just

comment this section out just so we can

see this

properly there we go so we get c is

awesome and because it's a console right

it's right in them all next to each

other and they're being printed out one

by one let's add a cool little effect I

can demonstrate you for now so inside

the system. threading Library we have

this sleep function so what we can do is

we can add another using command system.

threading we already have threading do

tasks in there but the function that we

need is inside the threading Library so

there's two ways we can write this we

can actually write everything by hand

like this dot sleep or you could just

remove the system. threading because

we've added it at the Top If you don't

want to add it at the top that's not

really a problem you can just include it

straight into here adding it at the top

will include it within the entire

project but if you're only going to use

it once or twice then sometimes it's

better to just include it straight into

here because it'll make your overall

program size a lot smaller so let's just

keep keep it in so we can make our Corde

a bit more readable so we have thread

dos sleep and what this will do is it

will suspend the current thread for a

specified number of milliseconds there's

a th000 milliseconds in 1 second so what

we can do in here and we're trying to

mimic a typewriter effect so we can say

something like 200 which will be roughly

a quarter of a second so if we've run

the code now let's see what happens so

we get this cool effect where after it

prints out each of the characters it

will print out the next character only

after it's being asleep for a quarter of

a second and that looks kind of cool if

you wanted to speed it up you could just

decrease this number there you

go of course if you make it too low then

it might be too fast for you to actually

acknowledge what's happening and if you

also make it too slow then it's just

going to take too long to turn off and

at that point you can use contrl C on

your keyboard or use the stop button at

the top to terminate the program okay so

let's have a look at another thing that

we can do with this so maybe we can make

this 100 for now in the previous videos

we've used use a function called

contains and let's say we're just

checking if it contains C and we know it

does because we can see it visually

let's run the

code and we see we have true being

printed and the reason why true is

actually on the same line as c is

awesome is because we're using console.

right here so it's actually not made a

new line character just after the E so

when it's printing true it prints it

straight after that so what we can do to

fix that is just place a new line

character in here using console.

readline and we can just drop this a

little bit lower to 50 there we go so we

have true and what we can do with this

is we can actually make our own little

version of the contains function let's

demonstrate so if we make this exact for

loop again in I equals z i is less than

the message. length and i++ so first

let's kind of understand what's going on

with this function returns a value

indicated whether a specified subring

occurs within this string and what that

means is it will return a Boolean for us

if C is inside our message then this

will return back true and we know this

is true because we just outputed it to

the screen and we can see this visually

so what we need to do is we need to Loop

through our message and try and figure

out if we can find C inside our message

and then we can give back a value is

true so maybe we can do a bu contains

equal false and the reason why we

initial it to false and the reason why

we initialize it to false is because we

want to set it up telling it that we

haven't found it and then inside the for

Loop if we find it then we can set it to

True let's have a look so after the for

Loop we can print contains of the screen

and then inside the for Loop what we can

do as we've seen here it returns back

every single character so you'll get

back C sharp then the space then I then

s and so on and so forth and what we

want to do is we want to go through each

of the characters and then just ask if

the variable is equal to C if C is equal

to C then we can assign this to true and

then go through #is equal to C if space

is equal to C and so on and so forth so

we can write a if statement here that

says message square bracket I is equal

to equal to apostrophe C and the reason

why I said apostrophe is because this is

a character and this also returns us

back with a character so we need to

compare them both like that if we use a

string in here then it might complain

that we're trying to convert between a

Char and a string and it won't let you

do the equals equals operator between

two different variables maybe what we

can do instead is to follow the approach

that we used before and use the equals

function and place our C inside here so

if the character that we're currently up

to inside the for Loop is equal to our C

which is what we want to search for then

we can set our contains variable equal

to true we don't need to write an L

statement in here to set our contains to

false because we've already gave a value

at the start if we didn't have this

value then it'll be beneficial to do

this but since we have it then we can

remove this other path and we don't

exactly need it so let's have a look and

see if this

works perfect it says true maybe we can

change this character to something like

a make sure this

works which it does as well so perfect

so now we've made our own mini little

contains function inside here and we can

also use the C library one but the

purpose of this exercise was just to

show you how we can iterate through a

string variable and then decide what

each of the characters can be equal to

and then we can decide if they're equal

to another one and then let the user

know that we found a match for their

search

term so far in the course we've covered

the equals function and the contains

function when you're searching through

strings or trying to find values let's

have a look at a method that makes sure

a string is valid before we can process

information on it so in this quick

example we have a name output we're

reading the value into a string name and

then we simply output it to the screen

if we run the code and just press enter

then it says your name is blank and we

don't really want that because we want

to check if your name is equal to

something before we continue so let's

look at some methods so we have if the

name is not equal to nothing and then

let's just print zero to the screen and

that's one of the methods and we can say

if name is not equals to quotation marks

then let's print out number one so what

this is doing is checking if the name is

not equal to empty quotes and then this

is doing exactly the same thing except

we're using the equals method and let's

just run the code and press enter and

you can see the zero or the one doesn't

appear because it's detecting that it

contains nothing so if we type in a real

value we can see Zero and one coming up

so these are both valid ways of checking

if the string is not empty so let's look

at a third one and this one is actually

very important for reasons I'll explain

in a second so inside our string Library

we have is null or empty so we place our

name inside here and let's see what this

says now indicates whether the specified

string is null or at an empty string so

this can be very effective so what this

reads now is if the string is null or

empty then we print a value but we want

it to be not no lower empty because it

wants to have some contents so if we

type a value in again you'll see now we

get all three numbers and what them

three numbers mean is that it's past all

of these checks and each of the checks

just ensures that the value has got

something inside and that's fine but it

can be slightly problematic for this

reason using this method and this method

are fine in some cases except as it says

here it checks if the string is null and

null means it doesn't have a value but

it just has nothing instead of something

let me demonstrate if we assign the

value of empty quotation marks this

actually has a value but the contents is

empty but it still a string as it comes

up in here if we assign this the value

of null then it's just a key word that

we can use to denote that this literally

has no contents it's not that it has an

empty string because an empty string is

still actually a string whereas a null

it just means the variable is blank now

this is where the issue arises if we try

and call a method on something that's

null Watch What

Happens we actually get an exception and

our program just crushes you can't run

any any code on something if that

variable is actually defined as

null it doesn't mind if you check the

value of it but if you try and run a

function then you've got a problem so if

we comment this line out this ensures

everything it ensures it's null or it's

empty and this is the belt and braces

option because if it's null we don't

actually get an exception when we try

and run this code as

follows we get the zero showing up

because our variable has something

that's not speech marks and it's

actually null so we want to avoid this

option as well and also avoid this

option in case our string is actually

genuinely

null using is null or empty we check

both for the value of null which is

right now and if it's got empty quotes

EG the value is empty so if we just run

this again and have these two paths

commented out we can see that two is not

appearing if we change this back to our

console read line and we try and do it

then we get our number two because it's

validated that this string variable has

got something inside it and the variable

is not actually no this is a very good

way of being able to make sure that your

program doesn't get exceptions as with

calling these equals if you want to call

equals then call it inside here you can

check if that variable equals something

by simply placing that if statement in

inside here after you validated if the

name variable able actually has some

contents if it's null or it's empty

running equals on it will just break the

code further and you don't need to check

if it's equal to Something in here maybe

you were checking if the value is equal

to abber or something along them lines

and now if we run it again we actually

get the output

correct it's best to Nest them like this

because if you run this function on

something that's null it's actually

really safe but as you saw previously if

you run a function on something that's

null then you're going to get a null

reference exception and your program

will close down and break you want to

avoid exceptions at all cost so nesting

it inside a is null or Remy check will

be perfect for your code it improves the

stab ability of your program to ensure

that exceptions don't

happen so in this exercise I want you to

ask the user to input any message and

then I want you to print the message in

Order character by character and then

also print it in reverse character by

character let's get started so we could

just have a console right line but let's

change it to a right and just say enter

your message call on and then speech

marks and then just have a string

message

equals console. readline perfect so in

order to be able to Loop through the

string message we need to have a follow

Loop if you remember from our previous

videos we can have this string variable

followed by a square bracket and then we

can have an index inside and that will

print us back any sort of index based on

that position so if we just have this is

a test then it's prob print as the T

because that's the first index and so on

and so forth so what we can do with this

information is take what we can do with

the string index and then also use the

property which is do length and then use

these two values to be able to process

this is a test so we have the first

character Square braet 0 and the last

character is at length 14 so our message

variable now contains 14 characters

obviously When I close the program then

that value is lost and I have to reenter

it but because of that exact reason we

would always use do length because we

never know how long the users input is

going to be so we can have a for Loop so

we can say 4 into I equal 0 I is less

than and we can use the message. length

here and then we can say I

++ so we want to start at zero because

our first index position is indeed zero

and we want to go from the index zero

all the way to the length

now in that example I just printed out

14 for the length but you got to realize

is there might be 14 positions but

there's only 13 indexes so it's not

actually 13 index it's just up to 13

when you start at zero going from 0 to

13 gives you 14 positions so when we're

saying 0 is less than the message length

then that'll actually take us from 0 to

13 instead of 0 to 14 if we made this

greater than or equal to and change this

to to one for example then that's going

to go from 1 to 14 and first we're going

to miss out the first character and

we're actually going to go one over the

message length so you always want to

start from zero if we're going through

the entire string so this will go from 0

to 13 and then here we can just have a

console right line and just print

message Square braet I and then just for

the time being we can comment out these

lines just so it doesn't saturate the

output so let's run this code and see

what

happens this is a test and then we get

them all on separate lines maybe we can

just use a console. right instead so we

get each character on the same line

instead of a new line character being

outputed at the end of each of the lines

so we can say this as a test again and

there we go we get this as a test

outputed as well so now that we've

printed that in order let's see how we

can print it in reverse so just a quick

little tip throughout this course I've

been quite hard on you I've made you Mar

the for Loop out exactly the way it

should be but all done manually this is

so you can get used to the syntax and

after a while once you understand

exactly what to do then what you can do

is when you type in the fall you can see

that it says as a force snippet tab

twice to insert the force snippet and we

can do that now and it actually gives

you a little bit of an output you can

see these sections that have been

highlighted the reason they're

highlighted is once you're done with one

section you can actually press Tab and

it'll jump to the next one so now my

cursor is jumped on the length and we

can type in message. length if I press

tab again then it'll just keep cycling

through them until we're done and we can

press Escape upon pressing escape then

it gets out of the little message and

there we go we've now just defined a

really quick for Loop please only use

this once you're comfortable writing for

loops and don't use them immediately

because you might get stuck on what to

do and how to do it so it's best to

always write the for Loop syntax out

from scratch so you can get used to the

three different sections so this is

actually a full loop that goes forwards

it's going from 0 to 13 but what we

actually want to do now is go from 13 to

zero so let's actually change this for

Loop completely and we can do our little

shocket again so if we do four and then

we don't actually want to start on the

value of zero we want to start on

message. length and then you want a

minus one and just as we said here we

never actually want to get to the length

because we want to go from 0 to 13 so if

we want to go backwards we want to go

from 13 to zero and the only way that we

can get this 13 is by getting the 14

value which is message. length and

simply minusing one so now that we've

got our first variable which is in I

equals message length minus one which

will give us the 13 we want to go from I

and instead of less than it's going to

be greater than or equal to and then we

actually want to change it to a zero

because we actually want to stop at zero

in this case and then we don't want to

use I ++ because if we start at 13 we

want to go down in one instead of up in

one so we can simply just just do minus

minus we can take this exact line and

print out to the

screen and if we just print something

small in between like a hyphen just to

separate the two outputs and let's see

what

happens test there we go so we have test

and then t s e and t is now in Reverse

but now you might be wondering if we had

a shortcut for the four what's this four

with an additional R cords n it for a

reverse for Loop so if we tap tab twice

you can see that we have exactly the

same format inti equals something minus

one which we have right here and then we

have I is greater than or equal to zero

as is we have here and then we have

iusus just like here so we can literally

just change this into message do length

and then these two now are exactly the

same so just copying this down we'll get

us exactly what we need but obviously we

just wrote this I just wanted to show

you the shortcut so let's try it with a

longer string this is a test there you

go and if you wanted to you could just

print these on separate lines so you can

just change this into a right line for

example and have it like that it doesn't

really matter the rest is up to you but

the task is just so you can print it one

way and then print it the other way I

realized that what you can also do is

just simply print a console right line

and have message in there and just get

rid of this completely and the output

will still look exactly the same there

you go and and the reason why I told you

to write the for Loop is not because

it'll be easier if you do this it's more

for your Educational Learning purposes

having more practice to how to iterate a

string variable is very helpful for the

future and you can understand it fully

if you just print out to the screen then

you're not learning anything extra

you're just applying what you already

know so let's just have a quick recap we

ask the user to enter the message we STW

it into a string variable and then I

demonstrated that you could use the

square brackets to Output the first

index then you can output the length of

the entire variable using a follow Lo we

can go from zero to message length which

will give us from indexes 0 up until 13

in this case and then we can go through

i++ increment in one and then we can

have a console right which will just

print out message index I for the index

that we're currently up to and then we

break it off with a console right line

just in the middle because these are

printing on the same line so we need to

insert a new line character at the end

after we've done that what we can do now

is print it in reverse and now we can do

exactly the same thing except from 0 to

13 we go from 13 to 0 so we start at the

message length minus one because the

length was 14 and now we minus one to

get to 13 and we're going from I is

greater than or equal to zero because

that's the value that we want to stop at

and then we can do IUS minus if we were

to take out this equals operator let's

see what happens test and now we're

actually missing the last character

because what we've done is we've

actually went from 13 to 1 instead of 13

to zero so let's put that back in and

make sure it works and then we have t

set for test and then we're outputting

the exact same thing in both for Loops

because we're simply just printing the

character that we're currently up to and

because this for Loop starts at zero and

this for Loop starts at the length minus

one then they output in the same values

or what it appears to be the same values

it's just starting at different

indexes in this exercise we're going to

be building some sort of a password

validor these can be present in

something like a register form where you

ask the user to enter their password and

then enter it again to make sure that

they've entered it correctly you want to

ask user to enter their password in

twice andall them both check if they

both contain something if they do we can

print out password match if they don't

passwords do not match and if they both

contain nothing then you want to Output

please enter a password so let's get

started first we can have a console

console right we can have enter password

string password equals console.

readline and then we can just copy these

two lines down using contrl D and then

we can have a password C for password

confirmation and we can say enter

password again and let just print these

out to the screen just to make sure we

know what's going on just like so so we

can have abber and then abber again so

now we have both abber started and

that's

fine so let's see what we can do now we

need to check if they both contain

something so what are the different ways

that we can do this so we can have if

password do equals and then we can make

it equals to string. empty and because

we want to check if it's not empty then

we can simply place the not operator

right at the start and then we can join

them with another one not password.

equals and then exactly the same thing

string. empty but in this case we don't

want to use password we want to use

password see there we go so if we've

came into here then that means they must

have entered something so let's just

quickly do our exit path which is if

they're empty please enter a password so

we can say else and we don't need a

condition here because if this were to

fail then it has to mean that their

password's empty so we can have a

console. right line and we can just do

please enter a

password and let's just test if this

path works first and we just press enter

twice and we get please enter a password

and maybe if we type something in for

both and then we get nothing because

it's actually came here now perfect so

if we come through and we can say

password equals equals password C or we

could use the equals function and we can

say password. equals and then password C

and if they both equal to each other

then we can print out passwords

match there we go and if that were to

fail then we can print out passwords do

not

match here we go let's run that let's

find out Aba and abber and we get

passwords match and if we try abber and

abber with two A's and then we get

passwords do not match so what are some

other ways that we can do this you can

structure this completely differently

right now we're doing both checks in one

single if statement and we can actually

split this up into two and then provide

a different error message so right now

this is please enter a password you

might have entered the second one but

not have ented the first one or vice

versa but it doesn't matter because you

have to enter both of them in order to

pass this validation check so what you

could do instead is actually put another

if statement inside and paste this one

inside here and then just keep these as

two separate if statements and then you

can actually provide different error

messages so let's Nest this in one

deeper so we can say if the password is

not equal to empty and if this returns

back true then this variable has

something inside it and then once we go

inside these curly braces we get another

check and if the password C is not equal

to nothing then that means if we've came

in here then we pass both of these

validation checks and both of them

contain something and then we can

proceed to check the variables so what

you can do in the first L statement is

you can say please enter a password but

on the second one so just after this

curly brace we can have another L

statement or we can say please enter a

password

confirmation so I know that was a bit

quick so let's just have a quick recap

so we can have have one if statement

that processes the first password that

you type in and if this is empty then it

says please enter a password and if it's

not empty then it'll go inside this

curly brace hit the first line and check

if the password confirmation is not

empty if it is empty then it'll say

please enter a password confirmation if

both of these return back true then it

will go inside the success path in which

it will actually check if password is

equal to the password confirmation and

we can say the passwords match or if

they don't equal to each other we can

say the passwords do not match let's run

that and see what we get so if we type

something in for the second one but not

the first one so for the first one we

just press enter and then let's type

something in for the second one and it

says please enter a password and then if

we run that and do the complete opposite

type in p and then press enter for the

second one then it says please enter a

password confirmation so you can see

immediately what we can do is provide a

different error message for different

situations if you include these both in

one

then you can only give out more of a

generic error message this is similar

for when you go to login and when you

get your password or email wrong it

doesn't say which one you've got wrong

it just says them generically which one

you've got wrong it says invalid

credentials or invalid username or email

it'll say them generically like invalid

username or password but it won't tell

you which one it is because hackers can

exploit this and you don't want to be

doing this but in the case of a password

confirmation and this is just for a

register form then it's not exactly the

the worst thing to do this because

sometimes what you'll see is the text

boxes might go red to indicate that

they're both not equal to each other and

this is fine on registration but it's

not fine on the login what we can also

do in here once we've checked if they're

both not equal to something we can

actually just validate how long the

string needs to be we can have if

password. length and let's say you had a

restriction and it can only be over six

characters and we can say six and

password

c.length is greater than equal to six

and once it passes all three of these

checks then we can check if they're

equal to each other if they got

something inside and if they've got

something inside and if they've got both

the length is greater than or equal to

six then we can check it so we can have

something like password and then

password and then this returns back with

password matched if we have something

like abber then it's actually returns

back nothing because we don't have an

else for this specific bracket so we can

say else conso right line please enter

six or more

characters so if we type in Alber twice

then you can see we get this message now

please enter six or more characters so

right now we have a validation for the

first password and the second password

and for the length and if all these

checks go by then you can process the

actual passwords that they've entered

and check if they're equal to each other

you can technically do all of these

checks in one line it'll just be a

pretty long line but what that means is

you can't have three separate error

messages like this if you have it

process in one line the only error

message that you can give is very

generic there's no one generic message

that can fit for password empty and the

confirmation password empty and for the

length so maybe what you could do is

chain the both of them to be check if

they're not empty so then you can

process a message with something like

please enter a password and then you can

have another check for the password

length just to let them know that they

need to enter six or more characters

splitting these off into two separate

checks is going to be very helpful

because it'll let the user know

something a bit better than a generic

error message so in the previous

examples throughout the course we've

actually talked about using the to low

function and I said in majority of cases

where you want actually compare two

different things you want to actually

use the two lower function or the two

upper function and you can achieve this

by having two lower just here and then

also two lower just here

now the problem with comparing if

they're both equal to each other but

checking the lower gue values is this is

indeed a password if you're checking if

the user has inputed any capitals

lowercase symbols Etc then there's no

point implying a too low function

because that will just ruin their actual

password and reduce the security so in

certain cases you don't always want to

use two lower and two upper for

comparison you want to just check the

value straight up and the same thing is

when you're doing a login you don't want

to be checking the values lowcase

because that's their login these are

some of the specific situations where

you don't want to be using the two low

function if the data that your

processing is pretty sensitive and will

be messed up if you use the to function

that you should always avoid it

passwords fit this perfectly and

usernames as well if someone's added

some capitals inside the username then

you don't want to ruin that by doing

lower case or upper

case if your username is spelled like

this and you try and log on like this

then they're not equal to each other

because this will probably be two

different accounts you can have an

account with a capital B and have

account with a lowercase b so you don't

want to be lowercasing the input and

then doing a comparison because what you

might actually retrieve is a different

account than you're looking

for so now that we talked about stuff

theoretically let's see how we can do

things practically so as you heard in

the last video arrays are a way that we

can store multiple variables of the same

data type in one little group so if you

had something like num one equals 5 in

number 2 = 10 in number 3 = 15 and we

had a similar case in one of the

exercises like this where we had to work

out if a triangle was actually a

triangle so we asked the user to input

three different angles and then we

stalled them all and then we added them

up after and it looked something like

this in total equals num 1 plus num 2

and then finally plus num3 and then we

had some sort of if statement after to

check if the

total was equal to

180 and then we did something in the

curly braces just to Output that it's

valid and then else output it's

invalid you can see how this gets a

little tedious we have to create a new

variable every single time we want some

more data to be stored and in this case

we just simply want another number that

we can store but we have to just keep a

pending one to it in that case we could

have angle one angle two and angle three

but how about if you had something that

just called angles for now let's just

talk about how arrays work how we can

use them and then after I've went

through this example about arrays and

taught you what to do with it then I'll

will go get the code from the exercise

from the triangle video and actually

transform it into using an array so you

can see what the difference is and how

the new code will look like so let's get

rid of this little section so now that

we've got three integer variables let's

see how we can do this another way so

the Syntax for arrays you first type in

the data type that you want just like

before and then you add on a square

bracket and a closed square bracket

there's not nothing that needs to be

inside as of right now then you press

space and type in the variable name as

per always and then we can make that

equal to new in three so what this side

of the equal sign means is we want a new

instance of an integer array and we want

to have three positions since we have

three variables here that we want to

store we need to have three positions to

store them so this line in total says

that we want to integer array we want to

call it numbers and we want to

instantiate our new integer array with

three positions instancia is just the

term that we use when you turn something

into a new class at this point if we

don't use new then we're going to get

compiler error because it's unsure what

this is trying to tell you it's trying

to start an integer inside integer array

and that makes no sense so it won't

recognize the square brackets in this

case because it has no idea what it's

trying to do and this syntax is

completely incorrect so the compiler

doesn't know what error message to give

you so we can have a new int and what we

can do now is by us using the square

bracket reference we can actually

specify these three variables inside our

numbers array so now we have access to

numbers 0 = 5 and then if we use

controll D to copy this down twice we

change this to one and two and then

print 10 here and 15 here so now this is

exactly the same as this we have three

integer variables defined separately as

5 10 15 and now that we've created an

array of numbers we can specify all

three these values inside our numbers

array so instead of having three

individual variables now we just have

one that holds everything like a group

and just to show you how this works if

we have a console right line we can say

num one space num two space num three

and if we use controll D to duplicate

that down then what we can have instead

of these num ones is simply just place

these values

inside changes to one and changes to two

and what you should notice is these two

lines are going to print the the exact

same

values there we go so in this example

we've took our sloppy code that will

roll us around appending one to this

number creating a new array and then

printing it out so let's say we want to

actually use these to read in values

from the console what can we do and

you'd use these exactly the same as how

You' use variables up here this is just

an integer variable at a specific

position held inside a group so we could

simply have a console right line delete

the right and just say enter a

number and then instead of starring five

we can say convert to in32 and then we

can have a console read

line and that will read in from the

console convert it to an integer 32 and

then store it into the first position of

our numbers array and now if we just

copy this down

twice and we can get rid of these two

lines cuz this is just staring it

statically and add one and two to here

so now what we're saying is enter a

number star into to 0 1 and 2 and let's

see what happens now so now we get asked

the numbers 10 20 and 30 and you can see

that they've been stored here of course

these haven't changed cuz this is still

referencing our static variables up here

so what you can see in this example is

now that we've made an array we can

specify each of the values very easily

inside here and if so we wanted to have

a number four instead of having to

duplicate it and rename it and change

the value for example we can just simply

turn this into four duplicate this

little section and then just change this

to a three one thing to note in C and

many other languages almost every single

index will start at zero in the last

section we covered the string functions

and they also started at zero when

you're dealing with strings and their

positions when you have a for loop with

the string then you always want to use

index Z as the first position the same

is true here we have four positions

which means it goes from zero all the

way till three it never goes from 1 to 4

or from 0 to 4 these are bad values it

always goes from 0 to

three you might be thinking this looks

really good but when we go to print it

we're going to have to copy and paste

this little section add another one and

rename this to three this gets a little

bit tedious if you just trying to print

them all to the screen so let's see how

we can fix that we can use a four Loop

for this so we can have four inti equals

z

I is less than and then we can have

numbers length and if you notice from

iterating through a string variable the

syntax is exactly the same we have a do

length property on the arrays as well as

we do with a string

variable so in order to print out this

line what we can do is print one of them

every time we go around the for Loop

instead of using a console right line we

can just use a console

right so we can have console.

right and then what we can simply do in

here is we can say numbers square

bracket I and then we can have a space

right after it just to M make what

happens here we have the number printed

out and then a space after it number

printed out a space after it and so on

and so forth so let's see what happens

now if we run the code 10 20 30 40 there

you go so you can see that these two

lines are exactly the same and now what

happens is let's just comment these two

lines out and if we were to change this

to five and we can duplicate the

section change this to a four and then

now we have five variables started and

we don't need to touch this for Loop

because the numbers do length will get

updated anyway so we can have 1 2 3 4 5

and you can see all five variables have

been printed automatically what also is

quite tedious here is we're having to

add another one to this just so we can

ask the user how many times that they

want to enter a number again this is

quite tedious but we also have a fix for

that

because we know how many times we want

to ask the user to enter a number then

we can use a for Loop to iterate through

and ask the user as you can see every

single line here is exactly the same

except for the index position that we're

dealing with and the same is true for

this for Loop this line will always be

the same as we're printing out here and

the only thing that changes between this

section and this section is the fact

that this says one and this says zero so

we can translate this into a f Loop to

make it

Dynamic and we can do exactly the same

thing above here so let's actually copy

and paste this for

Loop because we want to do exactly the

same

approach we want to go through all the

positions inside our numbers array and

then we can actually ask the user to

enter a number in so let's block comment

out this massive section and then we can

take one of them and place it inside the

for Loop so now we're asking the user

enter a number and then we're storing

inside index IND Z and of course if we

keep using index zero then it's just

going to override the first one and

we're not going to store any data so we

can change that to an i let's see what

happens when we run it now 1 2 3 4 5 and

then we get the five numbers being

printed this is awesome because what

we've got now is five output commands

coming straight to the console just from

a for Loop the for Loop is responsible

for printing them all out to the screen

reading in the value convert it to an

integer and then storing it inside our

array and then we have a separate for

Loop to print out to the screen what's

really really powerful about these two

for Loops that we've built is if we want

to have 10 numbers now we simply just

change this to 10 and then just rerun

the code as you can see we now have 10

numbers there you go so what we've just

done if we move this code down a lot now

just so we can have it close

by we've made our entire program that

was actually pretty lengthy into just a

couple of lines and two for Loops one

for Loop is responsible for looping x

amount of times x depends on whatever

that number is and then we go through

and ask the user to enter a number read

in from the console convert it to an

integer 32 and start it within the array

after this for Loop has finished running

then we have all the numers stored

inside our aray and then we can go

through and print them all out to the

console another way we can print this

out to the screen is by actually using a

for each so we can say int num and then

we want to be a number inside our number

so for each of the integers inside the

number we want to create a new local

variable called num and then we can use

it in here and if we take this line and

copy it down everything's exactly the

same except we don't need to specify the

main array numbers now and we don't need

to specify the square brackets we can

just change this completely and replace

it with n and if we just make this

number smaller so we don't have to

Output a lot of

values 1 2 and three and you can see

that they're exactly the same there's no

line between them CU I don't have a

console right line so let's quickly add

that

in and there we go 1 2 3 and you can see

they're outputting the exact same

values the reason why I needed a console

right line is because these fall Loops

are using console. right the problem

with console. right is even after

finishing writing all of the lines it

doesn't continue to the next line it

stays there so if I don't break up the

two outputs with the console right line

then all six outputs from the console

right and the other console right will

all go on one line this is just for

demonstration purpose anyway either one

of these Solutions are fine more people

tend to use this one the problem with

these two options is you can't always

use them

interchangeably this one will always go

through every single position it will

always go from zero and it will always

go to the length the problem with this

fall Loop is you can't choose how many

times you want to iterate through before

you stop there might be a very specific

case where you have a big array of data

but you only want to select a specific

range if you example where you had a

th000 array positions so from 0 to 999

and let's say you wanted to request and

run a for loop from 500 to 600 so you

would literally type in 500 in here and

then 600 inside here and this would be

fine as long as your array has that many

positions but with the 4 each Loop if

you run a 4 each loop on a thousand

length array then it's going to go

through every sing single position in

some cases you might not want that and

you only want to go through specific

cases so if you know you're going to go

through every single case then you can

use the for each but if you know you're

going to go through a certain amount of

cases then it's always best to use the

for Loop okay so we covered quite a lot

in this video so let's just have a recap

so initially we started off saying we

have our gome one gome two and gome

three then we had our static variables

stored inside there and then we created

our integer array which is now down here

and just just to make it a little bit

easier to store multiple variables

because if you wanted five variables

you'd now have to duplicate that and

change that to number five and this will

get very tedious if we had something

like 10 like before this is very long

and you don't need be specifying number

10 in your code because this also hurts

the readability of it using arrays can

solve this problem quite a lot you can

easily specify array using this notation

int square brackets followed by the name

and you make that equal to a new int

three the three can be any number that

you want as long as it's a whole number

cuz this tells us how many positions

that we've got we then outputed lots of

values to the console and read them into

our Ray but we had the same problem as

we did above where we just had to keep

duplicating the sections so what we did

to prevent that is by writing a little

for Loop that went through every single

position in numbers array outp puted

something to the screen read in the

value converted it and stored it into

the array and then after all that was

done we can use a for Loop or for each

Loop and print that back to the screen

now that we finished the base content of

this video and because I said at the

start that I was going to take the

triangle exercise and convert that into

an array so let's do that now so now

I've copy and paste a solution from the

triangle exercise straight into this

project I've just block commented

everything above just so it doesn't

interfere with our code so let's just

run this code to familiarizes with

what's going on so we enter 60 60 and 60

then it says valid

and if you run it again and enter

something else that doesn't equal to 180

then we get invalid so let's see how we

can make this code a lot better by the

use of arrays so as we said before we

don't want to be using this angle one

angle two and angle three let's make an

INT square bracket angles equal new int

and then in this case we have three

angles and what you could do as well is

you could say const int angle count

equals

3 and then you can simp L use that

inside here so later on in the code if

we wanted to specify this to a different

value we can just change that later

on so now that we've got three angles we

can get rid of these three lines and

write ourselves a little for Loop so I

goes from zero all the way to the

angles. length and then every single

time we go around in the for Loop we

want to

say console. right enter angle one and

then we can say angles square bracket

and not zero in this case cuz we don't

be specifying index as it will go from

zero to one to two we want to be using I

I because we're inside a for Loop that's

already going through all the indexes

for us and make that equal to convert to

in32 and then a console.

readline now we've got all the values

stored inside here let's deal with this

problem so if we just comment out the

total for the time being let's run the

code

oh we have one more error down here

sorry let's run the code again and we

can say enter angle one and we can type

the values in but as you can see we've

got angle one for each of the times what

we can do in here is use our I index to

print out the value so we can turn this

into interpolation and then wrap the one

inside curly braces and we can simply

change as one to an i and let's see what

happens now so we have enter angle zero

and then one and then two and this is

fine but humans don't like reading zero

they like reading 1 2 and three so what

we can simply do is say I + 1 and

because we're using I and then adding

one to it it's not going to affect the

variable inside the for Loop so there's

no problems by doing this this is simply

just for the output purposes so now we

can have one two and three just shown up

like that perfect so what we can do now

that we have all the angles stored now

we need to replace this line by writing

a for Loop that can add up all the

values for us so we can have four each

in angle inside our angles and we can

just say int angle sum plus equals

angle the problem with this is we can't

specify a new variable inside here and

then use it outside an if statement so

what do we do in this case you want to

take angle sum and initialize it out

outside the for Loop and then give it a

value of zero and then inside the for

Loop we can remove the int and we can

say angle sum plus equals the whatever

angle that we're currently up to so if

we had three values that's going to say

0 + 60 and then take that value and add

another 60 and then take that value and

add another 60 so it'll keep a running

total for us and if we just print out

angles some to the screen let's see what

happens 10 20 30 and now we have 60 and

that's the correct calculation if you

add them three together so now that we

have a running total for angle sum then

we're pretty much done if we get rid of

this line of code which is our previous

total and we actually bring back our if

statement there you go there's no error

now and all this is doing is checking if

the angle sum is equal to 180 and then

print valid and invalid so we can have

60 60 60 and it prints out valid and

let's just comment out our

output and then we can have 66 6059 and

then it prints out in valid which is the

exact same behavior that we saw at the

start so let's remove the extra cord in

here and keep it like this there you go

so now we've got our solution just like

this and it's a lot better because if

triangles were a transform in the future

and we wanted more than three sides then

we can easily update this value because

now that we're using AR raise or we're

using a for Loop to enter out the values

what we can do we don't actually need to

store it what I mean by that is we can

actually just get rid rid of this array

completely let me

demonstrate we can take this angle sum

and place it underneath here we can keep

the count so we can use that in the for

Loop so we're going from 0o to three

because that's our angle count and then

we can get rid of all

this and let's see what we can do now so

we have an angle count equals 3 so we go

from 0 to three which you'll just do as

we said before from 0 to two because

it's less than the angle count and let's

just print this to the screen see what

happens so the output's still exactly

the same but what's happening is these

values are not being stored they're just

being shown to the screen and then not

done anything there is no equal sign

here to assign it into anything so what

we can do is we can say angle sum plus

equals the value straight away and now

if we try it 60 60 60 then we get valid

the main differences between these two

situations is in the first one we used

an array to store all the different

values and then we added the total but

if we're not going to use these values

after then what's the point in storing

them we can just use a for Loop to ask

the user how many times they want to

input the values and then just add them

every single time that they add the

calculation in and at the end we could

just simply use a conditional operator

to be able to print at the screen

whether it's valid or not but let me

just undo that solution so I can show

you the array solution and we can have a

quick recap that was just an extra

little tip just in case you wanted to

know know what different ways you could

use to make this work there we go so

let's just have a quick recap here so we

have a Conant which all we'll do is let

us specify three inside here and then we

can use it here this isn't entirely

necessary but it does clean up your code

a little bit because it gives this

number three a bit of a meaning it says

the amount of angles is our angle count

having a three left over like this is

what we call a magic number they're

quite bad because it hurts the

readability of your code people want to

know what the three actually means so if

you bring in an angle count then you can

actually read we want a set of angles

and this is the amount that we need and

that's denoted by angle count it adds

text to a variable it gives you a way of

making sure that the text equivalent of

a variable is present so someone can

just read it after we've created our

integer we can actually make a for Loop

that goes from zero to the length and

then we ask the user to enter the angle

and in the previous example we had enter

angle one two and three so now we can

mimic that by using I but because I

starts at zero we want to use plus one

every time we loop around the for Loop

we ask the user to enter the number read

it in through console read line convert

it using convert 2 in 32 and then St

into the array after this for Loop is

finished we have all three values stored

in the angles array and then we have an

In Sum to count up all the values that

we need and then we use the fall Loop to

go through every single integer value

inside and make a running to total and

store it inside angle sum once angle sum

has the total count then what we can do

is use console right line along with a

conditional operator to print whether

it's valid or invalid to the

screen in this video we're going to look

at how we can use the built-in array

functions to be able to sort an array so

if you have an INT array called numbers

and then using the previous notation

that we looked at we can actually

specify any numbers that we want using a

common delimited list so if we just have

nine numbers inside here then we've

actually defined an integer array and

then the compiler can count the amount

of items that are inside here and give

it the length but we don't have to worry

about that ourselves so if we use a for

each and we can just print

Inn inside numbers we can do a console

right line on the new local variable

called num if print it out we can see

all of the values and maybe we can

actually just use a console

right followed by a space just to give

them all on the same line there we go so

as you saw before if you had a string

called test and we wanted to do

something to it for example if we wanted

to use the replace function if we wanted

to remove all spaces with an empty

string then if we check the replace tool

tie we can see that it returns a new

string most of the string functions will

return you back the new string after

doing something with it but in this case

if we type in Array followed by do sort

and we can place our array straight in

the bracket

what you realize is if you hover over

sord it will sort the elements in the

entire array but it will indeed return

back a void and vo just means it returns

back nothing so in this case what it's

doing is you're actually affecting the

numbers array straight away and you

don't have to do numbers equals array do

sort numbers for example if we were

doing the test replace we would have to

do this otherwise this would just be

returning back a string but we wouldn't

be using it the same is not true for the

arrays when you run the array functions

they tend to return back void and you

don't have to do anything other than

give it the array that you wanted to

sort so now if you run this code you

should just see the same output since

they already sorted anyway so let's

change some of these numbers

up and just see what happens

now there we go 02 55 6 7 8 999 and

that's it sorted just like that there

isn't a whole lot to this sorting

function but what you should note is you

can use this new array syntax to Define

how many items that you want in there

instead of having to change the amount

of positions that you have using the

square brackets you can just denote any

number of items that you want inside the

compiler will count them for you and PR

the length straight into the bracket for

you so you don't have to worry about it

using the array. sort function all you

have to do is give it the parameter of

the array that you want to sort and it

will affect the array straight away and

you don't have to restore it and then

we're just using a simple 4 each Loop to

print them out to the

screen in this video I want to discuss

the array reverse function so if you had

an INT numbers equal new int and if you

just had lots of numbers in here

defined just up till five then we can

add a semicolon and again using this

array function we can say array. reverse

and pass our array

inside and then we can just use a for H

of our item inside our

numbers and simply just print them out

using a console. write and we can use

string interpolation and just put a

space at the end there we go and if you

run the code then you can see our

numbers have just been reversed there

isn't a lot to this video I just wanted

to show you about the different

functions that you have available for

arrays these can come in handy when you

have something like a list returned from

a database for example and it's ordered

in a certain way let's say you're

returning back a list of lots of people

who are ordered back alphabetically and

it's going from a to zed and let's say

you have some sort of user interface

allows you to flip the order instead of

having to request the database to get

the data back in the opposite order you

can use this array function to just

reverse the list the same thing goes if

you're trying to order by lowest price

or highest price you can use this to

show the different values in different

orders that's where this array function

comes in handy when you have different

situations like the names or the price

by ascending or descending where you can

just flip the data instead of having to

request it back from the database again

flipping it locally is a lot easier than

going back to the database is that uses

more data and more computational power

on the back end and then return it to

the front end it's always best to be

able to use these functions instead of

having to use external things to be able

to return back the same data using it

locally like this will give us a

performance Advantage because it's done

directly on the data instead of having

to request everything again if you

wanted to do this manually let's have a

look and see what your options are you

can have your integer array just defined

like this with a dynamic list and then

we can have a sorted array using the

same length as the current array what

you can do instead of using reverse we

can actually just comment these lines

out you can bring back a normal for Loop

but if we use two RS it gives us a

reverse for Loop so the length is going

to be our numbers do length and the rest

of the paramet is exactly the same we

want to go from the last minus one all

the way till zero and we want to

decrement in one and we can say our

sorted number I is equal to numbers all

right but all this will do right now is

just give us back the same value stored

so what we need to do in a case like

this is make another variable something

like X and we can store that into zero

and what we can say is X is assigned the

value of whatever this numbers is

because this is going backwards but we

want this one to go forwards cuz we want

it to be reversed and we can say x++ and

see what happens when we run it

now so nothing's going to come up

because we don't have any output so

let's use a for

each we can have VAR

number inside our sorted numbers and we

can just take this and place it in here

and just print out the item and we can

use

num and there you go it's been flipped

the exact same value is just the other

way so this is obviously a little bit

more complicated because you have to use

an additional variable use a backwards

for Loop and then incent your own

separate variable and as well as

completely make a whole new array of

course you should only do this if you

need it as two separate arrays if not

you can always just affect the one that

you're up to right

now because I said before that arrays

are actually static data and they're

going to be fixed size then there's no

way to remove or add an item but you can

clear what you have already so let's

have a look array. clear sets a range of

elements in an array to the default

value of each element type so the first

parameter takes our array so let's use

numbers and we want to start off the

index that we want to clear from and

let's say zero and because we want to

clear the entire array let's go all the

way to numbers. length and now let's

just produce a for each our item inside

numbers and then just have a console

right string interpolation which just

prints out the item followed by space

and now let's run the code and see what

happens so we have lots of zeros in the

console and this is to be expected

because as we've talked about before the

default value for an integer is indeed

zero so all this is doing when it says

is it's clearing it's just actually

assigning all of the positions the value

of zero and we can mimic this quite

easily through a for Loop so if we

comment this out and write ourselves as

a for Loop in I equals z and we want to

go to numbers. length and then simply

inside we just want to say numbers

square braet I equals to 0 what you can

also write is the word default this will

pick up the default value for the data

type that you specified you can type in

zero or you can type in default it's up

to you but I think in this case if

you're trying to reset it back to

default then you don't have to worry

about remembering it or any typos you

can just use the keyword default so if

we run this code now let's see what

happens so effectively we've mimicked

what this function is doing but let's

have a look and see what other

parameters we have access to so if we

comment this out and drop the value then

you can still see we only have one

Constructor normally you'd see the open

down arrows on the left hand side to say

one of two in this case we only have

access to one Constructor it will only

give us a range of elements we want to

remove but really we just want to clear

it does say here in the tool tape the

array whose elements need to be cleared

and because it is a clear and not a

remove you got to remember when using

this function it doesn't actually remove

any of the positions it just resets the

values inside the array so what we can

do in this case is we can say numbers

comma 5 comma 5 and what that will do is

the first param arer is where you want

to start so if you want to start at the

fifth position and then we want to count

five forward and because we have 10

numbers then this should return back

okay let's comment out this for Loop so

it doesn't take an effect and let's run

the code and see what happens now so now

we took the position five which is

actually the sixth number because it's

zero base and said we want to remove

five forward so it's s and then four

more forward and there we go we have

five numbers being removed so instead of

removing all of the different values we

can actually clear a certain amount that

we want and to mimic this in a for Loop

we can do the following we can start it

at five and we want to go to 10 and

let's run the code and you can see the

output is exactly the same when doing in

a for Loop you need to actually

calculate what this is going to be so we

need to take both the numbers the fifth

index and the five length which is 5 + 5

and then we get 10 and we don't make

this less than or equal to 10 because we

have 10 numbers so we actually want to

go from position five to position 9

which will equate to less than 10 we

actually want to go from position five

all the way to position 9 which actually

covers five numbers 5 6 7 8 9 even

though it feels like the difference

between the two numbers is only four

because 9 - 5 is 4 but we actually have

five numbers between that 1 2 3 4 5

there we go so when we print the values

from 5 to till less than 10 we're going

from 5 to 9 which is exactly what this

is doing this is the index that you

start at and this is how many numbers

you want to count forward so let's just

have a quick recap of this function we

defined our numbers array using array.

clear it doesn't actually clear the

values it just gives us access to

removing them back to their default

values it doesn't actually clear the

array it just resets the values back to

their default type we can have numbers

parameter which will equal to our array

and we want to say we want to go from

index zero all the way to numbers.

length which will be every single value

inside the array and all that will do is

go through the array and set them all to

their default value which is similar to

what this for Loop is doing and before

we had in I equals 0 and I is less than

numbers. length and that will go through

every single position you can

technically use zero instead of default

but that would mean you have to remember

the default value of every single data

type it's easier to just the default

keyword and it doesn't promote any

typers using the default keyword is by

far the easiest and the most safest

option if you're going to have this

situation so making every number's index

equal to default in this case because

we're using integers it's going to

assign the value of zero and then after

this follow loes run with I is zero and

I is less than numbers. length it's

going to make all of these positions

equal to zero which is in essence what

this function is here for because arrays

can't be added or changed in terms terms

of the values that they have after

they've been created you can only really

modify what's already there or you can

reset them all back to zero using this

notation from zero to numbers length you

can get rid of all the values and make

them all zero using 5 to five means it

will start index 5 which is the sixth

position and then go five numbers

forward so it will delete these and

reset them back to zero you can mimic

this in a follow Loop just like this

start in I at five and then go to less

than 10 and the reason why it's less

than 10 is 5 + 5 gives you the 10th

index but because it's I is less than 10

you actually want to go to the 9th index

because from 5 to 9 that's actually

covering five different numbers and then

we can go through and assign the default

value and then when we print it out

you'll see that all of these numbers

have turned into zeros just like

so searching through arrays are very

helpful when you try to find some data

inside your array and you want to return

back the position to maybe do something

else with it so let's have a look at

this example so we have a numbers array

and let's say we want to search number

199 and find the index of it so first

let's ask the user what the number they

want to search enter number to search

then we can have in search is equal to

convert to in32 and we're converting the

console.

readline and then let's have a look at

the function so inside the array Library

we have an index of surges for the

specified object and Returns the index

of the first occurrence in a

one-dimensional array this is very

important as it says the first

occurrence which means if there was

another 199 at the end it's only going

to return you back this one and then

stop immediately and not give you the

value of this one so let's have a look

in the parameters and see what it takes

it takes our array and then a value so

our array is called numbers and the

value you want to search by is our

variable called search if you hover over

the index function again it says that it

returns back at integer zerob based

index of the first occurrence of the

value in the entire array if it was

found otherwise the value is going to be

minus one so we can say inter position

is equal to this and because it says if

it's going to be found then it's going

to have the value of a zero index and if

it's not going to be found it's going to

have the value of minus1 so we can say

if the position is greater than minus1

because if it's greater than minus1 that

means the value is zero onwards we can

also write this by saying if the

position is greater than or equal to

zero it's just up to you they both mean

the same thing and then we can say in

here number

search has been found at position

position there we go so let's run the

code and let's do a perfect situation so

we can say 50 and you can see it says

number 50 has been found at position

three and that's the fourth index since

it's zero based and what you could do if

you wanted to is actually add one to

this just so it looks like a bit more of

a readable number because four is going

to be the fourth number 1 2 3 4 and

let's try find a number that hasn't came

up like 60 it's going to return us back

with nothing this is really bad because

it looks like the search has failed

which it has but you need to Output a

message to let the user know so have

cons right line and say number search

has not been

found let's type that again 60 number 60

has not been found so let's see what we

can do to be able to write this function

ourselves if we just block comment this

for the time being we can actually use

in

position equals to minus1 and the reason

why I make equal to minus1 because when

we read the tool tip with this index

function it said if it's not going to be

found it's set to minus one so why don't

we set it to minus one first and then we

can try and find it so inti equals z and

we want to go to numbers. length and

inside here we want to scan each of the

positions so we can say numbers square

braet I and if that is equal to our

search then we can set the position

equal to I if the number we're up to is

equal to what the user has typed in then

we want to set our position to the index

we're currently up to and we don't need

to have an else because we've already

set it to minus one and after the for

Loop we can actually take this if

statement and put it back down here

because the code's going to be the same

if the position is greater than minus1

which in this case is our default value

so in essence if this value has changed

then this should always pass EG we've

found the number so let's run the code

and let's type a number in 30 now it's

found at position five now if we try 60

again number 60 has not been found there

we go so this function is exactly doing

some something similar to this it's

going through every single position

finding the variable and if they match

assigning the index and then after just

returning back to position back to the

console so let's comment our example and

let's see what other variants of the

function we can use and let's comment

back the first

one so using this line we can duplicate

it and just comment it so we have some

other parameters inside here if we add a

comma we can actually give it a start

Index this is the starting index of the

search and let's say you only want to

search from this second number onwards

then you can just type in the number two

so now if you've run the code and type

in 90 it's going to say 90 is not found

cuz 90 is the first one and let's try a

value like 50 now it says the number 50

is being found at position 4 because now

it's included in the range from two

onwards because this is two onwards

it'll be position two until the end of

the array if you wanted a very specific

range then you can actually give it

another value so so we can say we want

to go from zero and then we only want to

go two forward so if you run that now

and type in 22 it say is not being found

cuz we' started here and we said 1 2 so

now it's only searching between 90 and

199 and if you wanted to include the

middle ones you could say you want to

start a position one and go two forward

so now you get these two numbers and so

on and so forth so now if we try number

90 you'll see it's not being found

because 90 is not one of these two the

reason why you'd use different ones like

this if I revert back the first

one this will go from two till the end

this will go specific range and this

will go through everything the reason

why these exist is if you have a very

very big array let's say it's a th000

indexes then you don't want to search

everything unless you really need to

let's say for example you had a nam's

array and it was sorted alphabetically

and the person's name that you wanted to

search began with an a there is no point

in running the search all the way from a

to zed if you know it begins with a and

let's say for example you found the

first index of the user that has a name

B so you have now the indexes from the

start of the array up until the last

array position that has the value of

someone's name beginning with a so now

you have the two indexes of every single

a name inside this array if this was a

this was B and this was C and this was D

and you had these two positions then you

should only be searching all of the a

names instead of searching the entire

array and the reason for that is you'll

be searching lots more data for no

apparent reason and it's going to take

an extra long time for searching

something that you're never going to

find if you're searching for a name that

begins with a there is no point in

searching for anything A B C D and so on

and so forth that's where you'd use the

very specific range you can say you want

to go from zero all the way up to the

first B name so then you're only

searching the a names the this is just

one example and there is a lot more

every situation is very unique so use

the parameters that you want and always

use the ones that can get you the best

performance the least amount of things

that you can search is the best way

forward if you don't know what you're

going to be searching then you should

always use the top one which will just

search everything if you know where the

value is going to be or roughly going to

be then you can use this one or this one

to give you a better range and it's a

bit more focused instead of searching

for everything so a quick recap of this

index function what it will do is it

will return you back to position if it's

found it the position will be zero based

just as arrays are if it hasn't found

the position then it's going to return

this variable with minus one so

therefore after you've run the code you

can check if the value is greater than

minus one which will be from zero

onwards if the value position is zero

onwards then you know that that number

has been found and you can use the

position variable to Output that to the

screen if the value position is minus1

it means the array index function has

returned back negative and the value

position is now minus one so you can

output to the user that it has not been

found just in my little explanation down

below you can see that we can mimic this

function by setting the value of

position to minus one using a fall Loop

that goes from zero to numbers length

and if you want to two as well you could

use these inside here if you wanted to

mimic this this goes from two till the

end so you can say I equals 2 and you

still want to go to the length this one

goes from one and then two ahead so you

can actually put I equal 1 and then

because it's two ahead from one instead

of numbers. length it will just be I is

less than 3 because 1 + 2 gives you the

three so in order to do this manually

you can Lube through the elements that

you want check if the number you're up

to based off the index position of I is

equal to the search variable that the

user typed in of here and if you find a

match then you can assign the position

to the value of I after the for Loop is

run you can check the same if statement

as we discussed above these are copy and

pasted down below just to give you an

example in this little

section all these arrays have static

data which means that when you

initialize them with a certain length

you can't increase that length or

decrease the length you can only modify

the data inside it and you can't delete

any rows if you create an array of size

is five and you only stall three people

in then now you have two positions that

are being unused and that's unnecessary

amount of data stored in your memory if

you're not going to be using it up in

certain situations like when you're

making a game for example Tic Tac Toe

then you know you're always going to

need a 3X3 grid so a 2d array will be

perfect in this situation cuz you know

the exact width and height of your array

so you can do this perfectly whereas

lists are quite Dynamic if if you don't

know how many people are going to be

within a system for example if you're

signing up some sort of register for a

class or for a school or something of

the sort and you don't know how many

people are going to be in that class

then you can use something called a list

and list a dynamic cuz what you do when

you initialize it you just say that you

simply want a list and you can add items

and you can remove items and you can

also modify them if you wanted to expand

the size of an array it's slightly

complicated but it's not impossible

so if we had int numbers equals new int

and let's make that length four and

let's say we had a numbers array that we

wanted to increase to length

five we could have new numbers change

that position five and then what we're

going to have to do is from position

zero all the way to three which is our

fourth length from the numbers array

we're going to have to copy that into 0

to three of the new numbers array so now

they have the extra data plus the last

one which will give us our four so

that'll be five length 0 to three gives

us our four numbers and then we have one

empty one so we've just made a new array

and then copied all the data from

numbers into new numbers now of course

this is not really practical that if you

want to reduce the size or increase the

size you're going to have to do this

each time of course you don't want to do

this you just want to use something

called a list so let's stick with an

example and see what we can do so you

make this length

three and let's just put three numbers

inside here if you remember from the

array video we can also declare it like

this we can say number 0al 1 and then 1

and then two and change these values

these two are doing exactly the same

thing I'm initializing it with 1 2 and

three and also just saying that all the

positions in here are equal to 1 2 and

three so we don't need these twice but I

was just showing you as a quick recap so

we're declaring array we're calling it

numbers and we're giving it a length of

three and initializing it to 1 2 and

three now let's see the syntax to define

a list

you start off with a word list and then

you have a left and a right arrow which

makes a little section inside the

section you actually want to State the

data type that you want so if we're

copying the numbers array we can have an

INT inside here and that's it for the

Declaration of the data type and then we

can say new numbers or List numbers

equals to new and then there you go it

gets Auto filled for you but let's just

type it in we have list open the arrow

in in the middle and then close it so

now it's the same same on both sides but

because this is a new we need to add a

Constructor so we can open the curly

braces and the first Constructor says

initialize a new instance of the list

class that is empty and has the default

initial capacity press the down arrow we

can give it a capacity of the number of

elements that the new list can initially

store so we can start it off with five

length or three length or whatever it

doesn't actually matter it just means

that we actually have three positions

available immediately if we place three

in the brackets

and the last one we can actually give it

entire collection so let's say if we

loaded a list of numbers from a database

or a list of something from database and

we can actually insert it straight into

this list by putting a list inside these

brackets of course right now we don't

have a list that we're going to assign

it with so let's just leave this empty

and close the brackets and add a

semicolon so we could say list numbers

do add and then we can add one and then

duplicate this down and add two and add

three so now these do have exactly the

same contents instead of doing this you

can have the same notation like this so

you can have the curly braces in

here and we can put in 1 two and three

now that's doing exactly the same thing

and you see I can just keep adding more

numbers in here and the list simply

doesn't care but as soon as I add one

more into here then I'm going to get a

syntax error because it complains that

the length is not equal to the numbers

that we

have because the list are really Dynamic

it doesn't matter how many you put in

here because it can just go on forever

of course until you run out of memory so

let's have a little working example just

to see how this

works so we can have a for Loop and we

can go from 0 to 10 or maybe 0 to three

just so we don't have to enter as many

values we can have a console right that

kind of just says enter a number and

then let's read that in and we can say

int n equals convert to in32 and we can

place a console do readline inside

here and then after we've got the

console read line we've got an inn

that's being converted from the console

input inside our integer num and from

there we can take our list numbers do

adds and we can add the num inside there

or if you want to reduce a variable you

can just take this line and place it

straight into here now if you get rid of

that when this follow Loop runs we'll

have three iterations let's run the code

and find out 1 2 three so now we've

entered three numbers and now they've

been stored in the list so let's create

a follow loop after and we can go from

zero all the way to list numbers do

length but of course when we're using

list we don't have a length anymore when

we're using arrays we have length

because arrays have a fixed length

whereas lists have a count of the items

inside it so instead of length we simply

use do count and then inside here we

could just do what we normally do and

say list numbers square braet I and

let's run that and we should see the

numbers printed back out in the exam

exact same order 1 2 and 3 and the same

principle goes if you user for each Loop

we can say V item inside list numbers

and that's all you need to do and you

can just print item to the screen now we

should see the same output twice let's

have a look at other values that we have

inside here so we type in list numbers

Dot and let's have a look at the

function inside so we can add which you

just used above we can convert it to an

array we can remove a specific position

and we can clear it completely they have

other ones in here like B researchers we

can check if it contains a certain

element this is going to be very handy

when we do our

remove we can convert them all to a

different type we have a copy to we

check if a value exists

inside we have a find finding all of

them the difference between these two is

the find will return back the first one

whereas find all will retrieve all the

elements that match it finding the index

of a specific match finding the last

index iterating through them all you can

insert a specific position whereas the

add will just insert at the end of the

list adds an object to the end of the

list inserts an element to the list at a

specified index and then you have remove

which gives you the first occurrence so

you can type the number straight into

there so you can ask the user what

number do you want to delete and if they

type zero it will delete the first zero

in the list and you can remove all so if

you want to remove every single zero

inside the list you can do that as well

or you can move at a specific position

this is the most used function because

what you can

do and what you can do is use the find

index search for an element that matches

a condition and then returns to zerob

based index of the first occurrent so if

you want to delete the number zero from

the list you could use find index and

that returns you back with an INT and

then you can use the remove at and then

pass that index straight into there you

can also sort it so it goes up in number

order we did this with the array. sort

function as well and if you wanted to

you can also reverse the entire list

this can be very helpful as we did with

the array functions if you just wanted

to reverse them all in case someone had

something like a filter when you're

doing from Price high to low and low to

high the difference between them two

lists is simply the list flipped so

let's run a remove just inside here and

let's see what happens so we can say

remove that and let's say position

zero so we type in one two and three

you'll see that one two three gets

printed out and then I'll hit this

remove at and it will delete the first

index and in this case the first index

is going to be our number one so now

this has became our first index and this

is our second index and it's got rid of

the number

one so let's move on to different data

structure called dictionaries

dictionaries are generic collections

that store key value pairs in no

particular order they take in a t key

and a t value and these just mean the

key and the value can be any data type

that you want dictionaries come under

the system. collections. generic

namespace and if you don't include this

line at the top then you'll have to type

in system. collections do generic space

dictionary every single time you want to

specify dictionary putting the name

space at the top will include it within

the project and you can use dictionaries

freely so one thing to know is the keys

must be unique and they cannot either be

null values can be null or duplicate cuz

they're the values depending on the key

as long as the keys aren't the same then

the values can be similar so let's have

a look and see what we can do we can

type in dictionary and you can see it

has the arrows either side and you can

see here it says T key and T value and

what T key and T value is is it gives us

the flexibility to add any data types

that we want we can add in two strings

in here for example or we can do

anything that we please so in this

example I just want to start a list of

names and I want to give them a unique

identifier and this unique identifier

will just give them a number that their

profile is up against it's the same way

when whenever you make an account with

any sort of website when your data gets

stored in the database you have a unique

ID for your account and this is the same

thing that I'm trying to replicate here

we have a unique ID and with that unique

ID comes a name so we can say equals new

dictionary just like we do with the list

we can end the brackets and end the

semicolon there and now we've created

our dictionary and the exact same

principle we can use with the list we

can simply type in the name of the

variable of the dictionary and type in

add and then we have access to int key

and string value and this parameter is

going to change if this now becomes a

string as I'll show you

now and if we reopen the bracket you'll

see this has turned into a string key so

that will change depending on the data

types that you specified so let's say we

want to add one and we want to add

ourselves then we can duplicate this

down and add in two and three and we can

say test and test

and now if you run the code you'll see

that we have no errors and nothing's

going to show up I'm just demonstrate

that it compiles okay and the same thing

with the list we can also simplifies the

initialization process and it looks

something like this so because this is

in key value pair we can no longer just

type it in one line they need to be in a

little block so when we wrap these

around the curly brace we can have the

key on the left and the value on the

right and one of these is called a key

value pair key P value pair and we will

use these in the for each Loop in a

second when we print out all the values

to the console so let me just

demonstrate something about what I said

at the start I said that all keys must

be unique and there's a reason why I

said that if we duplicate the first

entry therefore giv us the same key as

one and we try run it and let's see what

happens we get something called a

runtime error this runtime error happens

when we run the program and it's got

nothing to do with compile time or our

logic an item with a same key has

already been added so we need to watch

out if we do this because our program is

going to compile but it's not going to

work at runtime and let me demonstrate

another fact if we make this number four

and our values are exactly the same once

we run this it will still work fine

values can be the same but the keys

cannot be the same the keys have to be

unique so just like with our lists and

our arrays we can use a for each or a

for Loop to access this directly so we

can say 4 in I equal 0 and we're want to

go names do count and the same reason

it's a do count for a dictionary as it

is for a list but it's not for an array

dictionaries don't have fixed length and

neither do lists they are very Dynamic

and basically are a list list can only

store one different data type whereas

dictionaries give you a key and a value

so as we said above we have a key value

pair so let's try and print this and see

what happens have a console right line

and we can say names square bracket I

and that will give us back the position

the issue with this is it will just give

us back the string and let's just see

what happens if we print

this then we get an exception because no

key was given and the problem with this

situation is we can't use this like a

list getso sets the value associated

with a specified key what this means is

when we give our square bracket I inside

here this is actually not talking about

the index this is actually trying to do

a search on these keys so if you

actually Chang this to one then we

should get abber return back this is not

actually doing an index lookup it's

doing a key lookup and the reason for

that is what we're going to have to do

instead is say names. element art and

then what we can do inside there is

place our index so this element art will

return us back with a key value pair as

I said above here so how this variable

works is we can do key value pair and

then we need to specify this variable

the same way we've got it up here so we

have an INT inside a string and then we

can say a pair and make that equal to

the function called element at as that

returns us back with a key value pair in

string and of course if you wanted to

make this a lot smaller you could just

simply use V but let's keep it as key

value pair just so you can understand

what's going on and the reason why we

need to get the key value pair is we

want to retrieve the integer and we want

to retrieve the string and now we can

use pair. key and pair. value and

because these are both integer and this

one is a string it matches our pair

exactly so we can take these values and

go to our console right line and we can

say something like this use string

interpolation and say pair. key and then

maybe add a hyphen and then say pair.

value and then just remove these two

lines and let's try and run it now there

we go so we get all the values and it

doesn't matter what this key is it can

be something random it doesn't really

make a difference like I said this

doesn't have to be in a specific order

so let's keep it as 1 2 3 there we go so

you can see using a for each Loop to

print this is is a little bit more

complicated let's have a look and see

what it takes when you use a for each

Loop for each VAR item inside our

names and as you can see here our item

is automatically a key value pair of int

and string and again what you can do is

type this straight into here just so you

can get used to the notation and there

you go it's still a key value pair and

then now what we can do is we can take

this exact line and paste into here and

instead of pair we have item and this

should return us back the exact same

values and if we just separate with a

console right line there we go okay so

now that we've understood this let's

take a look at an example let's comment

this out and let's create another

dictionary so we can say dictionary and

then we can up a string of

string and we can call this teachers

equals new dictionary string of string

again and we can add our curly brace

just so we can add our value straight to

here so as you said before we need to

open curly brace and close Cur

and then we can say the math teacher is

called abber and then we can add another

one and we say the science teacher is

called test there we go so we've

initialized our teachers and we said

that the value that we want to give it

is a unique identifier which is going to

be our string assigned to the subject

and this is going to be the teacher that

is assigned to the subject so what we

can do inside here is we can have a

console right line and we can do

something like this so remember when I

was saying in the for Loop we can't

actually use the square bracket notation

like this because this is referring to a

key rather than a position so we had to

use element at just to find out the key

value pair and then to print out to the

console so because the square brackets

is an actual surge let's try and make

use of that now so we know that there's

a math class available so we can type

math in here and what that should return

us back is abber there we go so what

that's doing is it's searching through

our dictionary finding this element

inside here and then return us back with

the value for that key gets all sets the

value associated with the specified key

the problem with using this approach is

it says here if the specified key is not

found a operation throws a key not found

exception let's just say for instance I

mistyped the math and now we're just

going to get a runtime error and it's

going to be a horrible exception and our

code is obviously going to break this is

similar to what we do when we have in.

trass we don't just trass it immediately

and convert it without actually checking

if it's a valid value so instead of

doing this line what we can do is we can

check if that key exists first before we

then use it so we can say if

teachers do try and get the value which

is similar to what we have with triy

pass and then the first parameter is the

key that we want which is going to be

our math and then out here is going to

be the variable that we want to Output

out so we can say out

teacher and then open the curly braces

and then inside here we can print out

the teacher so we try to get the value

for Math and if we found that key inside

these then we return back the value

inside our teacher the same way works

for our trip pass you take in a string

in here and the output is going to be an

integer if it's successfully passed it

and if it hasn't we can say cons output

math teacher not found so let's try and

run that now you see we get return back

Abba and if you actually drop the lower

case then it says the math teacher is

not

found alternatively what we can do

inside here let's assume that this is

correct we can take this value and place

it straight inside the square brackets

and do this again this is kind of

redundant because we've told it to get

the value for key place inside teacher

and then we're just going back to the

dictionary to get the value twice so

make sure if you have an output variable

that you actually use it inside here you

can see that you're not using it when it

goes a slightly dark color like this so

just like in the last examples when we

were placing values inside our list we

can also do that in dictionaries

we can say teachers square bracket math

and then we can make that equal to

something so if the math teacher were to

change and now the teachers called Joe

then we can run this line and print out

to the screen let's just take that for

each Loop and tailor it to the new

dictionary and see what happens when we

run it so let's just change this into a

VAR to make it simple and then we can

have teachers inside here there we go so

now let's just run this and you see now

it says abber is the first value that

abber is coming from console right line

here that says teacher this is one line

before we change it and we change the

value of the math teacher to Joe on the

next line and there we go it's committed

the change and just like in the last

video as well when we try to delete

something from the list let's see what

we can do to delete it from here so we

can have teachers do remove and you can

see that it says key in there and again

if we add the key in like this then it's

going to work just fine there you go we

just have science we don't have math

anymore but if I drop the lowercase then

it's going to cause us back with an

error but in this case instead of it

throwing an exception like it did when

we were trying to do up here and up here

as well the problem with using the

remove is you just simply won't remove

it but what it will do is it'll give you

back a booing if you remember from the

last video we actually had a look at a

section where in the list it gave you

back a booing whether the remove

function worked or not alternatively

what you could do instead of using the

remove function is to check if the item

exists in the first place we can say

contains key and we can Place math

inside here and if it does contain it

then we can run the same line of code

and we can say remove and then use math

just to make sure that this has been

actually removed and then in the else we

can say math not found retrieving values

back should be retrieve using try get

just so you don't cause an exception if

this is not found we can simply do an

update by placing the value of the key

inside the square brackets and then

simply just assigning it to something

else this assignment will change the

value of the key which is inside the

teacher dictionary and if you wanted to

remove something it's best to use the

contains key just to check if it

contains it first and then you can do

the remove and then if it doesn't

contain it you can tell the user that

math has not been found and then finally

we can just print out like

this so in this exercise I want you to

create two lists with the integer data

type one for even and one for odd and

then we're going to Loop through from

zero all the way till 20 and if the

number is even add it to the even and if

the number is odd add it to the odd list

and at the end print out all the values

for even and for odd I know you can just

print these out inside the for Loop we

don't have to have dedicated lists but

this is just for list practice and I

want to talk about different ways that

we can do this solution so let's start

we can have a list of int and we can say

odd new list int and we don't know the

size so we're just going to leave the

gaps empty and if we duplicate this down

we can simply just change this to even

now the reason why we're doing lists

we're going from 0 to 20 of course this

20 value could be anything it could be a

million it could be 100 but we don't

know and the point is lists have counts

whereas arrays have lengths if we set

the array length to something like a

thousand we know probably be able to

contain all the numbers inside there but

that's going to be a lot of positions

that we don't exactly need because

arrays are not really dynamic because

they're static then it's best to use

list in this case because we don't know

how many numbers are going to be odd or

are going to be even between between

this range if we knew the exact number

of positions that we needed in a given

solution then array would be better

since you don't want it to be dynamic if

it doesn't need to be so let's start can

have a for Loop that goes from 0 to 20

if you want to include the 20 as well we

can just place an equals the best way to

determine if a number is odd or even is

to use the modulus operator so we can

say I percentage 2 equals equal Z and

what this will do is it'll tell us if I

is divisible by two if the value is

equal to zero if you have two modulus 2

then the remainder is going to be zero

if you have three modulus 2 it's going

to be 1 * by two which gets you to two

and then to go from two to three you

actually have one so if you insert an

odd number and do a modulus two you're

going to get a one returned if you do an

odd number and you do modulus 2 then

you're going to get one returned if you

do an even number modulus 2 then you're

going to get zero returned so what we

can do in here is we can say even add

and then we can simply add I and then in

the else we can also simply just do odd

do add and then have I because the

values of the remainder can only be zero

or one we don't need to have an lse if

in here doing this is a little bit

redundant although it's still

technically correct the values can only

ever be zero or one so if you run this

calculation and the value is zero if you

run this calculation and the value is

zero the only other value can possibly

be is one so therefore we don't need to

additional condition so therefore we

don't need this additional condition and

we can simply get rid of it if I modulus

2 is equal to Z then we add the number

to even and else we add it to odd

normally when you have situations like

this we can use the conditional operator

where we have the question mark followed

by the colon but in this case we're

actually doing two different assignments

we're either assigning into the even or

assigning into the odd so there's no

room for the conditional operator so at

this point we should have all the even

and odd values from zero all the way to

20 inside our two lists so then we can

now just print both the lists out so we

can say printing even numbers and then

we can have a for each Loop that goes v

item inside out even and then we can do

a console Right add some instring

interpolation and then we can say item

followed by space then we can print

environment. new line just to give it

some space and we can say printing odd

numbers here we go and then we can just

take this exact for Loop and copy it

down instead of set in even we want to

do in odd and this is exactly the same

since the variable name is exactly the

same let's try run the

code there we go it's got zero all the

way till 20 and you can see it goes up

in twos hence all even numbers and we

also get these going up in twos except

it starts from one and this covers all

of the odd numbers and if we change this

number up to something like 50 then the

list will just grow and they Cod should

still work okay you can see that all of

these numbers are still consistently

even so now that our task is actually

complete let's just have a little recap

so the reason why we're using lists and

we're not using arrays is for this exact

nature if we have 0 to 10 then we can

almost work out how many even numbers

and how many odd numbers we can have we

can manually count we have zero and then

two 4 6 8 and 10 and then for odd we

have 1 3 5 7 and 9 so we know how many

numbers exist within here but what if we

just change that number to 50 then now

we have a lot more odd and a lot more

even it's impractical to type these

numbers in and then to Simply count them

in your head and then make an array

length based on that position that's a

bad solution because not all cases

you're going to have the flexibility of

Simply typing in the numbers like this

and Counting them yourself these numbers

could be something that typed in by a

user or something loaded for something

external like a text file you need to

understand that these values can be

generated from anywhere and if you just

type them in then it provides an

unrealistic expectation of how to write

some programs so what you have to bear

in mind in situations like this is you

simply don't know how many even and how

many odd numbers will be appearing

during this range so you want to use a

list so it's as dynamic as possible we

have two lists in this case one to start

all the odd numbers and one to start all

the even numbers we don't initialize

them with any sort of capacity we just

keep it empty for the exact reason we

don't use an array we Loop through from

zero to anything we don't even have to

loop from zero we can also just start

this at 100 and go all the way till

th000 it really doesn't matter what our

number range is the only thing that

matters is that we having a list that is

going to be dynamic and then we can

calculate whether the number is odd or

even and add it to the right list how

this works is we use I which is the

number we're currently up to and we

calculate the modulus of it to check the

remainder if the remainder is zero then

it must be even as it's divisible by two

and if it's anything else than zero

which you can only ever be one in this

case when using modulus 2 then we add it

to the odd list after this volume is run

now our odd and even lists have all the

values that they should have and we

simply just write these two blocks are

exactly the same just print the even

numbers and print them out print the odd

numbers and simply print them out to the

screen and that's it and if you run the

code it might get a little bit crazy in

here but as you can see these will

actually work if you pick any random

numbers you can see that they're all

divisible by two and the same thing goes

for odd you can see that they're not

divisible at two cuz they're all odd

so in this exercise we're going to cover

a little task I like this call this task

an array of multiples so we want to

Define initialize two integers and num

into length so in the case of this

example we have a number seven and the

length of five so what this will do is

it will essentially give you seven times

table but only the first five numbers 74

21 28 and

35 we take the first number which is num

which will give us the multiples and we

take the second number which is the

length and that gives us the size of the

array so we create the integer array

with the size of length Loop through the

array and insert the loop count times

byome CU this is 1 * 7 2 * 7 and so on

so forth until we reach the length and

we place into the array and then finally

we paint the array just to give us these

values out to the console all right so

let's get started we can have an in norm

and make it equal to 7 and we have it in

length and make that one equal to five

now that we defined initialize the two

integers let's create the int array with

the size length in Array result equals

new int and we want size length after

that we want to create our for Loop now

this is the tricky part if we try go

from zero all the way to result. length

then let's see what happens so we want

to start result I you want to make that

equal to number which is our array of

multiples Times by the value that we're

currently up to now let's print our

array using for each Loop to see the

value so we can say V item inside our

result then we can have a console right

that just prints one of them at a time

so we can say item followed by spits now

let's see what happens when we run

it so we get 0 14 21 28 as you can see

these are the first four numbers so

we're close but we're nearly there

because our array starts at zero and it

goes to the length which in this case is

going to be 0 to less than five which

will cover the positions of 0 to

4 with these positions it's going to do

0 * 7 1 * 7 and then get to 4 * 7 and

not actually get to the fifth because

we're starting from zero so

alternatively what we can do or what you

think you can do is changes to a one and

changes to equal to so now what it's

doing is it's going from one all the way

to five which is still covering the same

amount of positions it's just one index

forward so now if we try to run the code

then we going a runtime exception and

the reason for that is it's trying to

access position number five if we hover

over I we have five and if you hover

over the result we actually have some of

the right values except it's trying to

get to the fifth position and it's not

working the reason why the zeroth index

is actually zero is simply because

that's the same value as the default

value because our for Loop started at in

I it's actually only starting from here

and going down so this calculation is

actually correct but it needs to be back

one we need to start the multiplication

on IAL 0 but our for Loop needs to start

on IAL 1 so we can get all the way

through

so we have two ways of doing this we

could say I minus 1 so even though it

goes from 1 to 5 it's still assigning

into the array using 0 to four so if we

run that we can see that that will give

us the desired result alternatively what

we can actually do instead of doing IUS

one inside here we can define a variable

called counter and make it equal to zero

we can change this to counter and we

don't need to change the multiplication

because that's already going from one to

the length which is 1 to 5 in this case

after the for Loop is run we need to

remember to increment counter so there

we go we have the desired effect another

hack if you're interested if you have

two variables that you want to increment

inside the for Loop you can see that we

already have I ++ in here which will

increment it by one and we want to

increment counter by one as well every

single time it loops around what you can

actually do is remove this and you know

how these are broken up by semicolons

that indicates that the section has

ended the first sections for declaration

the second is for the range and the

third is so you can increment the

variable or decrement it when you trying

to increment two variables inside a for

Loop instead of placing a semicolon here

and type in the next one you can

actually place a comma and do counter

Plus+ what that will tell the fall Loop

is every single time you go through you

want to do a series of these actions and

because we have i++ and counter Plus+

then that's going to work exactly the

same way it just prevents us having

counter Plus+ down here and we can move

move it inside the for Loop just so it

doesn't for us and it looks a lot

cleaner cuz you can clearly see that

every single time we loop around this

for loop we're going to increment these

two variables there we go so let's try

to put some different values in here

maybe make this 10 and we can have 10 on

both to give us the first 10 numbers

there we go from 10 all the way to 100

let's have a little recap so we're

essentially just making an array that

will give us back all the multiples so

it's like a mini times table but the

fact that we're doing it dynamically

using our array is quite important what

you can do if you wanted to is to extend

this program you can ask the user to

type these into the console and then

convert them and use them right now

we're just statically typing them in and

that's not really an issue since the

main focus was doing this for Loop if

you wanted to you could ask the user and

you can type these values in so you

don't have to change them every single

time you compile so now we've got the

number and the length let's make our

interray call result and initialize it

to the length we set up this counter so

we simply didn't have to do I minus one

here so it looks a little bit more

intuitive we start the follow from one

and go to the length so we can access 1

to five and the reason why we want to do

one to five so when we do our

multiplication it doesn't start at zero

these two are going through the exact

same amount of indexes 1 to 5 is five

numbers and 0 to four is also five

numbers so when we do a multiplication

we want to start from one since the Tim

table normally start at one and we go to

the length the reason why we're using

the counter is so we don't have to do

IUS one in here and it breaks up the

logic a little bit and it looks nicer

without our counter we start our counter

at zero and instead of incrementing down

here we use this fancy comma and we can

say we want to increment I and counter

every time the for Loop goes around so

we don't need to include the counter

increment inside the for Loop and this

one line is pretty simple we say result

the index of counter which will start at

zero which is the start of the array

since it's zero base and we say that's

equal to the number and the number is

going to be a fixed number since this is

the multiple and we say number times by

I and in this case it goes from one all

the way to the length so we get

essentially the times table and at the

end we just use a simple for each Loop

that will go through all the items

inside the result array and just print

them out to the screen with a comma

after each other using console. right

just so they're all on one line this is

the start of the function section

functions can also be called method they

are used interchangeably in the

introduction we discussed dry which

means don't repeat yourself and the

whole point of dry is so you don't have

multiple sections of code that do

basically the same thing you want to

wrap it around in a function functions

are used to improve the readability of

your code and the reusability of the

code as well having multiple section

code that are basically exactly the same

can be more prone to errors if you wrap

them around and place in One Singular

function you can make sure that the

error prone and then wherever you use it

it will be error prone as well if you

have to copy and paste and tweak some

code then you're actually exaggerating

the amount of error that could occur and

plus it makes your code look a lot

cleaner and the structure a lot better

since you can name the functions so

let's take a little example we have a

static void main straight into here this

is a function or a method and these are

the parameters for the function The NET

Framework expects every C program to

have a main function with a capital m

and it needs to be a static and avoid

the parameters don't exactly matter we

can also remove them and it won't be a

problem the only thing that matters is

this needs to be called main if we drop

the lower case on it and try and run the

code then we're going to get a build

error program does not contain a static

main method suitable for an entry point

so if you change this back to M and run

it again and then it works fine so

that's one thing to note about The NET

Framework is you need to include the

main function otherwise the program

won't run and it won't even compile so

let's take a look at how we can use this

we can have something like a console

right line and we can say welcome to my

program this is a line that we're

probably only going to use once but

let's say this is welcome in someone's

name welcome abber let's say you had

this in your software in many different

places you don't want to be recalling

this or retyping out this message in

case you type it wrong the fifth time

and you get a error of course this won't

be a syntax or a runtime error it'll

just simply be a logic error because

it's a typo so in order to make sure

this typo never occurs we can actually

make another function so outside of

these cury braces and just still within

the class we want to create a new

function so we want to follow this exact

same approach we can say static then

void and we can call it welcome message

and we don't need to give it any

parameters cuz we're not really going to

give it any values just for now now that

we've made that we have no syntax errors

and we can run it like this except of

course there's no body so let's place

our console right line within here now

if you run the code nothing is going to

happen and the reason for that is the

code will still execute in the main we

haven't called this function inside the

main we've defined it and called it

welcome message and we've gave it the

contents but we haven't actually made

use of it and you can see that when it's

highlighted in a darker color that means

it's not being used as it says here

private member welcome message is unused

so now we can simply type in here

welcome message followed by an Open

Bracket and then a Clos bracket to

denote the parameters that we're going

to give it and of course in this case

there is no parameters and then we close

the brackets and add a semicolon now if

you run the code you can see it says

welcome AB so just to go over some of

these words that we're using static

means that we can access it anywhere and

everywhere what I mean by that is we

don't have the keyword new just before

this we don't need to make a new

instance of the program class in order

to access this so what that means is

when we make future programs we're going

to have some functions inside our class

inside the class you can actually denote

if a function is going to be static or

it's not going to be static you don't

have to specify is it static but this

won't let you call it from here because

it's unaware where this function's

coming from an object reference is

required for the non-static field method

or property because this is static you

need to reference something else from a

static nature all static means is you

don't have to create a new instance of

this thing in order to use it we'll see

different examples in the future where

you have to create an instance in order

to use something so let me just show you

quickly if you have a test and I say

static void

something and we can just print out

nothing to the screen and let's try and

use this so because this class is

outside of the program we have to use

the notation test Dot and then it should

be available within here and the reason

why it's not is because we need to

insert this public word just before it

and public means everything has access

to it and static means you don't need to

create an instance now if I type in the

dot again you can see we can now see

something

and the reason why we can see something

is because this is a static now if I

remove the static word then you see that

we'll get a compile error because it

doesn't know where this is now if you

don't use static you need to do this you

need to say test test equals new test so

you make an instance of the class and

then inside test then we get the

something so that's the difference

between static and not static

essentially it's accessible from

everywhere but if you don't want to be

accessible from everywhere then you can

just simply remove the static word and

the user will have to create a new

instance before they can use it so this

is what it's like without

static and this is what it's like with

static don't worry if you don't

understand this too much this was just a

quick overiew but I have a dedicated

video later on in the course so don't

worry too much about it so now that

we've made a function and we've called

it successfully in the domain and it's

prined out to the

console so when we're declaring function

we want to specify what return type

we're going to have we have a static

void Main in here if you hover over main

it says void which means at the end of

this function it doesn't return anything

hence its void if you have a look at

something like an in. trass when we open

the brackets you can see that it takes

in a string and it takes in an integer

out parameter it also returns us back to

the Boolean so we can have something

like 1 2 3 out int result and then it

doesn't actually complain about anything

but what we can do is also so just store

this in to a bu success and then print

it out to the

screen there we go so it says it was

successfully true if we remove this or

whether we keep it in or not trip pass

function doesn't actually complain but

the main point here is it defines back a

bull that means at the end of this

function it will always return you back

with a bull and it's up to you if you

want to make use of it and you can

alternatively you can place this

straight inside the console right line

and get the value printed straight to

the screen or you could wrap this around

inside an if statement like we've done

in the past Etc and make use of it that

way and have the result being printed

out inside here the point is you have

functions that return something and

functions that don't if you remember

that we had the array. copy for example

you'll see that they have void here

because they just apply a function to

something but they don't actually give

you something back this is the

difference of having something like this

a string test that says hello and then

you can do test. replace and then you

can return you back with the string and

it says here it returns a new string

whereas when we had a string builder for

example and we did string builder.

replace you can see that although it

does say it replaces a new string

Builder you can type anything inside

here and it will still affect the

current string Builder it won't have to

do SB equals s SP replace as you would

need to do here because this returns you

back with a new string and if you wanted

to replace test you would literally have

to say test equals test. replace with

something like a string Builder all the

array functions you don't actually have

to do any of that so you can say array.

empty and it will just return the empty

array and the ones that we used before

things like equals and that will give

you back a Bool because that's

determined whether it's equal or not but

if you're doing functions like sort for

example and doing things like reverse it

just simply applies the data but it

doesn't return you back with anything so

you can literally just call it inside

here put your array in the brackets and

it'll use it happily now depending on

your user case you need to define

whether or not you need to use if return

type or not for now let's just cover

void which means it won't do anything so

let's just Define a function static void

create and print an array open the

brackets close the brackets and we can

have it int numbers make it equal to new

int with length three and let's just

have 0 1 and two inside here as the

initializer let's just do a for each VAR

item inside numbers and then just do a

console right string interpolation and

just have item followed by space and now

that it's dark gray because we haven't

called the function so let's make use of

it at the top of our code and let's run

it now you can see we get 012 printed to

the screen and if we make this into a

five and simply just add more values in

here and then we run the code you'll see

that now it all ofd but because this

doesn't return us back or anything and

we don't actually use the integer array

I outside of these curly braces it's not

actually available up here numbers won't

be accessible inside here because it's

simply not within the scope numbers is

only available within this curly brace

and this curly brace which means when

this function finishes numbers has now

been deleted from memory so you can't

access it after this line void doesn't

do anything it simply just does the

contents of the function and as soon as

it reaches the bottom that's all that

happens you can have another function

defined that can return a value

like I said with in. trass for example

at the end of the function you'll see a

word that says something like this it

will have return and then return back

something followed by a semicolon and

that will dictate that as soon as that

function is done it's going to give you

something back now we're going to cover

that in the next video but for now we're

only going to cover void functions so we

can have something more obvious like a

static void welcome

message and simply just do a console

right line welcome to my program and we

don't need to return anything here

because all this function will do is

simply print out a welcome to the screen

and we can use that just before the

print array so we can say welcome

message Open Bracket close bracket and

then a semicolon and hit F5 to run and

there we go as you can see our main is

really tidy now it gives us function

names that tells us exactly what's going

on we're creating and printing an array

and then welcoming the user to the

console and then having a console read

line at the end there isn't an awful lot

of void functions all you need to know

is that when you create a function you

need to give it a return type it returns

back a certain data type or it simply

just doesn't and depending on what you

want to do and what you want to achieve

with that function really depends on if

you want to return a data type or not in

the case of these since they're just

doing something and then moving on you

don't actually need to return anything

by it with in. tripod you want to make

the function is executed successfully so

when you use int. tripas you can see

that returns back a bull and the bull

determines whether the conversion has

been successful and based on that return

value you can determine the next steps

of your program if all your function

needs to do is provide some sort of

functionality and then quit then that's

fine and avoid is fine but if you need

to provide some functionality and then

also return a value then you'll need to

specify the data type in here which

we'll cover in the next

video so far we've covered aoid

functions but we haven't covered return

types vo functions are where the

function just does something but doesn't

actually return anything hence the name

void let's start with an example if you

have a static void print

introduction might want to just return

back your name after you've printed this

line it's going to print it to the

console and that's all it's going to

do there we go let's say there's a

situation where you actually want to use

this inside your code you can actually

set the console's title by typing in

console. title and type in your name

inside the quotation marks or you can

type in anything inside here if you run

that you'll see Abra is in the title of

the console right now and that looks

pretty cool what you got to realize is

now we have two references to the same

value now at this point we can actually

do something better we can type in

static string name equals abber and then

instead of using abber in here we can

say name and instead of using abber in

here we can also say a name and they're

both using this variable and if you run

the code now you see that the same

output will happen you have abber twice

both in the title and both in the

console output now the problem with this

approach is you're actually making use

of a global variable which we do not

like code in situation like this you

shouldn't need to make a global variable

because there are ways around it so

instead of having this which has a print

introduction and we've got the name used

in there but the name is coming from

here maybe we can use this somewhere

else so let's say we make another

function called Static and instead of

void we want to actually return back a

string so we can say string and then we

can say my

name or something like return name or

anything you want just make sure you

give it a meaningful name so it dictates

what the function is trying to do so

this ISS to return the name and the

reason why there's a red underline is it

says not all called path return a value

since we need to use our keyword return

now that we had some empty codes on the

return it's going to execute fine and

the compile error is gone so obviously

we don't want to just return nothing we

actually want to take this ab and return

in here so let's get rid of our Global

variable and let's see what we're going

to break so we're going to break these

two references to the name variable and

simply inside here we can actually just

call return name name and then here as

well we can call return name and what

this will do is inside here it will

execute this function and then return

the value in here if this is too many

steps for you you can have a string name

equals return name and then simply use

the name inside the brackets these two

lines are doing exactly the same thing

except this is using a variable cuz

we're storing it first and then we're

using it whereas if you place it

straight inside the brackets that's just

going to store it and use it immediately

and there's no additional variable but

don't worry too much if you're going to

do this notation because an extra

variable in this case doesn't really

matter because as soon as this function

is executed the variable used to run

this function gets deleted since it's

inside the scope of these two curly

braces so now if you run the code you'll

see that again we have abber and abber

but now what we've done is actually

control everything throughout here so if

your name were to change or maybe this

changes in a different circumstance

based on the user that's logged in then

you can simply have the same thing now

printed in two different locations in

the title and in the console output and

it's actually coming from one function

so we can have a return name and we can

make a static in now and can say return

H and then we can have simply return 23

and that's our name and our age being

returned I Chang this back to abber and

then instead of the print introduction

maybe we actually want to print a little

bit more than the name and maybe in the

title what we can do is have string

interpolation wrap the return name and

maybe put a high in there and then we

can say return age so if we on the code

now you can see we have abber hyphen 23

so maybe that's the title of our console

but then in the introduction we can use

a bit more than that so we can have int

age equals return age and then in the

console output we can have something

like this hello my name is name and my

age is age and then after we've compiled

that together we can place the output

inside here there we go so we're using

the name and the age inside the console

title and then we have this function

that runs to get us back the name and

the age and then we're using it using

string interpolation of course these

four lines can be all squished into one

you can simply take this dollar sign let

me duplicate this

line you can take this and paste it

straight into here and where you have

name we can have our return name and

where you have age you can have return

age and that will actually rule out all

of these lines and you can wrap it all

into one

there you

go and if age were to change like I said

before you can simply type this number

in change it and you can see in both

cases in the title and in the console

output it has officially changed

functions can be very helpful to reduce

repetition in code let's show you an

example if you had three sections where

you said enter a

number and you had int num one equals

convert to n32 and then we add a

console. readline

and then you had this section and you

wanted to do num

two and you had this section again and

you actually wanted to do num three now

at this point even though these three

are actually identical you want to be

using array in this case so you could

have int numbers equals new in square

braet 3 and then here we could say

numers

zero numbers

one numbers two and then we don't need

the ins cuz it's already been defined

and then we have them like this but

because again all these three sections

are exactly identical we can actually

run a for Loop that goes from numbers do

length and then we can place one of

these straight inside here and then

change this to I and now we've achieved

exactly the same thing but we're not

actually done yet so if you run the code

and we do one 2 3 now we've stored all

three numbers so we have enter a number

and then we have the console read line

and maybe we can actually make these two

lines a little bit shorter so let's make

a function static and because we

essentially want to return an integer we

can say static in read number from

console and then if we take these two

lines place them inside here and because

we need to return back an integer this

is the value that we're going to be

returning so instead of assigning this

position to something we'll actually

just immediately return at this point so

instead of doing this line now and

instead of doing all of this we can

simply make this into one line of code

read number from console so every time

this will execute will jump into here

print out the value enter a number the

user will typee it in it will read it in

convert it to an integer 32 and this

will return back the integer that the

user's typed in and then that will

return it back to the console and

essentially replace this so if the user

is typed in five then it essentially

replace this with five store it loop

around and have to placed in 10 the next

time and then you replace this with 10

essentially and then that gets stored

inside and so on and so forth until all

the positions have been complete let's

test that 1 2 3 and it still works okay

of course I'm not actually printing the

values out to the screen so if you

wanted to see that quickly for each can

have V item inside our numbers and then

do a console right with some string

interpolation item followed by a space

and let's run that one two and three and

there we go we get one two and three of

course you can make these functions and

they can return any bits of data that

you want you can even have something

like an INT array and we can say create

random array and then we can create an

array call numbers make that equal to

new int square bracket 3 and we can

actually give it the values of 0 1 and

two and then just at the end here we can

actually just return numbers and then

just in here we can have an INT array or

we can call that new numbers since we

have numbers above just above here and

then we can make that equal to create

random array and because this returns us

back with an integer array there's no

compile array inside here and we can

have a four each follows the exact same

approach as the one above new numbers

console right line into a console right

and then have item followed by a space

now if we print these both out you can

see that the zero one and two actually

comes from the new one it's just we have

two console rights right next to each

other so there's no new line separating

them so if we just add a console right

line here 1 2 and three and there you go

1 2 and three comes from the three

inputs we just typed in and 0 1 and two

actually come from the function that

we've just created of course if you

don't like this notation then what you

can do is you can make it a lot easier

you don't even need to make a new

variable you can actually just return

the integer just like this so if we

place

this straight inside here actually just

make it on one line just so it looks a

bit neater then there you go we have our

entire function reduced in one line the

goal of functions is to make them do as

little as possible if your function has

two different things it's doing or more

then you should break that out into

another function for example if you had

a function that did two distinct

operations one was a conversion and one

was a calculation then you want to split

out into two the first function should

be the conversion and the second

function should be the calculation and

the reason why they're separate is

because if you want to reuse them as a

pair then you won't be able to reuse

each of the pairs if you wanted to have

a calculation on its own then you can't

do that if both functions do the same

thing for example you could have static

and it just could be something let's

just call it void and it could just be

test for example and if you had the

conversion here and then if you had the

calculation here then you need to split

this up into two different functions you

want have static valed

conversion and static vied calculation

if you wanted to use conversion or

calculation separately you can't because

now it's in this pair together so if you

wanted to use them separately you simply

can't it's best to keep functions on the

RW anywhere just so they have a single

purpose so you can give them a name cuz

as you can see here we can't give this

an appropriate name because it's doing

more than one task this is doing the

conversion this is doing the calculation

and this is doing mult multiple things

this could be doing something if you

have to think too hard about the

function title then you might be doing

too much within each of functions these

are very easy to be able to decide what

they do cuz this one converts and this

one's going to calculate reading number

from console if this was reading the

number from the console and doing

something else then it's going to be a

bit of a problem because now you've got

a bigger name you don't want to be doing

reading number from console and and

something else cuz then your function

name gets also too big and you got

multiple dependencies so the best thing

to do is to call them accordingly and

keep them as short as possible so let's

say we wanted to make a function that

added two values we can have a static

int call it add and then we can return 5

+ 5 now this function is a little bit

redundant although it will actually work

so if we go back to our main and we do a

console right line and actually print

the value of

ADD and we go through our function then

we see we get the value of 10 which is

indeed 5 +

5 but since it's 5 + 5 won't change

range it's always going to be 5 + 5 this

is where parameters will come in which

we'll cover in the next videos

parameters are a way of being able to

give the function value so these two can

be actually changed there's no point in

having an add function if the only

ability you can do is add 5 + 5 cuz you

may as well just return 10 at this point

so I covered a lot in this video and

there's lots of different functions that

do different things of course there is

quite a lot of lines we're up to 87 this

is probably the biggest project that

we've wrote so far and even though this

is not really a project it's just a buns

functions that do little things that are

made for demonstrations so let's have a

recap so first here we're setting the

title as a result of return name and

return age we can actually take this and

develop this further if you want to we

could actually say return name age pair

and if you wanted to collapse that

inside one function then that could be

really easy you could say static string

return name age pair and then you can

have return and literally the exact same

line above you can have return name

followed by a hyphen and then you can

have a return age and then end the line

like that so that just concatenates the

two values that are returned from these

two functions but the point is you keep

them all separate if you were to type in

very statically inside here AB 25 then

obviously like I've talked about above

then you're going to have duplication of

data and of course we're going to use

this name inside something like here and

as you can see this name age pair is

actually not applicable when it comes

back to this format so it's always best

to keep the these two separately so if

you bring it back and we can actually

keep it like this now instead of having

this code we can actually say return

name age pair that will give us the same

value at the top of the code it will

have ABA hyphen

25 so that's that bit in our print

introduction If We Hold control and we

actually press on this function it will

actually jump us right down and then if

we press the back arrow top left we can

go back to it there we go and then click

forward so in this function we can break

down all of the return values into to

string variables we have a string name

equals return name and inage equals

return age then we have a string input

that concatenates them both together

hello my name is name and my age is age

and then we print out to the screen or

if you wanted to we could wrap all four

of these lines straight up into one we

don't need to assign these into

variables although it does help the

readability if you keep them separate

but I prefer to keep it like this since

I'm used to this notation we can place

return name straight into there which

will get rid of our name variable and

the same thing with age which will get

rid of these two variables and of course

we're actually storing the string value

before we printing it so we could just

take all of this and place it straight

instead of here scrolling back to the

top this little section was

demonstrating how we can use integer

arrays to read in all the values from

the console but wrap it around in a

function so before in here you would

have something like a console right line

You' print out the value to the screen

that would say something like a ter

number and then you have on the next

line a convert to in32 and then after

you converted it in 32 you'll actually

start straight to numbers but because

this is going to be the same thing for

inserting all the numbers you can

actually wrap this around in a function

so if we hold control again and go to

this you'll see that them two lines are

very simply placed in here console right

Line enter a new number and then convert

in 32 based on the console read line and

then we simply just returning that back

ready to be stored in the index of the

numbers array and then straight after

that we're just printing out all of

values to make sure it's worked and that

all succeeded fine here I was just

demonstrating that you can have

different return values and it can

literally be anything so as you can see

here if you hover over create random

array it's inside the program class it's

called create random array and it

returns back an integer array so that's

what we're signed into and if we hold

control and click on this again you can

see that all this simply does is returns

us back a three length array with 0 1

and two as the array positions and then

if we scroll back up when we execute

this for each Loop then we're simply

going to get 0 1 and two just like that

since it's a console right and it'll be

on the same line with a space after each

other this demonstration was slightly

theoretical I was saying in one given

situation a function should only do one

task if your function converts and does

a calculation at the same time then

these are actually two different things

you should split them so you use the

conversion in this step and you use the

calculation in this step if you want to

convert something or calculate something

in the future then you can only do it

now because we've separated them whereas

before if you have them both inside here

then you simply can't do one operation

because you've wrapped it around in one

section the same is true when I was

discussing this earlier on if we kept

this name pair as the only way to access

the age in the name then it's going to

mess up when we use it in here and then

we're going to have a duplication of

data but because we separated the name

and we separated the age we can use it

in this function and we can in this

function and it doesn't interrupt

anything this simply Returns the name

this simply Returns the age and these

two functions make use of them if we had

something else underneath there were

another function that depended on the

name of the edge then again we can

simply use them if it was restricted to

this function then it's going to be a

problem using it in this function or any

future

ones and finally just to finish off add

function and all it simply does is

return 5 + 5 and I was saying as of

right now even though return return

returns back a value it's kind of

pointless CU you may as well just return

back 10 since it's doing the same thing

the reason I included this function is

that we can set it up and start planting

the seeds to understand why functions

exist and how to make use of parameters

what a parameter is is it lets you put

things Within These brackets so you can

give this function some data so if you

have an in. trass for example these

things that we place inside the brackets

are actually the parameters so we have a

string s and out in something and that's

how the parameters work on our trip pass

function and just to show you this is

how it's actually wrote It's a Bool and

then it's called

Triassic and I know it's give us an

error because we don't have the control

path if we just use result and assign it

to zero and then return back true you

can see that the compil error is now

gone and as you can see here it says

bull trip pass string s out in result

and if we actually try and use the trip

pass in here and press the bracket you

can see that these parameters are

exactly identical to parameters that

were inside of the tripar coming from

the integer Library so in the future

we're going to study how we can use

parameters to pass data inside our

function but just for now know that this

function is essentially pointless

because it's only going to return back

10 and this function will gain the

functionality it needs when we start

adding parameters this should

essentially be add five + 5 except this

is kind of a pointless function because

we already know the value is going to be

10 but again this is just helping you

understand why parameters are very

essential to

functions we've covered how to create a

VI function and a function that returns

a data type but now we want to create a

function that gives it some sort of data

you may not realize it but all these

functions that you normally use like

console right line you're actually

inserting data consistently into all of

these functions if you hover over

console right line you see his void

console right line and right now there's

Open Bracket and there's a Clos bracket

if we delete this bracket and reopen it

you see there's 19 different ways that

you can call this function and as soon

as you start to type a string you can

see we have a string format and an

object if you need to and if you type in

another string you can see it says

string value this string value is

actually a parameter If We Hold control

and press on right line you can see all

of the different functions right here

this is the most basic version that just

inserts a right line character to the

console and then these are all the

different parameters that you can give

the value of course you can't double

click and view the source code because

this is hidden inside Microsoft's

libraries the values that are placed

inside these parentheses are actually

called the parameters this is known as

functional overloading which we'll cover

later on in the course basically that

means you can have the same name

function but give it different

parameters and you'll see why this is

helpful later on down the line so let's

close this tab in the top right hand

corner and let's bring back out code so

now that we've passed hello into this

function that was actually given this a

string value parameter and that hello is

going to get past straight into the

console right line so then when we run

the code it's going to print into the

console so let's create our own function

with our own parameters so if you take

the function I had last time it was

static int add Open Bracket close

bracket and it simply returned 5 + 5

which we all know is going to be 10 so

if we place add inside these brackets

and we run the code we should get 10

return back there we go so of course

this is a little bit pointless since

it's always going to be adding 5 + 5

there is no way we can change this

without the use of parameters so in here

we can actually just do what we do when

we normally declare a variable we say

the data type int and then the variable

name and then if you want to add

multiple parameters you can simply add a

comma so now we can say int a and int B

and you can see now we've got a syntax

error because it expects us to have both

of these values inside if you hover over

it there is no argument given that

corresponds to the required formal

parameter a and then if we insert a by

having five for example and if we hover

over it it complains about not having B

so we can do comma and then do five

again so just this on its own is not

actually going to do anything we're

actually giving the add function the

values of five and five and place them

inside a and inside B variables these

are now known as local variables and

they only exist in memory between these

two curly braces as soon as the function

is done these are deleted from memory

and you can no longer access in a and in

B you can't just do something like a

inside here and think that this can be

used up here these are in two completely

different Scopes this is one for

function and this is another function

and they're completely separate from

each other when you type in five and

five it goes in order so int a is the

first one so five gets placed into here

and this five gets placed into B so now

that we need to make use of them we can

simply change this to a and change this

one to B now if you run the code we

should still get 10 but now our function

Works a bit better we can give it a set

of data so if you actually just put

zeros instead of here then we should get

a 100 returned perfect so now that we

figured out how to to do this let's have

a look at different ways that we can

make use of this function so let's say

we had a situation where we did console

right enter a

number and we add intn equals convert to

in32 and then you're converting the

console do

readline and let's wrap this inside a

function so before what I was doing is

simply just returning back in int it was

static int read

int and then we took these two lines and

place it straight inside here and remove

the fact that we have an integer and

simply just change this to a return and

what this now will say is let's output

enter a number to the console let the

user type it in inside the console read

line and then read it in convert it to

an integer and then give it back to

whatever calls it so now we can get rid

of this and get rid of this convert and

simply just type in read in inside here

and after that line let's just print it

out to make sure it's worked okay enter

a number 10 press enter and we have 10

again and that's fine except if we want

to use this in another case for example

if you have num one maybe we don't

actually want to enter a number maybe

this time it's going to be enter an

angle or something of this sort so what

we can do if we undo that we can

actually introduce a string message and

what this will do now is actually

specify the message that we put in here

maybe there's a situation where we

always want to enter something so maybe

we can just replace this and put a

string inter polation and wrap this

number around in the curly brace and

replace it to message so then in here we

can say enter a and then we can pass the

string variable which will get placed in

here so if this is a number then we can

type a number and maybe this is

something like an

angle and then here we can type an angle

so we have 10 enter a number and then

there you go it says enter an angle then

we can have 100 and that's working as

well alternatively if you want to

specify the entire message then you can

remove these and keep it like this and

then in both of these situations we can

say enter and number and copy that down

like this and make sure you put the call

on at the end followed by the space

there we go enter a number 10 and an

angle 20 maybe the situation where this

text actually changed and you just want

it to be angle and if you run that again

then you'll see that these are

completely different now one says enter

a number and one says angle but this

gives us a lot of flexibility in what we

pass in if we keep it as enter a and

then let the user decide on what this

section is then you rule out any

opportunity to be able to do that option

if you wanted to to prevent the colon in

the space always being at the end you

can actually just add that in manually

if you bring back the string

interpolation we can say colon followed

by space so you don't have to remember

to always put that in there we go so

that's doing the exact same thing and

we're actually just reducing the amount

of repetition because we have to

remember to put a call on Follow by

space inside here we might just forget

it and then when you leave it like this

then the cord's going to look ugly

because it looks like this and it's all

stuck together so let's make use of

these two functions and let's see if we

can write a really basic calculator we

can say int first num equals read int

and we can say enter first number and

then duplicate that down change first to

second and then change this also to

Second and then inside a console right

line we can actually have the add

function and we can type in first number

and then we can type in second number

and if you don't want to call the

function inside here you can actually

just make another int and we can say int

result equals add and just bring this

line over to here and then in the

console right line you can just print

the

result there we go so we read in both

the values execute the ad function and

then return it back to the user using a

console right line so these are the

other ones and then here they are so if

we do 50 and we do 50 again and you see

that I've messed up because we have

double colums now so although our

calculator did indeed work let's just go

and correct that so we can take these

off now because we added it inside

here 50 and 25 we should get set 75

perfect so now we've made a little basic

calculator by simply making use these

functions and if we just expand this

just to show you what it would have

looked like so we go in from this and we

place our message inside to here and

then we have our convert line just like

this and then if we duplicate that down

we can change this to Second n and then

to second

number and then as for the result we can

say first num plus second

n there we go you can see the code is

drastically longer and it's a bit

meaningless to have duplica code this is

literally the exact same line in both of

these sections except for the fact that

this ISS first and this ISS second and

we're starring in first and we're

starring in second so let's undo that

and get back to our more efficient code

there we go you can see that these three

lines are considerably shorter and

easier to read this is telling us we

want to read an integer here is the

value and we want to return it inside

our first Nome and so on and so forth

let's have a look at another example

where we can make use of this so we can

have a string called name and we can

read this in from the console console.

readline but we need to Output a message

so we can have another console right and

we can say enter your

name and then we can have this twice and

we can do enter your age and then have

an INT

age but of course we don't want to be

using this approach and putting a

console right line inside here with a

convert in32 because although this is

actually technically correct now what

UND doing the point Val function so

let's change this into our readint and

then as for our message well we have the

message right here and again we don't

need the space callon so let's remove

that and then as for the name we can

actually do this differently so this is

actually going to do a string variable

so what we want to do instead of having

read in we can have another function

called read string another string

message parameter and then do exactly

the same thing have a console right and

we can place string interpolation and

place a message inside here followed by

callon space and then we can just simply

return the console. readline there we go

and instead of doing all of this we can

actually just put our read string inside

here and then place our ENT your name

inside here just without the callon

space because we don't need that so now

we reduce this section to two lines as

well so now what we can do is have a

string details and make that equal to a

function that we're going to use now we

can say user details if we want to give

it the name and give it the age and that

will give us back a string that we can

print to the console so we can say

details so let's go ahead and make use

of this function so we can have a static

and it's going to return us back a

string cuz we're placing it inside the

string and then it's going to be user

details and then our name is a string

our age as an INT and then inside here

we just want to concatenate them two

values together so we can say hello my

name is name and my age is age and

because that's returning us back with a

string we can make use of it inside

string details or we can place this

straight inside the console right line

let's leave it as a function call assign

into string details and then print out

to the screen let's just skip over these

sections enter your name abber enter

your age 23 and then there you go hello

my name is abber and my age is

23 so this is how we can make use of

parameters inside our functions so we

can actually give it some sort of data

that's meaningful if you didn't use

parameters then what you're going to

have to face is for example example what

we showed you with this integer if you

don't use parameters then you're going

to have situations like I showed you

before with this integer function it

returns back an integer but it only gave

us the value of 5 + 5 I mean technically

you don't need to return anything you

can actually just keep this aoid and

just wrap this around in console right

line the only issue with this approach

is you don't have any option other than

to print out of the screen what if you

didn't want to print out of the screen

and you simply just wanted to return the

calculation and then store it inside

another variable this doesn't give you

the flexibility of that so we change

this into an INT and instead of

returning it back to the console we just

return back the pure value and then if

the user decides that they want to print

this out to the screen that's fine like

here we've made a decision that we want

to print it out let's just say we had a

variable that said in calculation then

we place that inside but we actually

never wanted to print it maybe we kept

it like this and then use Cal for

something else down below or maybe that

was something like storing inside a

database not everything will be printed

out to the screen for the user to see

the best thing to do is return the

values in their purus form because you

never know what the developer or the

user is going to make use of that data

later on down the line keeping that it's

purus form is the best way possible for

example in this case we're actually

reading back the integer and then print

it out to the screen but in this exact

case which is the best case scenario

that I just showed you we're actually

making use of first n and second n but

first n and second n are never actually

print to the screen it's always just

used for the calculation if we use

console right line to print out first n

and second them then we're not going to

be able to use it inside our calculation

and therefore our very basic calculator

is now being rendered pointless so read

in and add or return back values that we

can use in their purest form and that is

the whole goal of

parameters so now that we've covered

parameters that are always going to be

required let's have a look at another

concept called optional parameters so we

had a static in add and we add int a and

int B for example and then we simply

just returned a plus b like use in the

previous examples if we have an INT

result and we want to call that function

and we give it the value five and five

and then print out to the screen

everything runs okay because we've added

in exactly what we expect let's say we

don't actually have this additional five

of course this doesn't make any sense

cuz we're meant to be adding two numbers

but just hum me for a minute then what

this will do is says there's no argument

given that corresponds to the parameter

B now of course this is a problem

because it's a red underline which means

if we try and run the code we're going

to get an issue let's say you were

creating some sort of system that if you

entered both values it uses both values

but if you only entered one it

automatically set the second value to

something else and we can achieve this

Behavior using optional parameters so an

optional parameter doesn't exactly mean

quite optional it kind of just means

that it's going to be optional but you

can also give it a default value this

will always add two numbers A and B even

if we make a or b optional it's going to

still need two numbers to add in order

for the function to run so in order to

make a parameter optional let's just say

we want to make B optional we can type

in it equals straight after it and

actually give it a value so as you can

see our syntax error is now gone and if

you run the code we should get

55 and the reason why this works is a is

now five if you hover over here we can

see a is five and then the square

bracket around the int B actually

denotes that it's optional and it says

int b equals 50 cuz we have that h here

so it's actually using this as 50 and if

we don't specify the second parameter

then it's practically just doing this

which is completely fine so the reason

why I said it's not quite optional is

because you still need to give it a

value of course in here you can use the

default keyword in the case of an

integer the default value is actually

zero so if you just run that code now

it's going to say 5 + 0 which is just

five so it can be optional but you still

need to give it some sort of value of

course if you're doing a calculator and

you're adding to values if you only

specify the first one then adding zero

to it is simply not going to change it

so zero or default is going to be the

best user case when you're dealing with

default values with integers so another

way you can actually specify this is by

inserting this thing called an attribute

if you remove this equal zero and just

before the end we can type in Open

Bracket close bracket and type in

optional with the capital O and then

you're going to get a red underline if

you hover over it it says we need to

include this extra Library which which

will import it at the top of our code as

you can see here now that this is

available it says indicates that a

parameter is optional and what this will

do by default is it'll give you the

basic value for this number so what I

mean by that is we can type in here just

to show you this b equals and then B and

this will just give you the default

value based on the data type and as we

just said a minute ago that value is

actually going to be zero there you go B

is zero so all it's doing is saying 5 +

0 = 5

so that's another way of doing it or you

could just leave it as I said before you

can say into b equals default or into b

equals 0 it's completely up to you I

prefer using the default keyword so you

don't have to keep remembering which

different data types have the default

values in the inter just case it's zero

but I just like leaving the default and

we can get rid of this line now let's

have a look at different situations

where this will be helpful if you had a

function called print name and we add a

string name in here and then we can

simply just say console right line my

name is and then name this is quite easy

to use so we can say print name and then

Place AB inside the brackets and then

run the code and we get abber printed to

the screen and that's fine let's say if

we had someone else's name in there as

Joe for example then we get Joe to the

screen and let's just say as the

developer you only want to default this

to abber if you don't actually insert

anything so now if you don't insert

anything of course we're going to get a

compile error because we need a

parameter but if we assume what we did

here and just follow the same approach

if we use default then it's going to

give us nothing because the default

value for a string is just empty quotes

which is just nothing but instead of

default we can actually specify value so

we can say if no one types their name

inside the bracket then use

abber there we go so you can have this

optional parameter that defaults to

something and if someone types in jaw or

whatever inside the print name function

then the default optional parameter is

not going to be used since this will be

overridden if you have a parameter

placed inside here so now the ab is

going to get overridden by the jaw

because this is actually the parameter

that's been used in the

function so you've looked at functions

with normal parameters optional

parameters and now let's take a look at

name parameters so let's say you had a

situation where you had string name

abber in age equal 23 and string address

equals one something rad and then you

had a function that would simply print

these details out to the console so

static void print details there string

name inage String

address so you have three console right

lines that just print out a name value

pair just like

this and then when you go to call this

function what you're going to have to do

is specify the name then the age then

the address in that specific order as

per the parameter show if you try and

run the code now we should get the

desired

output perfect let's say for example you

wanted to rearrange the parameters and

put Age first you'll see we have a

compiler error now because age and name

are in the wrong order string name

should be first and int age to be second

we can still achieve this by using

something called name parameters we

don't have to stick to this order if we

tell the compiler which parameter we're

directly talking about so we can say age

callon because our parameter is now

called age as you can see it's been

highlighted and then after the colon

It's the variables that we're talking

about so it just happens to be that age

is the same value as the edge

so maybe we can change to age input and

place input the end of these so then we

can have age equals age input and name

parameter equals the name input and the

address parameter equals the address

input now we can have it like this and

to make it look even better you can

actually add new lines in here just to

break it off like this and this is a

similar pattern that you'll see in

normal production code putting a space

here can separate them out a little bit

and there we go it doesn't matter which

order that we put these in right now we

can even put address first first and

it'll still work okay and if we run it

you should still get exactly the same

output it's just specified in a

different way so let's just have a

little recap to make use of name

parameters you don't need to do anything

to the original function you just write

it exactly the way you're used to doing

you specify the parameters in the order

that you think is sensible and when you

go to call it you can simply just type

in the parameter's name first followed

by callon and then the variable name

that you want to address once you've

done that then you can use name

parameters you can go back to using the

normal function Fun by just getting rid

of the name followed by the colon and

just replacing all of the parameters

using the correct order and the original

variables instead of the new notation

having Name colon followed by name

input so far we've covered functions

with no parameters normal parameters

optional parameters named parameters and

let's look at a concept called out

parameters let's demonstrate a quick

example so we call a function called

test and we pass in a value and let's

just make this work so we can have an

INT Norm equal zero and then we have a

test function so we can say static void

test and we can say in n and inside here

let's make num the value of five now in

this example if we print out num to the

screen what do you think is going to

happen is num going to take the value of

five or is you're going to keep the

value zero I'll give you a second to

think and let's run the

code so let's run it and see what

happens and if you guess five you're

indeed Incorrect and if you guess zero

you are correct correct and the reason

why it's not five is because when you

pass a num inside this parameter it just

becomes a parameter and therefore it

becomes a local variable even though

these two variables are actually called

exactly the same thing you'll see that

when I highlight it it only highlights

this one and doesn't highlight this one

and the same is true for this it

highlights these three references but

not the ones down here the num variable

is only accessible in each other scope

this one is available through here and

here and this one is available through

here and here therefore if we use this

assignment then it's actually doing

nothing if we print out gnome inside

here num equals num and then we print

that we can see that it is assigned the

value five but because it doesn't do

anything at the end of this function

then it simply doesn't get returned back

or anything happens to it so let's see

how we can make this in to five when it

gets printed out here so the options

that we have is we can actually make

this viid an integer and we can say num

equals 5 and then we can return num or

alternatively we could simply just

return five and not do both of these

lines so if we run that now then we

still get zero and the reason why we get

zero is the test function is being

called and it returns back an integer

but we're simply not doing anything with

it so we can say num equals the return

value of this function which will be

five and now if we run it we should see

how five perfect now this is a little

bit cumbersome and let's say you wanted

to return a value and return back

another value at the same time than what

are your options so let me show you a

quick example when you're using int.

trass we have a string s an out int

result and a Bool so what this function

is effectively doing is return you back

a true or false value to dictate whether

or not the conversion has been

successful and it's also returned you an

out in result and what this means is you

can actually specify integer variable

straight inside the brackets so in

essence this function has gave you back

two values it's give you back something

from the integer parameter and it's also

returned back a Boolean variable so

let's convert this to code and see what

the third option is of trying to return

back five over to this so if we just

comment out this line and as you saw in

the trip pass it simply just need to put

the word out just before

here out int num now we don't actually

need to return anything in this specific

example because we want to just change a

num variable using the out parameter but

if we wanted to return something

separate to the num like a boing like

the tri pass did then we have that

option so we can return back true but

just before we return back true as

there's a red underline here it will say

that the out parameter num must be

assigned so we need to give num a

value we give it the value five because

what we're actually doing here even if

we double click on this we'll still get

num being selected here cuz the scope is

still exactly the same now except what's

happening is when this variable gets

returned it actually gets put into the

variable that it was initially called

with so let's fix these compiler errors

first so the reason why it's complaining

is because we need to give it the out

keyword so when we're specifying in Tri

pass our first parameter is a string so

if the user types in 1 2 3 we put in the

first parameter and then we'd say out in

result or something along them lines you

have an out and then you say you want to

make a new integer and you want to call

it result see in our case we don't need

to put int just like in here because

we've already created our num so the

only keyword we need is how to follow by

space and now of course we're trying to

assign this back into an integer which

we don't need anymore because this is a

booing so we can say Bo

success equals test out n so we print

out

Success Print them both the screen now

we should have five and true the true

comes from the return true and the five

comes from num equals 5 so what's

actually happening here is we're

creating our new integer we're passing

it into this function we're also telling

it's going to be an out parameter so

this function can still output things to

our number variable and then when it

gets placed inside here we assign num

equal to five and then just because we

have a bull we have to return true or we

can return false of course we can just

take this out completely take away the

return true and just keep this as

test of course in both scenarios these

aren't actually do anything they're just

completely random values it's just made

for demonstration so bu is returned back

true or false doesn't actually mean

anything I was just demonstrating that

you can have two return values from one

function there we go we get five when we

run it just like this so now I've

completed this little example let's have

a look at how it's used in the real

world so before we continue let's see if

we can rewrite the tripal function in

our code so it's going to be a static

returns back a bu we have a triy pass

our first parameter is a string s and

our second parameter is out into result

and inside there we can just do result

equals to zero and then we can return

back true of course we actually need to

do conversions inside here if you want

this function to work but I'm just

joining you for demonstration purpose if

we uncomment this line out and have a

look at the parameters again you'll see

that now they line up perfectly string s

out in result and it returns back a Bo

which we have exactly the same here

there you go Bo in. trass string s out

in result so that's how this function

has been declared of course they're

doing something inside the body that can

take in the string convert it to an

integer place it inside result and then

return whether or not the function has

been executed successfully so now that

we understand how to make an example and

how to make the trip pass function

ourselves and to give you the

Declaration let's have a look at a real

world example so if we had a list of

string and we had our shopping list that

was used from the examples we can have

list string and let's just create our

own initializer just with coffee and

milk

inside there we go so now that we've

created that we've got our shopping list

if you wanted to find something inside

the shopping list we have the function

index of and what that will do as it

says here searches for the specified

object and Returns the zero based index

of the first occurrence so if we were

search for coffee then we should get

return back zero so let's try and run

this and put it in the console right

line and see what the value is there we

go we get zero since it's the first item

and if we place milk inside here we

should get back one there we go so let's

try and rewrite this function into our

own code so all this will do is loop

around all of the positions until it

finds it and it'll find the first one

and it'll return us back the index so in

this case there's no out parameters but

there is a return value so we can also

include an out parameter and then

instead of assigning the value of minus

one we can actually assign the value of

true or false to dictate whether or not

that we found it so let's write the code

normally in here and then let's wrap it

around in a function so we can say int

index equal minus1 because we want it to

start a value that we know is incorrect

since the lists are from zero onwards

the value is only ever minus one then

that means it's not in the list then we

can then create a for Loop intire equal

Z shopping list do count because we want

to go through every single item inside

the shopping list and inside here we

want to do a lowercase comparison so we

can do if the shopping list square

bracket I do to

lower do equals and then we want to make

that equal to just something that we're

going to type in statically so we can

just say coffee we can make this into a

parameter after but this is just for

demonstration purposes so we have a

bracket and if we found that match then

we can say index equals to I cuz the

index of the position that we want to

find must be up to I cuz that's the one

that we've made a match with and we

don't need an else inside here we don't

need to set an else inside here to make

it equal to minus one because if it

simply doesn't find it then the index

variable won't change its value so it

will always stay minus one if it doesn't

find anything so after the followup is

run let's just print index out to the

screen there we go we have zero and if

we change this over to milk run it again

then we actually have one placed inside

here perfect so now what our function is

doing is giving us the values of the

index if it finds it now if you type in

something else if you just add another

can let's see what happens then we get

minus one and minus one means that it's

incorrect and it hasn't found it and

what we can do inside here we can say if

the index is greater than minus1 then we

can say found or else we can say not

found so let's run the code now and see

if we get a visual representation not

found and if we changes back to milk run

it again then we get found perfect so as

you can see here we're actually checking

if the value is greater than minus one

but it'd be easier if you had a variable

called found and it actually a booing

variable so we can make a boo found and

make that equal to an if statement

condition so we can say something like

index is greater than minus one which is

exactly what we had here a second ago

and because this is a condition it's

either going to return back true or

false and it's going to place the value

inside found and then we're going to use

found inside here this is easier logic

to understand if this is true then it's

found if this is not true then it's not

found true true false false it's quite

really straightforward and very easy and

clear you have an index and you have

whether or not it's been found so let's

try and wrap this around inside a

function so just as the trip pass does

it returns us back with a Bool which in

this case will be our found and it also

gives us back an integer result but in

this case it's going to be our index so

let's see what we can do to write this

so we can have a static we want to

return back the Bo and we can say find

in list we need to give it the item

we're going to find so we're going to

need a string s we need a string s for

the item that we're going to find we

need to give it the list as well and

then finally we need our out in

index there we go so let's comment out

this code here

and let's copy this down into our

function and see what we need to do so

index has the value of minus one we

don't need the integer variable

declaration here because we've already

declared it inside the parameter so

after declaring inside here we give it

the value of minus one minus one

indicates it hasn't been found since the

index are zero based so instead of

shopping list we now just have list and

list here as well and then instead of

having it being equal to milk we

actually want to use our s variable and

to make it better we can convert it to

lower case just so we have lowercase

conversions on both sides of the equals

if we find a match between the list that

we've passed in and the S variable which

is our surge term that we've passed in

then we assign I to the value of index

and then it's still got a red underline

because we haven't returned back

bu so right now we actually want to

return back the found variable so we

have two options here we can return back

found or we can simply take this and

return it back in here we don't need to

run this code to see if it's found or

not and then store it and then return it

after since we're not doing anything

else with it we could just return it

like this this makes the code

considerably shorter because this will

just return back a true or false if the

index is greater than minus1 then it

will turn back true if the index is less

than minus1 then it will turn back false

so let's see how we can use this

function inside our code now so we

wanted to search for milk so let's just

copy and paste this line and let's see

if we get the same output as the

shopping list index of so now our

function is called finding list you have

a bracket and then our string s is going

to be our milk our list is our shopping

list and our out in

index so this is going to return us back

with a booing so we can print that

booing to the screen and then if we just

duplicate that down and we can print

index to the screen and maybe using a

console right line and just place a

space right at the

start so you print out whether it's

successfully converted or not and we get

the value back from

it let's run the code

so we get true plus the value of one so

that means it's found it and it's found

it at one index and the previous line

before it which just run the normal

index of function also return back one

so they're both the same let's just get

rid of that

space so if we change these both to

coffee then hopefully we should see the

same result but with index zero there we

go this zero comes from the index

function this true is from our function

tell us has been successful and this

zero is the index so we can actually

take this and put this straight into an

if

statement so just like we had down here

with the found and not found we can say

if and then this function call and then

we can say found and then the item what

we passed in so in this case it's going

to be coffee found

coffee found coffee at index index and

if it hasn't been found then we can just

print not

found and this is getting an error

because we have two indexes up here so

let's comment out this line and let's

try running

out found coffee index zero and you can

see these two are the same again one

comes from here and one comes from that

index we change these both to milk now

milk milk and milk then run the code and

you see found milk index one if you

wanted to just before you pass in here

you can ask the

user enter an item to

search store it inside string search

equals console.

readline and then instead of passing mil

here we can just pass in Search and then

instead of passing milk in here we can

also use the search variable so now if

we try run it again we can type in milk

and then we go file milk index one and

then coffee found coffee index zero and

just to give this a test let's just try

and find m not

found

perfect so let's have a little recap

based on this function so initially we

try to assign the value of zero and then

print out a normal function and inside

test we just had a simple num equals 5

and what this was doing inside is just

locally assigning it but not actually

return anything and then we said we

could assign it and then return it back

and that was another option of being

able to assign the value to five and

then we use the out parameter which

allowed you to pass in an integer when

you assign in here it will pass it back

into the original call and place it in

this variable here so when we print out

on the next line it says it's equal to

five we wrote our own little shopping

list for the list of strings and then we

called the shopping list function index

of and then we actually created our own

index of function and made it into a

function so just a little recap what's

going on here we have a string s which

is our search term the list full of the

items in the index that we're going to

pass back to the user as well as

returning back a bu to indicate whether

we found it or not we set the index to

minus one so then that completes our

logic at the bottom minus one means it

hasn't been found found since the list

is all zero based if this value is

greater than minus1 then that means that

we found it inside the list since the

list is zero based and if it's not that

and this returns back false then we

mustn't have found it because this line

would have executed so we Loop through

the list we do a lowercase comparison on

both sides of the equation on the list

item and on the surge term if they both

match we run the index and store the I

variable inside the index and then we

return whether index is greater than

minus one so after we return this back

from the end of the function we can see

once we run it inside the console right

Line This is just going to return us

back with a true or false value as well

as creating our new integer variable

called index so on the next line we can

use index and print out of the screen

this line should return true or false

since it's a Boolean return and this

variable will either give us minus one

or something above minus one but in this

case when we actually make use of the

function we can ask a user to enter

something get them to type it in and

pass that into the function but more

importantly when this function returns

if it's true we output it's been found

and if it's false we output not found

and we only make use of this integer

variable should this return back true

there is no point in printing minus one

to this screen because that's what

you're going to get if it's not

found it's going to look something like

this which is kind of redundant because

the user doesn't care about this so we

don't need to include it when we're

printing not found but we should include

it when we're printing out the found of

course this is just a random example Le

and you might not need to print it out

to the screen or you might just do

something else inside here you might be

searching for something and then you

might want to edit it or do something

else with it and then you can make use

of that index if you wanted to ask the

user to search for an item and then tell

them what they want to replace it with

then you can also do that just as we've

covered in the last

examples so after we've covered out

parameters and normal parameters let's

have a look at a concept called passing

by reference so we created inome equals

10 and then let's call it assign and we

passed it straight into here and we can

have a static void assign in

N if we say n equals 20 if we use a

console right line up here then num is

still going to be 10 because we're not

returning it and we're not really

affecting it now other ways we can do

this is by changing this into an INT and

then we can say return 20 and then we

don't really need this anymore so we

could just say

num num equals a sign and then we'll get

20 assign back in there we go all we can

actually make this an out into num and

then we can say num equals to

20 and then inside here we can say out

num we don't need to return back in

anymore so we can make this valued and

you see the value 20 so there are

different ways that we can assign a

variable straight from here so let's

have a look at another method so instead

of having out we can actually use a new

keyw called ref and the reason why it's

ref it means it's passing it by

reference so when you pass a value in

through a parameter normally you're

actually passing by value and what that

means is you're copying this value that

gets passed inside the brackets into

here and it's making a whole new

variable what I mean by that is this

might have memory dress location one and

then when this variable gets created it

has memory dress location 2 for example

and then it's used within here and then

two is now deleted because you've got

rid of the variable because of this

function but one is still alive since in

the main function when you pass by

reference what you're doing is you're

saying give me the memory address

location of the variable inside the

brackets and give it into this function

rather than copying the value so if this

has memory just location one and you

pass it into here then it's also going

to have one so what this actually means

is if we put this ref keyword just

before the int just like we do with the

out and we can place it here as well

we're now saying we want to pass this by

reference so when this 10 gets pass in

here we actually have a link if you will

to this gome is now linked to this gome

which means if we simply do nor equals

20 and run the code then we're going to

see 20 the main differences between

reference and using the out keyword is

when you're using out within a function

you actually need to make use of the

value if I don't include anything within

here then I'm going to get exception and

it says the out parameter num must be

assigned so when using the out keyword

num has to be assigned when using the

ref keyword you don't have to make any

assignment because we're just passing a

reference in with the out keyword word

you literally tell the function I want

to Output this value but if you haven't

gave it a value to Output then of course

it's going to be an error so we can

assign in the reference if we really

want to but you don't have to and it's

not required so there are the two main

differences between passing by reference

and passing by value and also using the

out parameter passing by reference is

technically quicker because of

efficiency when you don't pass it by

reference you pass it by value which

means it'll essentially place that 10

inside these

brackets instead of passing the variable

in it actually just passes the value and

then it makes a whole new variable down

here when you pass it in by reference

you're essentially actually giving it a

link to this memory address location

from inside this function which means

that you don't actually have another

local variable inside here because this

one is affecting this one directly you

can do this with any amount of

references you want by simply just

chaining them and adding another one in

like that for example and then we can

have a string name and then we can pass

our ref name inside here and inside here

we can say name equals hour and this

doesn't like it if it's unassigned so we

just give it empty quotes or we can sign

it another name it doesn't really matter

it's just a demonstration and if you run

that but let's just print out the name

as well to the

screen there we go we get abber assigned

into

there and same thing with this variable

is we're actually just passing in the

variable as a reference rather than as a

value it doesn't matter what the value

is going to be B cuz it's just given

this variable inside this function so

we're actually saying name equals we

basically just assign it back into the

original variable so let's just have a

look at another example so we can have

some sort of like change name function

and we can give it the name variable as

a reference and then we can give it the

new name that we're going to pass in in

a second so if we make a new function

static void change name you're going to

need a ref string name and a string new

name and we can simply say in here name

equals new

name perfect

so let's give this a shot so if we just

comment out this little section and we

can say console right enter your new

name then we have a string new name

equals console.

readline and then just up here as we've

done before we could just declare the

name as being Joe and then we enter the

new name call this function and then

after we can say your new name is and

then we can pass in name perfect let's

run

that so at this point the name name is

actually Joe cuz we've made it appear

and then we'll enter a new name so we

can type in abber now it says your new

name is abber perfect so all this

function is doing I know it's pretty

pointless right now cuz it's just doing

one line but all it's doing is assigning

the reference to the variable that we

pass in so what we can do now is make

sure that we can actually assign this

variable in and we can also pass in a

Boolean variable so what we should do

now is actually make sure that we can do

the assignment properly cuz you don't

want to assign it if the value is empty

and then return back a Bo Lan type just

to indicate whether or not it's being

assigned so what we can do in here is

just on the change name we can wrap this

around an if statement and if this

returns back true then your name has

been changed and if not we can say

console right Line new name cannot be

empty or

no in order to be able to do this check

as we've used before we could say if new

name and then just around that we can

say string do is n or empty and wrap

that inside the brackets and we want to

say if it's not and the L empty then we

want to do our

assignment after we've done our

assignment we can return back true

inside here and then just outside we can

return back false notice how in this

little bit of code we actually don't

have an else we don't need to write else

inside here and place return false

inside here because if this returns back

true then it's going to execute this one

line return back true and since it's a

return it's going to jump to the end of

the function so we don't need the else

in there because the only way that this

line will ever execute is if we actually

had this function returning back false

so if this returns back true it's going

to hit this line hit the return jump to

the end if this returns back false it's

going to skip over the if statement and

then just return back false to the user

perfect so now we've got no compile

errors let's give it a run so if we want

to change your name to nothing if we

just press enter then we can see it says

new name cannot be empty or no and if we

type something in then we get our name

changed so just to round up this video

let's talk about the main differences

between the ref parameter and the out

parameter when you sign in by reference

you actually have to make the variable

before you pass it in for example you

can't just write ref string in here and

that actually works whereas you can't

actually do that with the in let me

demonstrate so if you had the in. trass

and that has an out parameter you can

actually type out int index inside here

you don't actually have to make the int

index inside here and then specify it

outside you could just initialize and

declare the variable straight inside the

brackets whereas because you're passing

a reference with the string you actually

need to make the string first and then

pass it in so that's a big difference

between the out and the ref when you

make news of the actually inside the

function if you're using a reference

then you never have to assign it or at

least it's not required you could have a

series of if statements inside this body

and then you might determine that you

might not need to assign it which is

exactly what we've got here the only way

we assign name is if this returns back

true if it doesn't return back true then

we simply don't assign it and move to

here this is a problem if the out

variable if we change this to an out

then we're going to get a compiler error

because it doesn't return back a value

so we'd have to write something like

this at the top name equals something

and then potentially sign it here and

then return back false so with reference

you don't have to worry about the fact

that you might not assign in every

single path of your code and finally the

main difference is the fact that out

parameters are still used by value and

this is by reference reference will be

slightly quicker since you'll get the

memory just location being passed in

instead of the Val we won't have two

copies of the same

variable the focus of this task is to

create a function that calculates the

area of a triangle so we're going to ask

the user for width and height install

them both create a function to calculate

the area the function is going to

calculate it using width times by height

taking that calculation and dividing the

value by two call it in the main and

print out the area of the triangle to

the screen so let's start with entering

the width and the height so we can say

enter width colon

and have int width equals convert to

in32 console.

readline and if you copy these

down change width to height and change

WID here to height and just before we

continue because we did copy and paste

down then this is quite bad and we

should use a function here so in both of

the cases we're going to output

something to the console and then read

it in and convert it back as an integer

so we can say static int because we

return back an integer so we can store

it we can say read int and we want a

string message so we can pass in this

value inside

here so we take these two lines and

place inside here instead of enter

height we're now going to have message

instead of int height we're just going

to have a return value and then we'll

return in the conversion from the

console read line and now we can use it

inside here read in inside the brackets

you want to put the string output which

is going to be enter height if we paste

that inside here and then do the same

thing for the previous section and and

change height to width and now get rid

of these so we just have these two lines

perfect so let's just print these out to

the screen on separate lines just to

make sure it's

working so the width of 10 and height of

15 we get 10 and 15 Perfect Since that's

working okay we can now create a

function that can calculate the area for

us so we can get static int calc area

and we can have int width and int

height and then taking this formula we

can simply just do return bracket width

times by height / two as you can see

this is literally exactly the same as

what we've got here it's crucial to

include the brackets because we want to

do this calculation first take the value

of that and divide it by two if this is

too many steps you can actually break it

down we can say int calculation is equal

to the width times by the height and

then we can simply return calculation /

two back to the function it's slightly

gred out because we haven't used use it

but that's not a problem we're going to

use it now I personally just to prefer

is to keep that inside here and just

have the brackets since a bit more

obvious to me what's going on but it's

up to you as the programmer either way

it makes no difference it's just more

for the programmer's convenience so now

we need to call the function above so we

can say int result equals calc area and

then pass in the width and pass in the

height and then we can have console

right line that just says the area is

and then result and then let's run it

you have 10 and 15 and there we go we

get the area area is

75 perfect if you didn't want to call

the function inside here and stall it

inside a variable you could just output

this straight to the screen by placing

the function call straight in the cly

braces and if you run that again just to

make sure 105 and we get 75 again

perfect so just a quick little recap we

have the console right plus the convert

inside this function which will let us

return as back an integer and we can

pass in the message straight in the

variable to make this a little bit

quicker and a bit easier you can

actually just change this one word

inside here so you could actually say

enter message call on space and then

just inside here you can say height and

just inside this one you can say width

just to reduce on code because in this

specific case the only thing that

changes between them two string

variables was the fact that one was

width and one's

height there we go you can see it's

exactly the same now so after we've read

in these two variables we pass it into

the function and all the function will

do is take width and height times them

both together take that value and divide

it by two and return it back to the user

and then we can call it straight in here

the area is calc area and pass in width

and

height in this task we're going to

create a function that will return us

back with the sum of numbers inside an

integer array so first step is to create

an initialize an array of numbers create

the function with the int return type

and it also takes a int array as a

parameter the function should return a

total of all the numbers inside the

interray call it in the main output the

total and just for extra bonus points

inside the function instead of using a

for Loop immediately you can check if

the array length is greater than zero

and then return minus one if it's empty

and then check that inside the main and

then output a specific message and also

see if you can think of any other

implementations you can use instead of

having to do return minus one how else

can you make this function whether that

means you have to change the parameters

or return type or anything like that

just have a think about the situation

and see what other options you can make

of course the output at the end is still

going to be the same but it's the way

you do it and the problem solving skills

that I'm trying to get you to get used

to let's get started so the create

initialize an array of numbers so you

have int numbers equals new int and

let's just allocate them manually 1 2 3

4 5 and add a semicolon there we go now

let's create the function sum of

numbers and we want it to return an

integer back with the total and we want

to take an interray called

numbers and then inside here we need to

actually return back an INT so we can

create an in total make that equal to Z

and at the end we can return total and

then during the middle we're going to

have to write our for Loop so we can go

through the integer array and count

through everything so we can use a for

each V item inside our numbers and just

inside here we can say total plus equals

item perfect so if we can call it in

here we can have a console right line

and we can just say sum of numbers and

pass our numbers array in the parameters

so we're just going to Output it to the

screen just for the time

being so sum of values from zero all the

way till 5 is 15

perfect so now that we've done that

we've created a function that Returns

the total numbers call it in the main

I'll put the total so we can just say

the

total the total is and then wrap this

around in the C

brace there we go the total is

15 now with the extra points we can

check the array length and return minus

one if the array is empty so let's see

what we can do in here before we even

end up going inside anything to do with

the total we can wrap this around in if

statement that says if the numbers do

length is greater than zero then we can

proceed with this little section so if

we highlight all of this hold alt and

press upar key then because it's one

back just press tab once and just press

the delete key here and let's get rid of

the empty Line This is going to return

us back with an error because not all

code path to return a value if this

returns back true then we'll eventually

hit a return but if this returns back

false then we not do anything inside

here so let's have a look at our

requirements return minus one if the

array is empty this dictates whether the

ray is empty so if this returns back

false then it's going to come into here

and we can say return minus one so we've

got this function call in here we don't

want to print the total right now

because we want to make sure that this

total is actually greater than zero

because we don't want to make a sum of

the numbers if the array is empty so if

you run this right now going to get the

total is 15 and if we get rid of all

these variables and just have the length

of five but not give it any value so all

the values are going to be zero then if

we still run that then the total is

going to be zero but that's still an

acceptable value because that's actually

got values

inside but if you said the array length

is zero then the total is minus one of

course we don't want the user to see

minus one so we want to bring this back

and instead of calling the function

immediately down here let's call it here

we can say int result is equal to this

and then we can say if the result is

greater than minus one then we can

output the total and again press into

this line hold alt and press Arrow key

and then we can place the result inside

here and the L's to this will be canot

add up an empty array there we go so now

if you run it we should still see 15 but

if we get rid of this and put it back to

zero there we go we cannot add an empty

array so we bring that back perfect so

now if we check this we've got check in

the main output the message and then now

we've got this little solution do we

need to return minus one how else can we

make this so right now we're going to

have to return back minus one cuz that's

the only way that we can tell the user

whether or not it's been successful if

the r is empty we return minus one and

if the ray is not empty then we return

something greater than minus one which

will be something above zero or zero

itself but as long as it's greater than

minus one that's how we know it's

complete but we don't actually want to

do this we want to be ideally returning

back a Boolean so let's duplicate this

function and show you both

implementations let's change this into a

Bo

and then because we're still going to

need to reference the total we're going

to have an out in total so we need to

change up a few things inside here

instead of this return minus one we can

do return false to indicate that it

hasn't been successful instead of

returning back total we can actually

just return back true now we haven't

done everything yet we don't need to

redeclare in total inside here because

we already declared it inside here so we

could just initialize total to equal to

zero but the problem here is if we make

total equal to zero just within this

path

then it's still going to complain that

total must be assigned so we can take

this and just assign it right at the

start of the function just like that

there we go so we make total equal to

zero that gets rid of the compil errors

and gives it a value the reason why we

have to give it a value is because this

out in parameter doesn't like it if you

don't assign the value that is a

requirement for using the out parameter

so we make total equal to zero check the

numbers length If This Were to return

back false then we return false to

indicate that we can't do anything if it

this returns back true it will go

through and count all of the items place

inside total and then return back true

so let's have a look and see what else

we can write this little section of code

so instead of having to call inside here

and use it within there then we can

actually do this another way the reason

why we actually calling this straight

inside here is because we can't place

this straight into here since it returns

us back with an integer and now that is

actually fine if that returns back of

the integer cuz as you can see there's

no problems here the issue arises is

when we have our result variable we can

use it inside the bracket and down here

there's no point in calling this twice

to get the same value although this

would still technically work but this is

not really efficient since you're

calling the function twice it's best to

call it

once store the value and then make use

of it twice when we use our out

parameter you'll see that this gets a

bit easier so straight inside the if

statement we can say sum of numbers and

then we can pass in our numbers and then

space out into total and what that'll do

now is because this returns us back with

the fol we don't need any additional

conditions like we have one here cuz

this will turn us back with a true or

false true if it succeeds false if it

doesn't so we don't need to say if it's

greater than minus one because we don't

actually care about the value of the

total right now we just care if this

returns back with true or false so

inside here we can take this same output

message and instead of having result

here we can have

total and then we can take this exact L

statement and place it here and let's

see what happens now the total is 15 and

the total is 15 so they both turning

back the same values let's add something

else on here just to make sure it works

there we go so you can see that both

these Solutions look very identical but

one is considerably different we have to

make a variable outside use inside here

and use inside here whereas in this

function we can actually just call the

function straight inside that will

process our new out into total and then

we can simply use total inside here and

we don't have to require another

additional variable just outside here as

this one will and you can see that the

functions is a little bit better because

we're returning true and returning false

to indicate whether or not it's been

successful whereas in this solution we

have to return back an arbitrary value

and then check that in the console the

reason with returning minus one is kind

of a problem is what if these numbers

are actually all negative then this

value is going to be very bad this can

only really work if all of these values

are positive if you had negatives for

all of these and we tried running the

code there you go this is a major issue

cannot add up an empty array well it's

not the fact that it is empty it's the

fact that these values are smaller than

minus one so you don't actually want to

be going with something like this

approach where you're comparing the

value because you don't know what

numbers are going to be typed into here

if the user were type in positive or

negative you want to provide a solution

just like this one that works for either

positive or negative you don't want to

restrict that by checking if it's

greater than minus one will only works

if all of these are positive values all

this is an index for the array since

arrays start at zero and go upwards you

can't have a negative -1 array position

but in terms of numbers that are

randomly typed inside of a ray you

should always be wary of using this

option because if some of them are

negative then this could return back

false so let's just have a quick recap

so we have an integer array we have our

values initialized down here and then

the first solution we call the function

passing the numbers array get our result

back check if it's greater than minus

one then that means it's been successful

so we print it out and else we tell it

it's an empty array now second option we

actually call the function because it

returns back a boly in this case so we

can place it straight inside the if

statement and then we can pass in the

numbers AR and then we have an out in

total which will give us the total and

in this case we don't need to check the

value because this returns us back with

the true or false and in this case true

determines whether it's been successful

and false it doesn't if it returns back

true then it has some values inside the

numbers array that we can actually add

up and if it returns back false then

that means the array is empty so let's

have a look at the implementations so

without the out parameters this is the

first solution up here we get the

numbers length check if it's greater

than zero if it's not we return minus

one make a new variable called total

make equal to zero and we run a for each

Loop V item inside the numbers and we

just say total plus equals item add them

all up in the for Loop and simply return

the total and then in the out solution

we have a total equals zero which just

initializes this variable otherwise

we'll get a compiler then we can say if

the numbers is greater than zero then we

can say if numbers. length is greater

than zero then we can do the for Loop

and return back true and if it turn back

false then we can say false inside here

and then when we use it straight in the

brackets we have access to it straight

away since it uses a Boolean variable

and then our value will be placed inside

our out into total parameter which is

used down here for the output to the

screen and again if this returns back

false then it will say I cannot add up

an empty rray and then we hit the

console read line and we at the the end

there we go that covers everything

inside

here exceptions are used to prevent your

code from crashing and then the program

closes down let's have a look at a very

very common example let's have a console

right and we can say enter a number and

then we can use int Norm equals convert

to int32 and then we can have a console.

readline inside here and let's just

print out number to the screen now if we

assume everything goes well and we

actually enter an integer like 15 and we

press enter then we simply get 15

returned and as we saw in the past when

we covered the trip pass function if you

enter anything else that's not exactly a

number then you get again exception

exception unhandled unhandled means that

we haven't wrote anything specific that

will handle this exception so it's

causing the program to close it's a

system. format exception it says the

input string was not in a correct format

so this is a format exception because

we've entered in a very weird set of

characters that can't be converted over

to an integer so now our program is

forced to crash and now rest of our code

is going to be deleted now because it

won't be able to run so if you had any

important data that was stored just

before this point then it is now lost

this is very crucial because if you have

a system that rides to a database or it

stores some very important information

that someone's typed in you want to

handle the exceptions so if something

were to arise it doesn't actually close

the program down and they lose all of

their data I'm sure you've had it in the

past where you've tried to do something

and the program comes up Windows and it

says this program had to stop responding

when that normally comes up it means

that Something's Happened that's so

fatal that the program cannot continue

it has to crash down and in most cases

this is what's called an exception so if

we run this code again let's have a look

and see what else we can do to make this

code break so of course as you heard

before a gnome integer can only survive

up to about 2 billion numbers so if you

enter a number bigger than that let's

see what happens then we get an overflow

exception value is either too large or

too small for an in3 too of course this

number is very big and only a long would

handle something like this an integer

definitely won't so these are the kind

of exceptions where you'd have to handle

it yourself manually otherwise your

program's going to crash coming up next

we're going to go through the ways that

we can handle these and make sure

programs don't come to a halt exactly

like these

examples I want to explore a technique

called trycatch this is very similar to

when we use the int. trass what this

essentially does does is it tries to do

something and it lets you know if

something went wrong this is exactly the

same when we're dealing with exceptions

except when we're doing a try catch what

the catch means is it's catching the

exceptions that happen and therefore it

is now a handled exception instead of

unhandled exception so before we try and

fix how this works let's just explore

the syntax so we can trpe in try Follow

by curly brace and just after this curly

brace we can say catch and then we're

going to put something inside the

brackets and then we have it opens

brackets if you wanted a quick shortcut

to this just like we've done the for

Loop and we double tap tab we can

actually delete this so you can type in

try and press tab twice and then you get

try the Open brackets you get the

exception and then we get a throw so

let's get rid of this and what we can do

right now is we can actually place the

code that we want inside here inside

this Tri bit because we're telling the

compiler that we want to try to do the

things inside here and then we want to

catch these things so inside these

brackets what you want to actually do is

decide what thing that you want to catch

if you type in exception this will catch

every single exception now the problem

with that is you'll actually face some

difficulties when you're trying to

Output very very specific messages so as

we've said before when you type in a

value too large you get an overflow

exception but when you type a value that

can't be converted like a square bracket

then you get an input format exception

so first what you actually want to do is

run this code outside the try and let's

run it now and let's get them bad values

so we had the square brackets and we can

get this and let's copy it down and

place it inside a comment just like this

and then let's rerun

it and if you type a number too big take

this stop the program and put it inside

here so now that you know what the

exceptions are called we can actually

write these inside the code so we have a

form exception and an overflow exception

but before we get into these specific

exceptions let's just catch everything

this is just a catch all and then see

how this

works so as we've put it back inside

here let's see what actually happens so

we can just put a console right on here

and say something has went

wrong the reason why it's something has

went wrong is because this is a catch

all any exception appears during this

code it will always come into here

regardless of what the exception is

whether it's a format or an overflow it

doesn't matter it will always come into

here so it's going to be something

because this is not specific at all so

let's run the code enter a very big

number something has went wrong but if

you notice how the program doesn't

actually clash it's still very much

alive and we can test this by putting a

simple message here at the end that says

goodbye and we run it again enter a big

number and there you go we get the

message as goodbye so it successfully

skipped over this section without

actually causing an exception that

breaks the program so even though we've

entered something very fertile because

we've handled it then there's no

problems so if we now type the other one

where we have the square brackets then

you'll see we'll also get something has

went

wrong so if you wanted to catch a very

specific exception what we can do is say

catch open the brackets and we can say

format exception just like it says above

here and then place the curry braces and

what you can do now is you can actually

chain these and these go from top to

bottom when an exception occurs up here

it will match this one if if it doesn't

match it will match this one and you

want to put the catch all right at the

end so if it doesn't match any of the

ones above it it will always match the

last one so you can have a generic

message inside here but you can have a

very specific message inside here

because it's a format exception you can

say please only enter numbers so now if

you run the code and if we type in

square brackets it'll say please only

enter numbers there we go so this is a

very specific example and if we copy and

paste this down again and then we can

say overflow exception

and we can say please enter a number

less than 2

billion if you enter a very big number

again please enter a number that's less

than 2 billion

perfect so this will get checked like if

statement it will start on the first one

and go down the list imagine this is a

if and then we have an else if and then

else if as well if you place this one

right at the start then you're actually

going to get compiled errors and you

can't actually have the catch all right

at the start so even if you wanted to

the compiler literally doesn't let you

and anyway you don't really want to be

doing that because then you'll be ruling

out these two and it's kind of pointless

writing this code if it's never going to

get used anyway so now when we run the

code you can see even if we typ in a bad

value our program will still run and

everything works okay so now what we can

do is actually make this into a real

life

situation so if we actually type in 10.2

then it says please only enter numbers

then we're going to have an issue here

here because if we try and print the

value down here then it's going to cause

a problem let's try and print out num

and you can see that num does not exist

now we have an issue of scope in is only

declared within here and here so if you

wanted to print out the value of gome

we'd have to print it out up here so now

let's run it again and if we enter 20 20

comes up if we've entered 15.5 then it

actually skips over this console right

line because the exception occurs right

here and then it'll jump into one of

these paths so in order to store the

value of num you can either the move num

outside here and make it equal to zero

and then assign num inside here and then

you can take this console right line and

actually put it right after the triy

pass but I don't really suggest this

option so if you said 15.5 then you're

just going to get zero returned but we

don't really care about the zero because

we're not going to get the value

converted so why do we need to print the

zero and the answer is we don't so what

we should do is keep it all inside here

again and then what we should do instead

is wrap this around in a while loop so

this will try to do the code this

section will catch them all and then we

simply have a good buy at the end but

let's just make sure that this actually

runs because if we type in

15.5 then the user still hasn't entered

the number but our program was closed so

we want to loop around until the user

has successfully entered a correct

number so we can say bull looping equals

true and we can have while the cord is

looping that off the curly braces let's

place our entire Tri cat inside here if

we highlight it all hold alt and press

the op power key and then tab it once

and then get rid of this empty line so

now we'll keep looping around here until

this is going to be a different value so

because the while loop will only keep

looping until this is true and the

moment when it's false is when it will

cancel the W Loop so as I said before

when we run this code and then just at

this specific line if the exception

occurs it will actually skip this line

and jumped below here so if it skip this

line then what we can actually do is we

know if it reaches this line then the

conversion has been successful so we can

print out to the screen and we can say

looping equals false and we don't need

to place looping is equal to True inside

all of these three paths because if we

don't assign it to true then it's still

going to be the value false no matter

how many times you loop around so let's

try and run that

now enter a number 15.5 enter a number

15

and we can keep doing this forever as

it's a while loop and as soon as we

enter a valid character 20 and now it

says goodbye because we hit the end of

the

program so that's it for this video but

let's just have a little recap so we've

determined when we run our code just

these two lines that in both situations

we can have a format exception and an

overflow exception we can use these to

catch them specific exceptions and then

have a catch all at the end the reason

why you want to catch multiple is you

can have a very specific message

overflow dictates we have a number

that's too big or too small to fit

inside of an integer it can be less than

negative2 billion or can be greater than

2 billion and that's how you get the

Overflow exception we get him a format

exception if you entered something

that's literally not a number or

something that has decimal places and

then our catch all can be if anything

else goes wrong we can output a generic

message by 99% of the cases you'll

either enter number too big or too small

or it in the wrong format and this AC

ction is just so it catches everything

else should anything else happen so at

this point even though our program

doesn't actually close and there's no

exceptions the user hasn't had a chance

to enter the number again so we use this

inside a while loop and we can say while

looping is true when we hit a conversion

that's successful we say looping is

equal to false and once it hits this

line the Y Loop will then exit and then

we'll get our goodbye message and we

wrap the entire try catch inside the W

Loop just so this keeps on looping until

the user has typed in a successful value

as demonstrated

above we can type all this and 15.2 15

Point 15 and then finally says 15 and

then

goodbye so I want to explore different

ways you can output messages inside this

catch block when you have a catch

exception this is actually a parameter

that we're passing in this parameter can

actually have a variable as well

normally when you specify parameters in

a function form you say in and then some

something whereas right now we're kind

of defining the data type which is our

exception in the same case as int here

but we're actually not giving it a name

so it looks something like this of

course when we do this inside a function

we're going to get a syntax error but

for a catch we're not going to get any

errors at all and the reason is because

we can catch without having to use a

local variable so if we actually add a

local variable make you call it e for

exception then we actually have lots of

options inside here Type e then we have

lots of data and the stack traces very

helpful when you debuging but we'll

cover that at later date the thing I

want to focus on right now is the

message so we can use this and print out

to the screen so we can say error callon

and then type in E message and let let

run that now if you enter something

invalid input string was not in a

correct format if you enter a very big

number then values either too large or

too small for an in32 as you can see

these error messag are pretty

descriptive and normal users should be

able to read this and understand it of

course if you want this error message to

be more specific then you can add some

more catches inside here and we can have

format

exception this will be if you type in

something other than number but if you

do exactly the same thing in here then

it's kind of redundant because you're

just outputting exactly the same value

if we try and put the square brackets

again then we're going to get this

string which is actually outputed from

this line but even if we include the

catch all exception you get exactly the

same error message outputed from here

the moral of the story is you should

always have a catch all right at the end

of your chain but if the only thing

you're going to do inside here is simply

output this message to the screen then

you don't need any multiple catches what

you should do is catch multiple

exceptions that you know are going to

get fired in your code and then you want

to handle them and then have a catch all

at the bottom that will display the

message generically instead of

displaying the message right here you

can actually have a more specific

message like we covered in the last

video so this could be please only enter

numbers and we don't actually need the

message in this case because we know

what exception we're going to catch

because we've specified formal exception

another little tip if you hover over the

function call it says here format

exception and overfall exception which

are the two that we handled in the

previous video this is very easy and

understandable if you can just read the

values from here and to see what

exceptions can get raised and the same

thing here you get an IO exception for

the console right line the console right

can also give back an IO exception as

well generally speaking these console

functions almost never return back

exceptions I don't think I've ever hit a

situation where this exception has been

returned unless you do something

ridiculous and maybe you type in way too

many values that the console right line

can handle let's try an example and we

can do something like this if you enter

a very big number that can't be

specified inside the integer then

console right line has so many overloads

that actually processes it as a long

right now so you almost can't break this

unless something fundamental to your

computer actually happens so you have

exception e and with exception e you can

actually take this local variable and

print out the message this is the

preferred pattern because instead of

outputting here something went wrong

just very generically you can actually

give them the error message that comes

back from the exception the reason why

this is helpful is because if it doesn't

hit any of these exceptions and it just

happens to fall into the catch all at

least the user has an idea of what the

error message is going to be the

preferred option is to try get to a

point where you never have to reach the

catch all and try chain as many catches

as you can in order to handle as many

exceptions based on the code that you're

writing which can be found if you hover

over the function and read the

exceptions once you've covered as many

options as you can throughout the

catches then you almost never have to

worry about the code entering this

section because we've covered both the

exceptions in format and overflow and we

can do the Overflow right now please

enter a value under 2

billion then that means we've actually

covered all of the catches that are to

do with converting an integer 32 covered

format and covered overflow so when we

run this code the only two things that

can possibly go wrong are these two

functions the format exception overflow

exception and we won't ever hit the

catch all in this case but if anything

goes wrong at least we have a belt and

Brace option to catch it and we can tell

the user what happened and because it's

e. message then the value is going to be

quite descriptive so the user can read

it without any

problems so in this task we want to be

able to convert a string to an INT

successfully without any errors

occurring and without any exceptions

that could break our code so in steps we

want to create an INT and try and

convert any string from the console to

an integer notice the error that appears

when you try to do that write a try

catch handle around it to successfully

operate that and output the message to

the screen and you won't need to change

the console out print and the convert

in32 to be able to make this work so you

don't want to change the current code

you just want to add the triun Handler

around it so why is a bad situation how

can we know if it's been converted this

is just a question that you should keep

at the back of your head and we'll

answer this shortly and then finally we

want to create a custom tri pass

function find the real trip pass

function and copy the return Titan

parameters and see if you can mimic Its

Behavior read the tool tip it gives you

to give you ideas on what to do so let's

take these in steps first we can have a

console right and say enter a number and

then Inn equals convert to in32 and then

we need a console read line

and then if you run the

code if we try and just convert some

square brackets then we get a format

exception so that's the exception that

we're going to be handling right now so

we can take this code and we can wrap it

around and a

try use alt and up Arrow key and then

just after do a catch and then we want

to do a format exception and then space

e to give it a variable and then we do

e. message out to the screen and now

let's run the code square brackets input

string was not in a correct format so we

get our message and our exception has

been successfully handled and our

program hasn't crutched but the problem

is is has got to this console read line

and the user hasn't had a chance to

actually enter a number so what we can

do in here to ensure the user always has

access to writing a number is we can say

something like this bu success equals

false and then just after here we can

say success equals the

true and just down here we can say

console right line so success question

mark yay and then call on or

no so if it converts it 15 we should get

a yay and if we convert it and it fails

then we should get an o no along with

the

message of course what you can also do

is wrap this entire section inside a

while loop what we've already covered

that inside the tutorial and that means

it'll keep repeating this until this is

set to true and therefore exit the while

loop and then will the users finally

typed in a number so let's go back so

we've noticed an error and we've brought

a TR catch handle around it now we want

to catch the error and output the error

message with through done and then we

haven't changed the current code which

was these two lines we've added a booing

and set it to True here just so we can

have a bit of an output message before

so why is this a bad situation how can

we know if it's being converted so this

code is a bad situation because we just

have these two lines outputed and then

now that we've added our booing to tell

the user whether it's been successful or

not is actually making it a bit more

meaningful the problem is even if we

print or no then the user doesn't really

have a chance to enter it again so like

I said before you could loop around and

use a while loop to make sure that this

situation can go from something that

gets handled into a situation where the

user can actually type it in there's no

point hand on an exception and realizing

there's an error if you don't give the

user a chance to enter another value if

they enter out 15 followed by full stop

when they only meant to type 15 then you

need to give them another chance to type

in that 15 value otherwise the program

is simply just going to end and

nothing's going to happen for example 15

DOT it says or no or you can have

another message that says something went

wrong or you can have more specific

message about the conversion and then

once you press enter the program simply

closes this is not an interaction that

you want you want the US it to be able

to reselect another value so that's why

it's a bad situation because you know

it's being converted or not heuse now

build success but the problem is we

don't have any sort of looping so let's

have a look so now let's comment out

this and let's see how we can make our

custom trip pass so you type it in. trip

pass you can see they have a bu inpass

string s and out in result so let's try

and copy that and make our own custom

function so we say static Bull and it's

Tri pass and then we have a string input

and out in

result perfect so now we can get rid of

this line just so we use it for

reference and let's use it straight in

here and then we can write the

implementation in a second so we can say

if trass the thing that we want to pass

is actually a console read line and then

we just say out into

result and the console read line is

going to be answered to this question

which is enter a number you place that

straight inside here and then we say out

in result so if this has been successful

we can print out yay again and else if

it's not successful we can print out or

not of course you can do other things

inside here or you can even print out

the value straight from here so we can

say yay plus a space and then result

just so we can get that back to the user

and then oh know if something goes wrong

of course this is just so we can test

things and see how they work so this Tri

pass function it will take in a string

input and it'll try and give us back the

result so in order to be able to make

this successful function what we need to

do is essentially do the conversion

ourself which will be this convert in 32

so first we need to assign this out int

so we can say a result equals minus1 so

now that we've used that we actually

need to have a return type as well but

let's worry about that in a second so

essentially what we actually want to do

is say that the result is equal to

convert to in 32 and then we want to

convert the input store it inside the

result and if this goes successful then

we want to return true and if it doesn't

go successful then we want to return

false but of course we need to be able

to do these things separately so like we

said with the try you only wrap around

the section of which is going to be

problematic so in this case as we've

done here we've wrapped the convert in

32 inside the try so we're going to need

to do that down here as well so we can

open the try right here and place these

two lines

inside and then have a catch have a

little think about what sort of catch do

we need the whole point in this function

is to Simply convert value and return

back whether it's been successful or not

there is no messages here we just need

has it been successful yes or no and

because we only need to know if it's a

yes or a no then we can just have a

generic exception and we don't need the

E variable because we're not going to

access the message we're going to keep

it as an exception and instead of

returning false down here we actually

want to do this straight inside the

catch so now the code reads like this

we set the result to minus one and the

reason why we do that is because if we

don't then we're going to get a compiler

error and it says that not all paths

will going to assign result

alternatively we can also assign result

straight inside here just so we have an

assignment in both paths or you could

just leave it outside at the top so we

assign result to minus one and then we

place our problematic code straight

inside here we try and convert the

result and if this line returns back

successful then it's going to execute

the second line and return back true if

this line returns back an exception it's

going to miss this line completely and

jump straight into the exception and

then return us back with false so let's

actually try this and see what happens

15 DOT or no and then 15 y 15 so the

reason why we don't care about the

exception in here we can add in

different values as we've used before

with format exception overflow exception

but as we saw with trass it simply just

returns us back with the bull the bull

simply tells us if it's been successful

or not so we could stack these multiple

times times we can say catch and then we

have the format exception and then we

can place a return false in there and

then we have another catch for the

Overflow exception and we can place

another return false in there but as you

can see we're just returning false

inside here so now that we've changed

these it's kind of pointless each of

them return back false and because we're

not doing anything very specific we

don't actually need to chain them all

together we don't care about the message

we don't care about exception we only

care about the fact that something has

went wrong and if something has went

wrong then we return back false if

everything goes okay then we return back

true and that's all this Tri pass

function is going to need to do it's

simply convert it or it doesn't convert

it using an input and outputting a

result so if you run it retype in a real

number we get a number back and then 15

DOT Z then we get all no because it

can't convert it there we go we've met

all our requirements for this

program let's have a look at how we can

do debugging using visual studio to to

step through our code manually so this

is the example I used last time int age

equal 35 and ideally in this case you'd

want something like 30 plus to be

printed instead of 18 plus even though

18 plus is still technically true we'd

still like 30 to be printed in this case

because this is if it's over 18 do 18 if

it's over 30 do 30 plus so in order to

start the debugging process you

shouldn't run the code first if you run

the code first it's going to execute so

fast that you won't get a chance to

actually put any code in and and try and

debug it there we go we've already hit

the console read line and it's executed

for a spit second so the best thing to

do just to the left of all the line

numbers you want to press in the Gap and

that will create a red dot and it'll

tell you that this is a debuging red dot

just in this little tool tip debugging

do program. men debuging program. men so

it tells us we're in the program class

and we'll going inside the main you can

also address the debug menu up here and

it says we can have a toggle breakpoint

we can add new one we can delete them

all or we can actually disable deleting

them will just simply get rid of them as

you can see here if I set a couple more

and press disable then it's going to

hide them so when I run our code it

doesn't actually apply the debugging but

it doesn't delete them and then we can

enable them and then we can also delete

them all and it gives you a little

prompt because if you're doing this

inside a big project and you just spent

a lot of time going through and

debugging certain functions then you

don't want to be able to delete them all

without any confirmation so to delete

them all and put it back on line 13

which is our int Edge so let's run the

code and see what happens so as you can

see it minimizes our console for us and

nothing's actually been printed yet

because we're only up to this line and

then we can use these buttons up here

step into goes inside a function step

over goes over the line so it will go

from this line to this line step out is

used after you've stepped in if you

stepped into a function and then you

don't want to see the rest of the

function executing you can step out to

jump back out of it which I'll

demonstrate later on in this video so

now that we've hit this line you can

actually see what's going on so we have

int age equals z because when this line

is highlighted it means this line hasn't

executed just yet so we can press this

or we can press F10 on our keyboard if I

press F10 you can now see int age has

the value 35 and what you can actually

do is double click on it and just change

the value to 30 for example now if you

highlight you can see the value is 30 so

you need to double click change the

value to something and then simply press

enter if you change the value but leave

the box like this then it won't change

the value so you have to remember to

press enter so now I've made the age 40

but let's just change it back to 35 to

keep it the same and then now what we

can do we can explore what's going on

here if age is greater than 18 then

we're going to check if this condition

is true or false so in order to check if

this returns back true or false you can

actually hover over the operator and it

says here AG is greater than 18 is equal

to true and if we hover over this one it

says AG is greater than 30 is equal to

two notice what we actually did there we

essentially ran this condition through

the debugger without actually reaching

this line we're only up to line 15 as of

right now but we've managed to execute

this and give us back a function so as

you can see age greater than 30 is true

and age greater than 18 is true and

because this is lsif chain it only cares

about the first one that turns back true

and because this one has turned back

true then if you press F10 again you'll

see that now it's went inside this curly

bra is which will print out the console

right line if I press F10 again you can

see we're now waiting on here if I use

alt tab I can get back to the console

you see that 18 plus has now been

printed now that we're waiting here we

actually press F10 one more time and

then it jump straight to this read line

of course because this is L if chain as

soon as one of these become true and it

jumps over the else if because of course

this is a chain the first one it hits

that's true it skips over the rest if we

didn't want this to be a chain then we

could keep them as both independent if

statements if age is greater than 18 and

if age is greater than 30 and don't use

the lse keyword but in this case because

you do want to Output a different

message for every single age range you

do want to place the L's word in there

and now that we've hit this line we can

press

F10 and then now we jump back in the

console and now we're waiting right here

and just a little tip when it comes to

debugging if at any point you just want

to exit the debuging you can either

press continue or just press F5 and the

program will run for example if we

investigate this variable and we can see

the value is 35 and then now we're happy

with the rest of the Coe we can just

press F5 and our code will run as normal

we'll get the out print and we'll get a

read line waiting here so we know our

problem here is both conditions return

back true so just like in the last video

we actually change this condition so to

make sure that it only goes between this

range but let's not repeat ourselves

let's have a look at a different example

so we can have string name equals Abu

and and then int age and then age equal

23 which I'll demonstrate why I've done

it like this in a second and then let's

have a function just so I can show you

how to step in so we can have a static

string print details string name in

Edge and here actually we want to just

return back a void because we just want

to print out to the screen and we can

say name space edge and maybe just put a

dash between them and let's run that

code now we can see

aa-23 of course making that function

wasn't the point I actually want to show

you what's going on so if we just print

this a couple of times just so we can

show you the step out and step in so if

you run the code now we can see our

string name if we go over that you can

see it's called abber and then now that

it's stepped over this line cuz there's

nothing really to execute here it's just

creating back a variable so you can see

that age is zero cuz that's the default

value for an integer and when we skip

over that now it's got the value of 23

so one line creates the integer with the

default value equal to zero and then the

next line will make it equal to 23 and

then we're passing on the variables here

and if you wanted to investigate it you

could simply just hover over them like

this so you can see what the values

contain and then now that we've hit this

function if we press F10 then it's just

going to skip over it but what we

actually want to do is be able to go

inside the function so this is where our

step in goes step over doesn't care if

it's a function or a normal line it will

just step over it regardless so we want

to in here we want to use step into or

we can press f11 once we press F 11 you

can see that now it's jumped from print

details up here to print details down

here and then now look if I step through

it's going to actually execute these one

by one so right now it hasn't executed

anything so I step over this once using

F10 you'll see it now appears and then

the same thing with this one and this

one and now that I've executed three we

should see three in the console perfect

so now what I want to demonstrate is

let's say what happy with the rest of

this function and then now we want to

just step out so I press this button and

you can see it jumps back back up to

print details f11 to go in and then

shift f11 to go out so now that we're

back in here the only thing we can do

really from this point is either press

F5 to stop debugging or press F10 to

jump to this line and at this point

we've already hit the last line now code

so we don't really need to use F10

anymore cuz we nothing to step over so

we can just press F5 and let our program

finish and there we go so let's have a

look another example can have a string

message equals read from console then we

can pass this in and

anything and then we can have a console

right line and we can just print the

message and then let's create this

function so because it's a return value

and start inside a string we're going to

need a static string read from console

and then this is one string parameter so

we have a string

message and then we can just do a

console

right and then print the message to the

screen and then we just want to return

the console. readline there we go and

again let's put a break point here and

we can remove this one so it doesn't

always have to be the first line if

we're perfectly happy with this amount

of code then we can simply take that off

and it will stop when it gets after this

line now if you look at the console

you'll see all of this is executed that

function is executed four times to print

the name and age of the screen and now

we're waiting here so we have our read

from console and now we can step into

using f11 and you can see that if you

hover over string m message has enter

anything which is our parameter that we

specified up here and then there you go

and then that will print into the screen

so you tab back in you'll see it says

enter anything and then just at the read

line we need to actually enter it

now

something and then press enter and then

just right here it's going to return it

back so if we use F10 it jumps back in

here and then actually we need to

execute this line so F10 again and then

if you hover over a message you see it

says something which is exactly what we

typed in the console here and then we

just print it back to the screen there

you go and now we just have the console

read line and we can press F5 to finish

up there we go so debugging is mainly

used by pressing this button on the side

so debugging is used by pressing on the

empty Gap just to the left of the line

number and it'll create a red dot once

you create a red dot it'll highlight

this for you once you've clicked on it

it should show up a red dot you can also

disable or delete all the bra points

from the debug window at the top of the

screen when you run the code it will

stop here and then you can either use F9

as a shortcut as well click into the

line that you want to debug and press F9

please note there is specific cases

where if you try and press this one

right here it's not going to let you if

the line doesn't really do anything for

example this is creating an integer

there's no real action that's happening

here that you should or want to debug

this is an assignment this is an

assignment this is a function call and

so on and so forth and this is also a

function call when it comes to just

declaring variables then a compiler does

not let you put in a break point because

there's nothing really to investigate

when you're just creating a variable so

don't get thrown off or think

something's wrong if you click on the

empty line and nothing appears so that's

it for debugging but let's just have a

little recap we can use F10 to step over

f11 to step into functions shift f11 to

step out or you can use the buttons that

appear at the top of the screen when you

run the code just right

here hover over variables and you get

their values as I showed you in the if

statements if you hover over the

operator inside the if statement it will

actually tell you what the condition is

and whether it's true or false so you

say if 1 equals equals to one and let's

just print out true to the screen just

so I can demonstrate

this if I hover over the equals equals

it says 1 equals equals 1 is

true so that's how you check if a

condition is going to be true or false

when you're

debugging you can check the parameter

values by simply hovering over it and

the tool tip should include the

value just like so and if you wanted to

step into this function you can use step

into and then use step over which is F10

just here and then you can actually

investigate these values as well or you

can look at the parameters and once

you're done with the function you can do

shift f11 or you can use step out and

then you can skip over this and the same

thing with this you can have a look at

the string variable once it gets

returned something in here and now it

says something thing in here and string

message and then we can print out to the

screen Etc so you can have a little bit

of Freedom with what you can do in terms

of debugging play around to debuging in

the past exercises that we've made

together and then what you can actually

do is gain experience in debugging so it

comes to more complicated projects you

can also apply that learning there and

make sure that your code is error

free so we covered how to debug by

pressing the white space just to the

left of the line number if we run the

code

the program will stop where our

breakpoint is and it won't execute the

line that we're up to we have to step

over it so we've actually used this

before to analyze our functions and see

what values are inside things so we have

these extra windows called the local and

the auto so let's take a look at them

and see what they're about so again if

you don't have this layout you can use

window reset layout and it should be on

the left panel not the right one this

time so we've got watch which we'll

explore later and we're going to have

locals and autos so the autos because

we're up to the age then it shows us the

age has value zero and then that

prevents us from hovering over it and if

we step over it you'll see that now it's

got age 23 and now name has appeared the

auto tab will try and figure out what

functions of what parameters you need to

be displayed down here based on the

section of Corde that you're currently

up to so my guess is because we're up to

this function and it takes in a name and

age then we're getting name and age

appearing before when we were on this

line it was only showing back the age

and because that section only used the

age we only got age here but if you

press locals you can see all the

variables that are local to this main

function are actually showing up we have

a parameter called ARs and technically

this is a parameter and it's a string

array type but it's currently unused but

it's still a parameter so you can see it

down here and then in order we have the

name variable down here then we've got

the age and then we've got the message

which is currently said to know because

we haven't created this in memory yet

but as you can see this changes depend

on the scope of our variables so now

that we're about to hit this function

let's use the step into and you'll see

that the locals have now changed we've

got rid of name age argument and string

message and it's replaced with name and

age because remember what I was saying

about the scope of the variables

parameters inside a function are always

going to be local to that function

around the curly braces that they're

surrounded by name and age is only

within here so when it's trying to shows

the local variables it's only local to

what's inside these curly braces which

in this case is name and age so now if

we step over

this and then if we step into this read

from console you'll see that just before

we step into this function that these

have all came back cuz again the scope

has changed back to this function which

is our main function which has all these

variables inside so our read from

console will only have our string

message so hopefully when we press f11

or press this step into button at the

top we should only see the message

variable inside here there we go we get

into anything cuz that's what was passed

in over here and then as soon as we

return back to

that let we type something in and then

we get all of the values again and you

can see that system. console. rine had

returned hello which is this line and

then if we press F10 again you'll see

that even though we've got it back here

our message is about to be assigned once

we step over this there you go it says

hello and as you can see this changes in

real time so as soon as we step over

lines hello got play straight into there

this helps us tremendously because we

don't have to keep hovering over

variables like this to keep checking

over their values you can simply use

this menu and it will always update

because whenever you change Scopes

between functions that will

automatically update as you just saw in

them examples there we go and then when

the program ends obviously this window

is going to close down so that's a very

helpful method of being able to debug

without having to hover over anything in

the next video we're going to cover how

to watch variables and this can be very

handy when you're looking for specific

areas

another really good debuging technique

is the watch window let's press a break

point just of left of line 13 and let's

run the code and let's see what this is

about so we covered that we have the

locals window and we have the auto

window that will automatically give us

the variables that we're currently in

the scope of but let's forget about that

right now let's have a look at the watch

window it says here add an item to watch

so there's a couple ways that we can do

this you can actually double click on a

variable and write click or you can just

highlight it like this and then right

click and it says here add watch and you

can press it it says name value null

because we haven't created it yet so the

default value is null as of right now

cuz it's not actually assigned anything

so if you press F10 and step over it

you'll see that immediately changes to

abber without was having to do anything

except simply press F10 which is the

shortcut for our step over button right

at the top of the screen this prevents

us from having to hold over the

variables to get the little tool tip so

we can see the value the of this is we

can watch variables and we don't have to

worry about showing in the locals or the

auto because it's always there and if

you have lots of variables like this

then you're only concerned about the one

that you're watching locals and aluto

will always change depending on the

scope that you currently at whereas

watch will only do what you want it to

do so because we don't put age inside

there then it simply won't come up just

because it likes it if we check the

locals we have agent there and the Autos

we have agent there as well but we don't

have it in the watch so what else you

can you do is actually just type

straight into here age

23 if you really wanted to you can

actually also type in conditions age

equals equals 23 it returns back true so

if you had an if statement that you

wanted to track then you could do that

as well so let's have a

look so had this statement that said if

age is greater than 18 then we can just

print out 18 plus to the screen so let's

run the code now and see what happens so

as you know we have this condition right

here so if you actually highlight this

and and drop it you can see that the

cursor changes and you can drop it

inside here let's click on the age equal

equal 23 and click delete so of course

we can't really render this function

right now because we haven't even

created the integer variable so let's

run over the integer variable and as you

can see here it says AG is zero which is

the default value for integer and that

is indeed zero right now and then AG is

greater than 18 is false but as soon as

I step over this line and it makes age

the value of 23 you'll see that these

two immediately change you know they

change because the values have went red

red means that the values have just

changed in the last button that you

pressed whether that means you stepped

into over or stepped out it doesn't

matter red always dictates that the

value is just changed so now it's

telling us that age is greater than 18

is returned back true so when I step

over this line because this is returned

back true I should render 18 plus let's

have a look F10 F10 and there we go

we've reached the middle which means

that's going to get printed out

now so so moving on to another example

we can have print details if we go into

this function and let's say we're only

concerned about the name then we can

print out the name down here but as you

can see we already have it twice so

that's just going to update depending on

the parameter name and even if you

wanted to show something like this you

can drag this down here and it actually

shows you the output this is very handy

so you can see the output because

sometimes when you have it like this it

doesn't look very clear you can also

hover over it right there and you can

see the value placed here but again it's

very handy to have it here so you don't

have to keep hovering over the tool tape

just to see the values and from here you

can actually change the values so we can

just say Harry is now the value for the

name and Harry is going to be age 35 so

when we press F5 and let the program run

naturally you'll see that Harry is age

35 now and that's all done through the

watch list down here and it doesn't even

matter because we have full control over

the watch list variables and we can

change their contents to see how our

code acts in different situations so

please use this watch list as much as

you can and don't forget that once you

can double click on variables and add it

to the watch just from here you can also

say quick watch and what that'll let you

do is it'll give you the value and then

if you want to add it you can press add

watch here or you can just keep pressing

re-evaluate once you've skipped over

some lines so let's say we skip over it

now and then go back onto it and because

it has a shortcut shift F9 we can just

quickly press it like this and it says

Alber inside here and we can change the

expression

maybe do something like age and then

click re-eval it and it changes the

value to zero and then we can even

change this to like 50 for example as

you can see down here it's changed to 50

as well so you can drag and drop it into

here or you can double click and press

add watch it's up to you please make use

of this watch variable and don't rely

too much on the autos and the local just

so you can keep your own variables

inside here and you can have complicate

outputs like these you can check

conditions you can check console outputs

as well as just checking normal

variables so using the watch window you

have lots of different opportunities to

keep track of your

code so we've got another debugging task

let's try and run the code and see what

happens we're going to get printed over

18 so our value is agal 35 and we're

already getting over 18 printed to the

screen so if we place a Brak line inside

here and actually run the code we can

see what's going on we can add them

inside the watch just like this we can

add in all the conditions inside

just like

this perfect so we can actually see here

that because our age is over 35 it's

saying greater than 18 is true greater

than 30 is true but greater than 50

isn't true and we can easily see that

except because this is an if and an LSI

chain as soon as the first one is true

it's going to enter that one you press

F10 then we get over 18 and then as soon

as it finishes that path it actually

skips all the way to the end the problem

with this is we only want it to print

over 30 since it's over 30 so we have to

introduce ranges inside here and we can

say age is less than 30 and then you can

have AG is greater than 30 here and then

you can also insert an and and say age

is less than 50 and there we go and now

it says over

30 and if we change this to 55 then we

should get over 50 and then finally if

we change this to something like 23 then

we should also get over 18 perfect so

what was going on here is because we had

if El if chain then you're only going to

get one of them printed and because a

value over 18 satisfied both the first

path and the second path then it's only

going to print the first path if we

actually undo our changes all the way

till the start and then we actually flip

the order of this if we put our this one

first and delete the else and change it

to lse if inside here so now we have a

new chain except the first one in the

chain is actually if age is greater than

30 now if you're on the code you'll see

that the first one actually says over 30

30 and it says over 30 and it doesn't

say over 18 anymore but simply because

this is the first one in the list as

soon as it hits the first one as I'll

demonstrate now it will go inside this

bracket hit this curly brace and then

jump straight to the

end you should always order them from

smallest to biggest because that will

probably make the most logical sense

when you're reviewing your code and in

doing so you can actually have a more

formatted code but you need to watch out

that the ranges need to make sense if

you have something like this then you

need to restrict this one because it's

going to be blocking the second one and

you don't want to make these all ifs

because then you get multiple outputs

now we should get 18 and 30 being

printed to the screen this is not

something you want so make sure that you

place your ranges inside here by adding

an and and then placing the other end of

it which will be 30 and then this one

will continue from it so just to sum up

what you need to do is make sure that

you use l ifs and make sure that you

have ranges just so when one exits it's

going to check the other one and the

other one you don't want the first

condition to beat the second one if

that's for the right path age 35 goes

into this path or at least we want it to

but it's been restricted by the fact

that age is greater than 18 when we had

it like

this this is restricting everything over

18 to go inside this path if this was

even like 65 we should only fall into

this one and we run the code then we're

still going to get over 18 which is

still technically true it is still over

18 but we have different outputs for

this sort of age range make sure that

you use El ifs and you keep in an

appropriate range and keep them in the

order of the if statements going from

lowest to highest or whatever makes

sense in that situation that you're

using

it this is a start of objectoriented

programming let's start with a concept

called structures structures allow us to

store different data types inside one

data type so it's almost like a group of

data types we can demonstrate this if

you wanted to stall something like a

person you would normally have something

like a string name equals ABA ear it in

age equal 23 so in here we have a string

name that represents the name and inage

which represents their age and you can

see that because these are two different

data types you can't wrap them around

inside an array you can't have a string

array called person and then say we want

to have two different values although

this will still compile we can't store

both these data types inside our array

unless you make the age and store it as

a string which will be 23 inside the

quotation marks and then you'll have to

worry about converting it later on in

your program so this is not really ideal

so we have something called a structure

so just outside here we can say struct

which stands for structure and then we

can have our name straight after so we

can say person and the next time we just

open the curly braces and let's see what

we've just created so now in order to

make an instance of this we can actually

use that like a data type so we can say

person person there we go so now we've

created our person variable now we see

we've got our own data type before we

were just using string and ins and

arrays and things like that but now we

actually have a new person so because

our person is made up of a name and an

age let's place that in here string name

and then int age of course you don't

want to give them default values because

like all variables you don't know what

the value is going to be to begin with

so now what we can do person Dot and we

don't actually have access to using

these values yet so what we're going to

have to do there is a concept called

access modifiers which we'll cover on

later on in this course but just for now

what this means is you either have

private or public public and they're the

main two words there's other words that

you can have but they're the main two

for now if you have it private it means

you can't access it down here through

person. name and but as soon as you make

this

public then now it becomes

accessible there we go we can make that

equal to something and if we take off

public then you see we don't have access

to it it's inaccessible due to its

protection level because the protection

level is private which means that you

can only access name Within These two

curly braces the second you make it

public it means that anyone outside of

the structure EG down here can also have

access to name so if we do that to our

public on in age and string name then we

actually can access both now we can say

person. Ag and it comes up like this the

purple cube is a function and the blue

is Fields you can actually fil them out

by pressing them down here show only

methods and show only Fields so we can

do age equals 23 and we can actually

just place abber inside here

and now that this data is essentially

the same as this the benefit that we

have now is when we print to the screen

we can say person. name and then hyphen

person. age and if you run that

now we get Abid

23 if you actually copy and paste is

lined out and just remove person dot

just so we're using these two variables

at the top of here we in the code you

should see exactly the same values

coming up there we go but now what's

really handy about this situation is we

have two data types that are wrapped

inside of one data type instead of

having a name and age we have a person

because what gets really easy now is if

you wanted to add something else inside

here like for example birth month which

for me is five so in here you'd have to

make another one birth month equals 5

and then all we have to do inside our

person is just say person. birth month

and we can just assign it right here

instead of having to create a whole new

variable we add it up here and then we

can use it down here and then we can add

that into here person. birthmonth

make add this to this one and then get

rid of birth month and as you can see

it's exactly the

same so we've taken these data types and

placed it inside our structure so then

we can just reference it by the person

this becomes very very handy for this

exact reason that I'm going to show you

now let's say you wanted to read this

data in from the user so you have static

and then you're a bit stuck on what data

type you want to return if you forget

about the birth month then we have a

name and age is a very basic person but

our return type only lets us have one

type so that's going to be a problem now

so you could do a string return that

will give us back the name and then we

can say return person and inside the

brackets what you can actually do is do

out in Edge so you can have two output

variables an out age and then a return

string so inside here we could

say enter your name and then string name

equals console. readline

if we copy and paste this down and then

we can say enter your age and then we

can say int age equals convert to in 32

and then put the console read line

inside there there we go now that we've

got that we don't actually need in age

because we've already got output

parameter so we just need to be age and

then after we've retrieved them two

values we can return name there we go so

let's actually try that up here so we

can say new name is equal to return

person and then out into new age and you

can take this exact line paste it down

here get rid of the birth month and then

we can use new age in here and new name

inside here so let's run that now ask us

what is your name Abba what is your age

23 and then we got Abid 23 which is the

same as what we've got before but you

see that this situation is pretty messy

we have to return a string variable and

also use an output in order to be able

to give back two values alternatively

what we could do is actually just turn

back void and then we can say string

name and then inage but we're going to

have to use references inside here and

then have string new name equals nothing

and then new inage equals zero so we

have string new name equals nothing and

then into New Age also equal to nothing

and then inside our function instead of

having out parameters we can actually

use a reference and we can say new name

and then ref New Age and what that will

do is we can just return it like this

because it's void instead of declaring a

new string name we can actually just

assign it to the reference that just

passed and because it's a void parameter

now and for the return type we don't

actually need to return anything so we

can actually assign these by reference

enter your name abber and 23 so as you

can see it's still works fine but let's

say we wanted to add another birth month

so we' have to take the birth month

variable new birth month make it equal

to zero and then add yet another

parameter ref new birth month and then

we need a new birth month inside

here ref int birth month and then we

need another one from here enter your

birth

month and then we'd store it inside

birth month and then finally we can also

return it up

here as new birth

month Here We Go abber 23 and then five

so we get them values being returned so

in order to keep adding different

properties to your code you have to make

a new parameter and reference variable

and then append the parameters inside

the function now the problem that is

even though you can have an infinite

amount of parameters then this gets very

tedious very quickly and you don't want

this so let's have a look at how we can

make this function exactly the same way

just using our new structure you can see

that instead of having to pass all of

these different things in or return back

a certain value we can actually just

return back a complete person so all of

this can be squished pretty quietly so

actually let's just comment all of this

out and let's comment out this function

and let's have another

rewrite so now that everything's gone we

only want to be returning and dealing

with the person so we can say static and

instead of void we actually want to say

we want to give the user back a person

return person and we don't need any

parameters in this case this is only

passed in because it's a reference so we

can assign these values back to the

original variables but because we're

going to be returning a person then we

don't need to do that so we can

essentially take this code and put it in

here and we can say string name now we

have an INT here and then also an in

here there we go so now that we've

constructed all our variables that we

need for the person what we can do is we

can make a new person person person and

then person. name equals name and then

duplicate this down we say person. AG is

equal to age and finally the birth month

is equal to the birth

month and then now that we've

constructed our person we still got a

red underline because we haven't

returned anything yet and after all of

that we can say return

person there we

go and now simply in here we could just

say person person equals return person

there we go and then we can take this

console right line here and place it

straight underneath since it uses the

same properties now let's try and run it

h

235 there you go so now instead of

having to make a whole new variable all

you have to do is simply just add

another one down here so we can just say

number this could be your favorite

number or anything and we can add it

onto

here person.

number and then here we can paste this

down we can say enter your number and

then it'll be number in here we can

paste it down here and change this to

number and there we go that's all we

need to change and this C doesn't change

cuz it's simply calling back the

function and we're doing all the hard

work inside here so now if you run this

enter your name AB 23 5 and finally four

and there you go we get the values being

returned so this looks a little bit

tedious we have to assign each one

individually every single time we do it

so we can actually use something called

a Constructor in order to achieve this

result we make the person we set them

and then we return it it'd be easier if

we could have the Constructor that we

can assign straight inside here and then

just return it immediately instead of

having to do all of these lines and then

reference each one individually so let's

have a look and see what we can do

inside here we can have a new function

that'll just be called whatever the

structure is called then you open the

brackets close the brackets for now and

this is called a Constructor in order to

be able to use it down here we need to

make it public in order for someone else

to access it so this says that it needs

explicit parameters in order to be able

to compile it says that it needs to

assign name age birth month and number

so let's see how we can do that as we've

used Constructors in the past for

example when we had things like the

string Builder we had s SP equals new

string Builder and when you make a new

something that means you make a new

Constructor so all of these sixes are

the parameters that go inside of this

but each one of these is a separate

Constructor if we control click this we

should be able to see them all there we

go you see that the class is called

string Builder and this is called string

Builder and these two names match

exactly so to make a string Builder you

can give it any one of these as long as

your parameters match one of these six

you can give it nothing or you can give

it some other values and that's the same

is true with our current

person so what we need to do in this

case is we don't have multiple ways that

we can construct this in the case of our

person we have to provide all of these

details otherwise the compiler is not

going to like it so we can have a string

name int age int birth mon

and in number now we got our parameters

set up we actually need to make use of

them in

here so because we have name and name

and they're exactly the same string by

string then here we can't say name

equals name in terms of global and local

variables this is global within the

structure as it's within these two Co

braces and all of these variables are

only Within These two curly braces local

variables always take presidence over

the main one if I double click on this

you'll see that all three are

referencing this Constructor if I double

click on this you'll see that both name

references on line 20 down here is all

referencing this one in the parameter

and not the one up top we want it to be

assigned into here so you have two

options in this case you could

capitalize all of these so then you

don't run into this issue and then

instead of name equals name it's capital

N equals name and that fixes it

alternatively if you want it to be a

lowercase then what you can simply do is

you can place this Dot

if you use this it goes back to the

current scope and the current scope of

name is going to be this which is within

the

structure when you use this it doesn't

reference the local variables it

references the global variables up here

so when I double click on this now

you'll see that that gets highlighted so

we can say this. age equals age this.

birth month equals birth month and

finally this do number equals number so

we're just getting all the parameters

from here and putting them into these

values this might look a little bit

redundant but I'll show you why this is

a lot

cleaner so back in our return person

function we have the variable and then

we assign them all manually but look how

easy this now has became if I comment

out this return we can say a return

person so now we can reference person

with a capital P this time cuz I want to

reference the structure directly so

after the person we can open the

brackets and then start to type in so

our first one is name age and the birth

month name comma age comma birth month

comma and then number comma and then

this is not going to like it because we

also need to place new

inside as I said before when you making

a string Builder you have a new keyword

and this new means that you want to

create a new instance of this you could

think of this structure as a template

this is the template for something and

until you start using that something

it's actually not going to do anything

so we have to make a new instance of it

because it's not already available so we

need to make it available through our

data type so when we say we want a new

person that gives us access to the

Constructor if I remove that you'll see

we've got one of two now we can create

an empty person and that will just make

us assign all the values individually

but we don't want that we want to use

the second path and if you drop the

arrow you'll be able to see the

different parameters which is the ones

we just typed in name age birth month

and then number and now that we've

returned back this we actually don't

even need to do any of these lines right

here we can actually just return it

exactly like this so now if you it again

you should see exactly the same output

23 5 and four perfect so let's just have

a little recap so normally when we're

creating variables we use common

variables that we've used in the past

string in double Flo bu Etc but with the

use of structures we can create our own

group of variables and then we can use

them variables inside functions and

inside our code to make things a lot

cleaner and a lot easier so inside

person we actually store four different

variables and they can be an infin

amount of variables should you will and

you can easily remove them and then

remove them from the parameters and from

the assignment and then that's it if we

use this without our structure then

we're going to have to declare every

single variable separately and I know

this is the same as doing it up here

it's actually a little bit more work cuz

you need to create a new parameter and

create all the the instances inside here

and assign the

values now the benefit of doing it

within a structure is that when you go

to do a function look how easy this line

is before you'd have to have name a age

birth month all as references or have

them as out parameters and it gets a

little bit long and a bit sloppy in

order to include the month in here we'd

have to have another in number and you

can see that the parameters are growing

if you wanted to store a user from a

registration form you might have name

address phone number country and the

list goes on it can be a very long form

and you therefore you'll have a lot of

parameters so it's very easy to wrap it

around inside a structure and then

simply reference it like that and you'll

need zero parameters because everything

is contained within the data type and

then inside here we can ask for the

users's details individually store them

as their integers and string variables

and then instead of using this notation

we can now use our fancy Constructor

where we can pass it in in this exact

order right here name age birth month

and then the number perfect and then we

can use inside here we can call each of

these positions separately and

concatenate them

together so now that we covered

structures known by struct as the

keyword let's have a look look at

classes and how to define them

syntactically so we can make a struct

called person and we can give them a

string name and inage and to make them

accessible we'll make them public and we

can say public person string name and

int Agee and that means we can assign

these values using the Constructor so we

can say this.name equals name and this.

age equals age perfect so's get rid of

our compiler error since we're assigning

both the values and then down here we

can use it we can say person person

equals new person and then have abber

and then 23 in the brackets and we can

print to the screen person. name and

then if use contrl D to duplicate that

down and we can do age and if we run

that right now we should see abber in 23

being printed to the

console perfect so as we talked about

introduction syntactically the struct

and the classes are very similar so

let's comment this out so we don't get

any compile errors and let's see how

this is going to work so of course we're

going to get error on this line but once

we make our class the error should

disappear from here so instead of struct

person we're simply just going to have

class person exactly the same and

because these are fields we can also

copy these down so we can have public

string name and public int

Edge and then we can have public person

and then string name in Edge this. name

equals name and this. age equals age so

as you can see this is exactly the same

as this except for the fact we have

structure and we have class inside here

now you see how compile error is gone

and if youve won the code we should see

exactly the same

output there we go now the main

difference about classes and about

structures is that you don't actually

have to give these a default value

inside the

Constructor if we just comment this one

out for a

second and if we bring the structure

back and we actually remove the

parameters from here then we're actually

going to get compile errors and it says

that the name and age must be assigned

before it's returned and stroks cannot

have parameterless Constructors now

that's a bit of a problem in certain

cases you might want to create an

instance of something but not actually

derive any values so you could actually

make these into default values you can

have string name equals nothing and int

age equals z and therefore once we place

inside here then there's no problems if

you run the code then you will get the

output this will be nothing this will be

zero and you'll get errors and you won't

get any compile errors doing this

but the point is you have to include

them and you don't have a

choice so if we just comment this back

out now what you'll notice about the

class

person is even if we get rid of it then

it still lets us have it of course we

can't actually give it parameters since

we don't have a Constructor that lets us

have parameters but what you can do as

well is you can overload this and

actually include it as well so you can

have another set that literally let you

define both of

them and then you can even have another

overload that lets you just include the

name without the ede and then also

another one that lets you include the

int age without the name or you include

both the details so in these cases what

you can do is you can store the values

up here as the fields let them use a

default Constructor or only give it the

name or the age or you can actually give

it both so when we come down into here

we actually now have four different

Constructors we can make an empty person

we can make it with an edge with a name

or with both

and what you can do in here is you can

say this.name is equal to nothing and

then here you can say this. AG is equal

to minus one just to default it to a

value that's incorrect so after we've

got this let's have a look at the

different ways so we can give it a

person which gives us an empty value so

if you run that now we get blank and

zero and if we just give it the name

which is Aba then we should get ABA and

minus one yep and then if you just give

it the ede you should get nothing in 23

and if you actually give them both then

you should get both printed out to the

screen and there we

go so now we have four different ways

that we can create our person with our

structure we're only really limited to

one since all of these values need to be

assigned as the structure is created

structures are meant to be used as an

extension to a data type rather than

almost like a mini management system

when we make a class we have so many

options of different ways that we can do

this inside here and later on in the

course we're going to show you how to

include functions inside here and then

eventually do other Advanced Techniques

with classes that aren't directly

available structures if you have a basic

example where you want to extend

something to use inside a function or a

data type like storing name and age

instead of having to do two return types

inside a function then a struct is

perfect the second you want to do more

complicated things or make it a bit more

specific and flexible then classes of

the way forward you'll see it very often

in games where they have struct position

you'll see in video games where they

have something like a struct position

and they might have int X int Y and int

Zed and that's for their 3D position or

they might even just have an X and Y or

you could have something simple like a

rectangle and you can give it a width

and a length so now when you use that

inside the code you're going to have

different flexibilities of the amount of

data types that you can store and then

when you return that back from a

function that'll be okay as well since

you can use this as a data type so if

you want something simple and

straightforward then go for the

the second you want something a bit more

complicated and a bit flexible then you

probably want a class we'll go into more

different situations inside this course

so you understand in which cases to use

what and in most cases you'll notice

that the class is more replicable so if

you wanted to you could ask the user to

enter these details in and then you can

pass them inside the Constructor so we

could say console right line change it

to a right enter your

name String name console. readline and

then copy and pastees down changes into

into a in Edge and then wrap this around

inside of convert in 32 instead of enter

your name it'll be ENT your Edge and

then C these are grade out it means we

haven't used them so we can change abber

to your name and then change 23 to age

perfect so now if you run the code now

enter your name ABA enter your age 23

then we get ABA 23 printed out to the

screen so just a quick recap

Constructors are basically defined the

same way you have public followed by the

class or the structure name and then the

pr inside the brackets and then you can

assign it after without structure you

have to declare all of the variables

inside the parameter and assign them all

down here otherwise you won't be able to

run your code with classes we have the

flexibility of just including one

default function which will just be our

Constructor and even if it does nothing

this is still acceptable and then we

broke it down to multiple sections where

you might have situations where you only

want their name or their age or you

might even collect both to store it if

you collect their name then we'll

initialize age to minus one just so you

know that this is a bad value and if you

declare only the age then will'll

initialize aim to nothing just so you

know that it's an empty value and if you

accept both then we simply assign both

and down here we have access to it we

can even make this a little bit better

by checking these values so we can say

if string is not null or empty of

person. name and we can put a knot

inside here then we can print out this

and then the same thing for age we can

say if person. AG we can say greater

than minus one since we set minus one as

the bad value and then we can move this

line up and let's try run it now so

these two if statements are

fundamentally separate from each other

one is checking the name and one is

checking the age so let's try and

manually type these in and see what

happens so enter your name let's make

this blank and only include the age and

let's see if this runs okay so you had

no name and the age is 23 then you see

we only get printed 23 because it'll

skip over this line as you can see if we

put a break point in now and just

refresh the code we get empty name plus

23 and when we press F10 over this line

it jumps the next one because if we

hover over this you'll see that it

should return us back with false there

we go we get strings null or empty is

false so that we skip over that and

because the age is 23 then this line

going to execute let's run it again and

do the opposite we could say name is Aba

and then age is min one and then we get

ABA printed be not the

edge there we go so if you wanted to fix

these in and type them manually so we

can say

23 there we go we get 23 and if we only

include the

name

AB then we only get Al printed out and

if we include both of

them then we get them both printed out

perfect so now that we've created our

class we've gave it some fields and

we've made our Constructor that lets us

initialize it let's see how we can print

the details out to the console so we can

have a CW tab tab a console right line

and then we can say string interpolation

name callon space and then we can have

our curly braces and we can say person.

name we can access these fields using

the dot operator and then we can say

back sln for the new line and then say

age and the same thing person. AG let's

try run that and see what we've

got so now we've outputed name and age

out to the screen let's see how we can

do this inside a function if you wanted

to place this in different part of your

code then you're going to have to copy

and paste this and as we know this is

bad for our code because it's j a

duplication we want to be able to wrap

this inside a function somewhere so

let's see what we can do we can have a

static string so it can return as back

with this that we can output straight to

the console and we can say return

details and for our parameter we can

have something like string name and int

age because that's what our class is

made up of and inside here we can simply

take this

put it inside here and put a return

before it and then get rid of the person

dot since we have an aim and age

variables as local to the function so

now instead of this line we can

duplicate this down take out the

contents and we can say return details

and then we can place person. name and

person. AG inside here let's run the

code so we get exactly the same output

but the problem with this function is

we're having to type out the parameters

manually we have them here and we're

going to have to to type them again in

here and again for the parameters this

is a bit of a problem cuz we've just

made our class but we haven't really

used it when we're passing it in so

instead of having string name and int

age we can actually duplicate this

method and just comment it out just so

you can see it for reference and instead

of doing this you can actually just pass

in an entire person so now we have

access to person and we can bring this

back and we can say person. name and we

can also say person. age and the reason

why this method is preferred is if you

actually have something else public int

number and then you added another one

inside here in number and then you said

this do number equals number the

parameters won't have to change inside

the function all you have to do is

simply pass in the person and then now

we actually have access to doing person.

number inside here should we need to if

you're passing them all in one by one

like this then you have to append into

number on the end and then add it

straight to here and then also add it

inside here as you have like this it's

easy to pass the class in because all of

these properties above are just simply

used throughout the function so now if

we just bring this

back and let's have a run and see if we

get the same

output which we do name ABA age 23

perfect so now that we've thought of two

functions how to do this we can manually

type in the strings and the integer and

any other parameters that we need all we

can actually pass in the person the

problem with these two approaches is the

whole point of having classes and

structures of of the like is so we can

wrap around lots of functionality inside

it if you want to send this to another

developer for them to use in their

project or maybe this is a file that is

shared within the project then you don't

want them to include a separate function

that is simply outside of the class we

want to include the functions inside the

class so of course as you know these are

functions so inside here we can also

make functions so let's do it so we can

have public and we want a string return

details and then we don't need to pass

anything in the the values that we're

going to be returning are these two

right here which is technically local to

our class so therefore we're not going

to have any parameters I'll explain that

further in a second so we can take this

exact line paste it straight into here

and get rid of the person Dot and get

rid of the person do on this side so

then we have the name variable and the

age variable if you double click on them

you see it references these variables

and the same thing for age the reason

why we don't have parameters is when you

call this function as I'll show you in a

second you call it directly on the

person so the person that you're trying

to print has already got these contents

inside of them so let's have a look we

can duplicate this down and instead of

calling return details and passing the

person you actually do it the other way

around you say the person object dot

return details so now we're calling

return details inside our person

object now let's run the code you see

that the output is exactly the same

except now this functionality is a lot

better our return details is wrapped

inside our class which is the preferred

way now we can actually get rid of these

inside here and then we shouldn't really

use this notation even though it is

technically correct but you want to wrap

all your functionality inside here and

just bear in mind that scope is also

applicable here return details is within

this class which means if you try to run

this function inside the main then it's

not going to node exist this return

details function was able to be used

inside here because this was in the

scope of the class program which is this

curly brace and this curly bra but this

return details is only within the scope

of this class which means you can't just

suddenly use it inside the main so

please bear that in mind when you

produce in these classes and you trying

to understand where everything goes

every function that you place inside

here is accessible through the dot

notation after the object once you've

created the class say person equals new

person and then after we type person dot

then we'll get a list of all the

functions the same way if you have

something else just like this and then

if you do person Dot and then you see

that something has appeared there so all

the functions that you create up inside

in this class for every person that you

make it'll be accessible through the do

notation so just to round up this video

you should always make your functions

inside your class having them inside the

class is the whole point of making a big

class and have lots of functionality

inside if you keep the function that

does exactly the same thing outside of

the class then if you were to share this

file or come back to it in the future

then you're not going to understand why

you've done this and and it's outside

the class keeping everything wrapped

inside the class is the best way forward

in most case

scenarios so now we have our class

person it's got a name and age a

Constructor and a function to return

back the details and we can simply use

it like this and return back the details

like this but so far we've covered how

to make classes Constructors Etc and

assign the values but the values are

only get assigned throughout the

Constructor but what if a different part

of our program the user wants to change

their name or update their age Etc then

what options do we have so you know we

can access our Fields using person. name

and then you can simply type equals and

then type in another name and we can say

person. AG equals 25 now we've changed

these properties if we use the console

right line and return details you'll see

that the values have indeed

changed as you can see there it's

changed the hurry and

25 this is okay except for the fact that

this shouldn't really be possible we

should try and restrict this Direct

corly by the use of gets and sets so for

now we're going to cover fields and how

to restrict certain values and later on

in the course we're going to go through

what properties are so before alter

properties got invented we had to use

gets and sets gets and sets are

essentially functions that will prevent

this from happening so the reason why we

can do this is simply because this

public word is placed right here if we

change it to private it means that name

is still accessible within here and here

which is only the limit of the class but

as you can see it's not applicable here

this is why you need the public Getters

and Setters so I'll explain that what

that means now so we prevent these from

accessing outside the class by making

them private so this functionality no

longer works so what you have to do

instead is for every field that you have

you need to create a GTO and a seter

function so in order to set a value we

can have public and because we're

setting it we don't need to return

anything so it'll be void and we can say

set name and then we pass in string name

and then we simply just say this. name

equals name so when someone call set

name and pass in the name like this we

just override it so let's see how that

looks so if we comment these two lines

out we can simply say person do set name

and then we can say Harry so this line

is directly replaced by this line and

now if you run this we'll see that Harry

should be changed there you go abber is

changed to Harry this is powerful

because what we can do now is restrict

the access inside here and make sure

that the value contains something

genuine we can say if string is null or

empty and then pass the name inside

there if the string isn't null or empty

then we assign it and if it is null or

empty then what we can do inside here is

we can say else this do name equals

nothing and we can keep it blank or we

can use string. empty just to make sure

that we know that the name has been

blank out if they've entered something

invalid if they've entered something

that's valid we assign it if it's

invalid then we don't assign it and we

just initialize it back to nothing and

because our options are endless with

this we can actually make this into

something else we can simply just say

invalid name so then what happens is if

we try and change this to nothing and we

run the

code we can see that we get invalid name

being printed to the screen and that's a

lot better than if we had string.

empty because if you had string. empty

then it would kind of say nothing then

it looks like something's went wrong if

you have something like invalid then

that gives you a bit of a Barr message

so we can have invalid name there so

using our Setter Let's us change our

name from down here without directly

exposing the public if he expose the

public then everyone who uses classes

can simply change the name to whatever

they want having it private and only

changing the name within the set name

function is very preferable because you

can restrict the access and what people

can set the values to if they try to set

it to something that's not valid then we

set it to invalid name whereas before

when we did this and if we make this

public

again we can simply set this to

something bad like null null is a very

bad value but it still lets us have it

and the reason why it's very bad is if

you try to do something like this

person. equals and just some empty

brackets now even if I just leave this

empty the fact that you try call equals

on S inside person. name is going to be

a bit of a

problem so we can say person object the

name property inside it and we checking

if it equals to Aba for example but

because we've just said it to null let's

see what

happens you see that we actually get an

exception it's a null reference

exception because if you hover over name

you see that returns back null nulls are

very bad in this case whereas if you

actually bring our function back and we

make this into a private and then if we

try and take this value our null value

and place it straight inside our set

name if you uncomment it get rid of the

quotation marks and if you actually try

and assign it to null let's see what

happens then we're going to get invalid

name and this prevents us from breaking

our code if a function like equals were

to be called on any of our properties

inside of name so now that we've done it

for our name we can also do it for our

age but before we do that we can also

call a function called get name return

details gives you back these details

in a very specific fashion but what if

you wanted to do something like this

your name is and then you wanted to do

person. name but of course you can't do

that because name is no longer public so

you can't reference it directly so we've

got a set name and then now we need to

do a get name so we can have public and

because name is a string the return type

is going to be string and we can say get

name and this function is very simple it

just returns back name and that's it

there's no no parameters because all it

does is return back a value and in this

case it's just returning back name so

instead of using person. name in here we

can say person do get name open close

the brackets to indicate it's a function

but there's no parameters now you see

that we have no compile errors so now if

you run that you'll see that it says

your name is invalid name so let's

actually give it a

value and we can say Harry again run the

code there you go your name is Harry so

it's officially change it now let's work

on the

edge so just following the exact same

approach we can have a public void set

Edge in age and instead of just doing

this. age equals age let's try set some

boundaries on this we can wrap this

inside an if statement so as for the

condition we want to validate if the age

is successful so we want to do if age is

greater than or equal to zero and age is

less than or equal to 150 so this means

if the age is less than zero or greater

than 150 then this is going to return

back false and then it's not going to

assign the value and we can simply

assign it to minus1 -1 is just so we

know it's a bad value so now that we've

created our set age we can actually make

our get age so we want to return back in

int because that's going to be the data

type for age so we do public int get age

we don't need any parameters cuz as like

the name we're just simply returning

something so we can say return age so

now that you've made the set age and the

get age let's actually use it quote so

we've made our set name and let's say

person do set age and we have 25 inside

here just like above and then now that

we've set the age let's appin this

sentence we can say and your age is and

then person. get age perfect so let's

run the code and see what happens there

we go we have 25 and Harry being

changed so another little tip when we do

in this code I get age as one line and

I'll set age as a couple of lines but

fundamentally only assigning Edge so

what we can do is we can make these into

the tertiary operator so as we can see

here this is the condition if this

returns back true then we assign age our

local parameter and if this returns back

false we assign minus one so we can

actually make this into this. AG equals

if you remember the format of our

conditional operator use condition true

and then condition false so this is our

condition that is leading our if

statement and if this returns back true

then we do question mark and put age in

there and then call on if it returns

back false then it's simply minus one

there we go so this is actually being

entirely replaced by this one simple

line and we can do the same thing for

our string so we can say this.name is

equal to string that is null or empty

pass the name inside there and if that

is true then we assign it to name and if

that is false we say invalid name let's

comment this one out and let's see if

our code runs okay still

hurry 25 hurry 25 and now let's try our

bad values so we can try to set the age

to 200 and the value to nothing and

let's see what happens we get invalid

name minus one and there you

go perfect so that's working okay let's

undo them values and you can see that

this has been shortened completely

another top tip for functions like this

you can actually use something called

Arrow functions and if you've done any

JavaScript this might be quite familiar

so we can have our get Edge and in

instead of open the curly brace at this

point we can actually place this Arrow

inside so if we comment out this one

with arrow functions you can only return

back one simple line so because this is

only one line we can have return Edge

but our functions don't like the keyword

return any variable that you put

straight inside here is automatically

applied that it's a return type so we

literally just put age get age returns

us back with age if this is confusing

then stick to this approach but this can

might tidy up your code because instead

of having all of this and all the curly

braces for one simple line you can use

Arrow function so if you actually copy

and paste but first comment out all of

these functions you can see how small

the code can actually get there we go

and then let's actually have a public

void set age let's put our R function in

and then we can take this one line and

paste it straight into here so you can

see that these two lines are now being

replaced by all of this

and of course we need our int age inside

here there we

go so now we can do the same thing with

our set name we can take

this we can have public viid set name

String name and then have our Arrow

function and then simply paste that in

you can see that this will get a little

bit long now but it's still ideal I've

got the code zoomed in but if you put

that to 100% you'll see that this code

is actually pretty small it's just I've

zoomed in just so you can see the code a

lot

clearer and then finally for public

string and we can get name and then we

simply just do arrow and then name and

you can see that with all this other

code commented we're just relying on

these functions as we just created and

you'll see there's no console errors or

anything else so if you try and run it

you'll see that everything is going okay

of course if you don't like this

notation and you don't have to include

it you can stick with the curly braces I

don't use the arrow functions a lot in

practice because there isn't many

situations where you'd actually use them

and even if you do some people might not

like them or there might be certain

guidelines that you might be following

inside the

company what I do suggest you stick with

is the tertiary operator these are a lot

good and a lot better to use since it

reduces the code drastically if we

actually remove this and I'll paste it

back in just so you can see it for

reference inside the resources but you

can see that these four functions are

now reduced to on one pitch you can see

that they're all got one lines and

they're pretty short so let me undo that

just so you can see the original code

and have it for

reference so there's a lot covered

inside this video so let's just have a

little recap before we finish up so just

to start at the beginning when we

initialize our person with their name

and their age we don't actually have any

other opportunities to change their

value which is where this comes in you

can actually just say a person. name and

assign any sort of value you can put

anything inside there and it'll assign

it directly unconditionally the problems

of doing this is someone might expose it

to null by accident and somewhere in

your code if you're using something like

equals this will actually prevent an

exception of course you can wrap this

inside a try catch but this is

unnecessary because we can prevent this

in the first place it's always best to

prevent an exception then to put

additional cord in like a try catch in

order to catch something that you can

prevent in the first place prevention is

definitely better than the Cure in this

case so having something like a person.

name being exposed it's not so much for

the integer because integers will always

have number values whereas strings they

can be initialized to null there is no

such thing as null when our age that our

default value for an integer is zero so

we don't really have the same issue we

started introducing the name function

and the age function these are used so

we can control what values get assigned

to our local variables and we also have

our get functions get name and get age

so let's explore how these are made

inside our Cass and expand on that and

see how they work so first we need to

make sure that our variables are

actually private they're private so we

can't access them just like this if I

copy and paste this line You'll see

we're going to get a compile error and

this error is because we can't actually

use it because as it says here it's

inaccessible due to its protection level

and the protection level comes from the

fact that this is indeed private it's

private so it's only accessible within

class person so every reference and name

can be used inside here just not outside

so the only way to be able to change the

name now you've made it private is by

enforcing this function the good thing

about this function is we can check if

the value is invalid and then we can

star it if it's valid and then change it

to something else if it's invalid and

then we can wrap this if statement

around in a conditional Operator just to

make it a little bit shorter and in

order to retrieve a name because now

that it made it public we can neither

set or retrieve it so we have our get

name function that simply just returns

it back to the screen nothing special

here and the same thing for our set age

we can check if the age is between 0 and

150 and assign it and if it's not assign

it to minus1 and then again wrap it

around in our conditional operator and

then for get age we can just return age

I demonstrated our functions inside here

you can take all of these on line

functions and actually add them all in

one line without the need of curly

braces if you want to return back in age

then you simply just type in age just

like you can see here and here when you

do assignment you want to specify this.

name equals but when you doing returns

you just need to type in the variable

that you need of course this looks a

little bit cleaner and a bit shorter but

not Everyone likes this notation so it's

completely up to the developer all the

environment that you're working in and

finally we just have our return details

and then we can make use of them just

like this by using person which is the

name of our local variable for our new

instance followed by a DOT and then set

name set age and then get name and then

get

age so now that we're dealing with

classes it's important you focus on the

scope we have a person person here

that's defined within the main which

means it's only Within These two curly

braces so if we have a static void and a

function that did something inside here

we can't access person inside here if we

take out the comment and we try it the

only reference we have is accessing the

class directly not this local variable

if you want to access local variable

from inside this function then you'd

simply have to pass it in like this and

then it'll finally become available as

you can see now there's two and it says

as a parameter and the same goes for

this class above just because we have

name and age up here it doesn't

necessarily mean that we can magically

use name down here if we have something

like a static int defined right here

then we can use this integer inside

these functions as it says there it's

available we can sign that to 10 and

it's also down here available and we can

sign that one to 20 and you see we have

no compil erors but if we take this and

put it inside our return details

function then you're going to get an

exception because X is not available

within that scope and the functional

scope matters inside here as well if you

have a string test inside

here we can just access it in another

function for example The Constructor we

can't just print out test as the screen

the handy things or classes if you want

variables to be available throughout the

class then you put them at the top we

can have that private string test and

there you go you see that the compiler

error is now gone and we give that

initial value and then you can use that

to print to the screen Etc and just to

note when you have a variable that's

called exactly the same thing we have a

private string test up here and we can

say hello then we also have a string

test down here so let me demonstrate

what happens when two variables are the

same so let's move this into our

Constructor so if we run this as it is

the test equals hello and then we print

out test and then run the

code there you go we get hello printed

and just ignore this this is from the

return details function as we've got in

the main down here return details so

we've made our new Constructor and then

assigned it the value with abber and 23

and then we can get hello printed to the

screen but let's say we actually made a

string test inside here and we said hi

instead of hello then which one do you

think it's used the global one or the

local one let's run it and find out it's

actually the local one the compiler will

always prioritize the local variables

over the glob Global variables and this

is the reason why you need to type this

dot because when you use name it's

always going to reference the parameter

when it's name on its own use console

right line and say name and then if we

do after this line and another console

right line and we say this. name then

these are completely different this one

is the parameter and this one is talking

about the variables from the class and

these are known as our Fields local

variables take presidence overall Fields

as long as they're called the same thing

as you can see now says it's assigned

but the value is never used if you take

the string test out then you can see

it's now being

used there you go hello gets printed out

to the screen and there you go the green

line has went because we're using it

down here scope is very important when

you're designing these classes and just

to note that the variables that are

available inside here are not going to

be necessarily available inside here

unless you make them public and even

when you make them public that doesn't

necessarily mean mean that this is still

available magically over here name will

only be available through an instance of

the person class so if we do person.

name now we can see that that's

available as our field so that's why

that makes it

public if we try and make this private

again just to return that value

back and we scroll down you'll see now

we get a compile error because it's

inaccessible because it's outside the

scope because it's now a private

variable

so we've covered what it means to have a

public or a private field if you have a

private field then you're going to have

to use Setters and Getters in order to

work with this field if you make it

directly public then you won't need any

Setters and Getters because the user can

just type in do name after their public

instance so you can have person followed

by the dot and right now you can't see

name tied here and the blue slittle icon

is no longer there the reason why it's

not there is cuz there's no public

Fields if we then change this to

public remove the dot and read it you'll

see that our blue square is now back

because our field is now accessible and

we can assign that to anything that we

want the whole point of making this

private is you only restrict the access

so you know what you're doing and the

reason why I say that is if they enter

something that's invalid then we want to

specify something like invalid if we

give them Public Access then we're not

going to know and we won't be able to

validate what they've entered so in

order to do it through a Setter we can

make it private create our set function

with a return type it's going to take in

a string parameter and this string has

to be the same data type as the prety

you're talking about call it name or

whatever you want it to be and because

these two are called exactly the same

thing we have to use this dot so we're

referencing this name instead of this

name in the parameters and here we're

just using a conditional operator and

we're saying if the string is not null

or empty hence the exclamation point

then we assign it to name name gets put

in this.name and if this were to return

back false then we place invalid name

straight into this. name and for the get

we simply just return a string since

that's a data type for name and then

just return it back and it's that simple

and the same thing for age we validate

the age range set it and if it's outside

this range we can set it to minus one so

as you can see this is a bit long we

have our private variables then we have

two functions one for set one for get

and the same thing for age so these are

called fields and gets and Setters so

I'm going to introduce a notion called

properties and properties make it easier

to do this exact notation so let's now

see how property is created since these

fields are private we need to make

something that's actually public so we

can do something like this we can say

public string and we can say name with a

capital N so now you can see that name

and name are not actually clashing and

we can assign that in here should we

want to and you see we don't need this

do anymore because this is now different

it's a capital N so this one always

references this and this references this

so we need to add something else onto

here so if you create them

both now you can see we can do age

equals age and there'll be no problems

with this so now that we've made our two

new Fields so now we have our two new

public variables which are known as our

Fields let's see how we can turn them

into properties so if you remove the

semicolon you can actually add in some

curve curly braces so inside here we

need a getter and Setter just like we

had down there but we have a quicker

notation for it instead of making two

distinct functions you can actually

create a little section inside these

curly braces to get and set the name so

you got to think of this as a middleman

the same way this is a middleman we call

this function and this function will

affect the name and this is going to be

the same principle we make use of name

with a capital N but it will actually be

affecting the lowercase end variable

these are going to be our new middle BS

and they will directly replace the gets

and sets here so what we can do in here

is we can say get press enter go on the

next line and make some C braces and

then we can also have a set so this is

like our mini get a mini set function

just like we've got here but as you can

see it's a lot shorter we don't need to

give it a distinct name or set the

public or anything else we just give it

a simple set and get so if you have a

look at the compiler error it says not

all cause path return of value because

as it says here this get function is

actually a mini function built into this

property person. name which is our name

with a capital N and then it's do get

and this returns back a string so if we

actually just type in return this then

it gets rid of the compiler error but of

course we don't want to return nothing

we actually want to return name because

remember what I said string name and

intage up here as our private field they

actually start the data the public

string name and the public inage is the

middle mans that coordinates all of the

gets and sets to do with the private

variables so for the set just for now we

can say name equals and then what do we

give it the value of so if we hover over

set it doesn't actually give you any

indication of what it's going to be so

let's have a look if we press control

space then we don't also get the list of

everything that we can add inside here

now it's very difficult to understand

what to assign this to when we have set

name we've gave it a string name

parameter so we can use name down here

so what's our parameter in this case

well the function itself doesn't

actually tell us but I'm telling you

right now that the parameter is actually

just called value and this is a very

default parameter that you'll see

everywhere when you're doing gets and

sets inside a property you don't have to

specify value or anything it just gets

simply assigned in just like here where

we have string name this will be a

string value so it will look something

like this behind the scenes but of

course you can't actually type this in

cuz remember these properties they

trying to give you a short hand on how

to do gets and Setters so you just got

to remember that when you're trying to

set you get the property inserted as

value so you can start that into name so

that's it the name is actually sorted

now so before we do the same thing for

age let's see how we can use this inside

the code so we scroll down to our main

we have a person person and then we have

a console right line that prints the

details so we can actually do person Dot

and you can see now that it's slightly

different if you ignore the edge since

start to return back as a field since we

haven't done that yet you'll see that

name now has a little Cog next to it

sure only properties this is a new icon

that we haven't saw yet so this is our

new icon it says it's going to return us

back with a string and we can actually

execute a get and execute a set straight

on this name then we can say name equals

Harry and we don't get any compiler

errors whatsoever this lets us do it

completely so now if we do another

console right line and we say person do

return details and let's run that and

you should see that the name gets

changed there we go ABA gets changed to

hurry perfect so after we've got person.

name let's see how we can also get the

value so we can just say string

interpolation your name is and then we

do person and followed by a DOT and as

you can see the exact same list that we

got given over here is given right here

as well name also says get and set and

it returns back a property which is a

string type so we can open like this and

you'll notice that we don't have the

parentheses after it and the reason for

that is because the brackets indicate

that you're calling a function but a

property is just a property it's almost

like a variable so you're not actually

needing to put any brackets after it

because there's no function to call so

as you can see this is exactly the same

as this in this case we're actually

setting the value and in this case we're

actually getting the value so let's

comment this line out and let's see what

happens your name is Harry so that's

worked okay so now let's do the same

thing for

age remove the semicolon add the curly

brace we can say get and then return age

and then simply do set and then do age

equals value there we go so now we got

that set up if you return back down here

and we see a person dot so as you can

see now the age is being removed as

being a field as we saw in the blue icon

it's now been turned into a spanner

which means it's a property as shown

here show only properties so now you can

see it returns back an integer and we've

got a get in a set so we can set that to

25 for example and then we can append

onto here and your AG is person. AG you

see that it's a capital A just as this

one is a capital N and now we have

getting set available and again we don't

need the brackets inside here since this

is a property not a function now let's

run it we should see Harry 25 there you

go your name is Harry and your age is

25 perfect

so as you can see now is instead of

having our set name and get name which

are these two functions we actually have

them contained within a

property we call this property and it

affects these variables but as you can

see just as these functions below were a

middleman we've now moved the middleman

into these properties so as these are

only one line you're probably thinking

there's probably a better way of doing

this and it's a lot quicker for syntax

and you're right there is so let's

explore that so I said before about

about Arrow functions when you're doing

something like this get name you can

have public string get name and then you

can simply do Arrow name this is a very

common string function get a name that

just returns back a value and you can

make that into an arrow function by

literally just putting back name so we

can actually do the same thing but for

our properties so these both contain one

line so we can actually minimize this

and if we just block comment this

out we can say public string name and

then we can have get and then the same

thing with the arrow function when we

doing Arrow function down here you

simply won't use the return keyword you

would just type in the variable you want

to return so we can say get arrow and

then simply lowcase name and then add a

semicolon just so you know that that

section is ended and then straight after

we can have set and then arrow and then

name equals value just like that so as

you can see these contents are exactly

the same we've actually returned them

back in a short space and of course here

as we got a compile error it just

expects a semicolon to be right at the

end here there you go and now we do the

same thing for our

age we can do public int ede get arrow

ede and set Arrow age equals value

perfect so now you can see that this has

been drastically reduced if I cut this

just underneath you'll see that almost

all of these lines are just replaced

into a two and you'll see that our

functionality will still work exactly

the same if we just run the code Harry

and 25 is being reassigned over our

default variables perfect of course now

if you want to add some more

functionality inside here for example in

our set name we had a little check that

makees sure that it's a valid name

before we assign it so we actually take

this and paste it over here then you see

the lines grown quite a lot so what's

pred to do is if you're going to have

any data inside here that does a little

bit of logic then it's best to keep the

curly bra is since you can have a bigger

output and it looks a bit more sensible

if you're just simply getting and you're

setting the variables then you can leave

this notation so let's undo this and

bring back the original ones in this

case there we go and then we can take

that line and in the set we can actually

replace it here so as you can see this

is a little bit grayed out so let's put

the semicon at the end and let's see why

this is grayed out name can be

simplified so what we're doing now is

name and all of these variables are

actually looking at the private variable

whereas if you actually look down here

and we uncomment this you'll see that

set name if we double click on this one

this is the only reference to it which

is our private variable up and the

reason why this doesn't need to be used

in this case is because our parameter is

now called

value so it's saying the name is equal

to checking if the value is null or

empty assigning the value into name if

not and then if it is empty then we hide

invalid straight into name in the case

of our set name our name was our

parameter the same goes here if we

change this to Value we can change these

two for Value as you can see now this

dot is actually grade out and it can be

simplified to just simply name and the

same principle applies above so let's

comment these back out and scroll back

to the top so now that we've assigned

name there we go we've got our check

inside there and you can also leave this

on one line if you want you can even

drop the curly brace in just so it looks

like this instead of having it all on

one line so you could do this and this

would be applicable as well but the

second you start to put it all on one

line then it gets a little bit messy

quickly so if you leave the outer

bracket just like that then it can be

pretty short since you don't need more

curly braces so now that we've done that

for the name let's do it for the age as

well so we had this. age we check the

range and we assign the relevant values

so let's take that paste it over this we

don't need this dot anymore and age in

this case is actually going to be the

value gets passed

in to replace all the ages with value

there we go so if the value passes the

range check we put the value inside age

or not we can put minus one inside age

and again we can have the same thing we

can use our arrows inside here there we

go so now we've got our Cod drastically

reduced so we went from these big

functions that have to be defined with

specific names over to our properties

and they went from really small to just

a little bit bigger but now they have

advanced connections just to make sure

that the variables are okay before you

assign it in so now that we've got our

properties let's have a look so inside

our Constructor we don't also need to

use our local variables which is our

private ones directly we should actually

get rid of this now and we should always

do everything through our properties

name equals name and because this is a

capital and this is a lower case we

don't need this dot in

there there we

go so what you should do in the return

details function is also use the capital

n and the capital age so when you hover

over these you're actually referring to

the property because like I said before

these are the middleman to communicate

with the private variables you shouldn't

need to access the private variables

directly you should use the middle man

as much as possible so now that we've

done that I have one last thing to

introduce so if we actually abandon all

of this code just to keep it for

reference we have something called an

auto property and you briefly saw it

when we saw it down here so if we

actually just bring them back for a

second and if you hover over a name down

here it says string name get and set in

the curly brace but you see how the get

and set is empty it just has two values

inside there and it just ends a curly

brace with no actual logic you see in

our get we're saying age and our set

with saying age equals this so when

we're doing Auto properties what you can

do is you can actually make these public

again change these to a capital N

changes to a capital A and just straight

after it you can say Get Set just like

that and what that will do is although

they're actually made public what it's

doing behind the scenes is actually

doing this for you it actually has a

private and a public for you behind the

scenes this is just a Shand these are

what's called a auto property what it

does is it makes an anonymous property

behind the scenes as I'll show you in

Microsoft documentation right now as it

says here in c three or later Auto

implemented properties make property

declaration more concise when no

additional logic is required and what

that means is no additional logic all of

these are additional logic if you're

just simply assigning a value and

reading it back just like here then this

is no need to write get name and set

name if all you're doing is getting and

setting it if you're getting and setting

it but there is a certain amount of

logic as we have here we essentially

have a conditional operator that's

making a subconscious decision about

what to assign the name to but if you

just simply assign in something like

this then an auto property is perfect

they also enable client code to create

objects when you declare a property as

shown in the following example the

compiler creates a private Anonymous

backing field that can only only be

accessed to the properties get and

sets as you can see here just like in

our example we have public int something

and then get in set and then they have a

public in something with the get in set

as well and they can use it just here to

access it

directly and because they're simply just

assigning and getting the values and

there isn't any additional logic then

this is the best way to do it and you

get as it says here an anonymous private

backing field so this would be the same

thing as doing this private string name

and private int age so once you do that

and you make this into the get and set

properties which are these two right

here this and this line together make a

property what the auto implemented

property does is actually combine this

line and this line together and make the

private one behind the scenes so the

programmer doesn't see it but it will be

applicable when the program runs in the

compiler and then you only get publicly

exposed with this parameter which will

be our name property so it will actually

make the private for you if you just

keep it like we had it a second

ago just like this so if you leave it

like this it will actually create the

private variable behind the scenes as it

says here it's Anonymous backing field

and it can only be accessed through name

and Edge and as you can see none of our

code has actually changed all of these

still function okay and if we run the

code we should still get Harry and

25 so just to sum this video up since

there was a lot covered the bottom line

is if you're going to have any sort of

values that require any logic then you

should use normal properties if you're

simply just going to assign and get the

value and it doesn't matter and you have

no control over it then you can use the

auto implemented properties since that

will do the same thing with less code

using the gets and sets is the old way

of doing this and you should always use

the properties going forward gets and

Setters are very helpful to know just so

you understand what they are and why

they exist but you should note that

properties are the best way forward

properties give you access to doing the

same logic as it says inside here if you

do an auto implemented properties then

you're not allowed to use the logic

inside the set or the get so if you

don't want to do any logic then don't

use the auto implemented properties only

use the normal properties to make a get

and Setter you just do set name get the

parameter and assign the local variable

and the get just returns it getting back

a property you want to capitalize your

private variable if you had private

string name with a lowercase n you want

public string name with a capital N you

get the name and then you can set the

name with some sort of conditional

operator or any if statement or anything

inside here and the same thing goes with

the age you can have a public int age

with a capital A and A Private in age

with a lowas A you can get the age and

then set the age with a conditional

operator again or any other code if you

don't require any logic like these two

lines indicate then you can simply just

just use the auto properties as

demonstrated above here and they can be

used quite easily throughout the

Constructor and our functions and even

outside the function when the user is

trying to call

them but one thing that we haven't been

able to solve and you may not have

noticed this as a nuisance the problem

is when you try to return details about

something we're having to call this

function every single time if we have an

in age for example made that equal to 23

and we did console right line and simply

placed age inside the brackets we don't

have to do anything like this because it

simply just prints the value out if we

run the code you'll see that it simply

just says 23 this should be pretty

simple for our person as well but it's

not we need to call return details every

single time we want to print the

properties and if we don't do this the

only way to do it is by making some

string interpolation and we can say

person.

name and then also include person. AG

Etc and then that can print out to the

screen just like that

of course it doesn't have the same

format in but we can also just take this

place it straight inside here add our

person dot before them person Dot and

there you go then you get exactly the

same output as Callum return details but

of course you don't want to do this

every time and you certainly don't want

to have to type in return details

function every single time as well you

want to keep it as just person now of

course this is not going to work

Straight Out of the Box let's try run

that and see what happens so we get

string override person and what's going

on here is it's saying names space is

string override and then it's a class

person so it's just printing out this

person object but it's not really doing

anything because we haven't really told

it to do something so what we can do

here is we can actually override the two

string method so let me explain so let

me set up a couple of examples just to

show you what's going to happen at the

end so right now we call return details

to return these details what we can also

do is say dot two string and then we can

also do these three options return the

details convert it to a string or just

print the person straight to the console

at the end of this little section we're

going to make all three of these print

out the same values so let's have a look

now two string and printing out normally

these two lines right here are actually

doing exactly the same thing behind the

scenes when you place anything inside

these brackets inside a console right

line it will try and convert it to a

string anywhere so whether you put two

string or you leave it as person the

console right line function will still

accept it so just coming out the age for

the time being in order to make the two

string function work as well as just

placing person inside the brackets we

need to make a special function which is

an override function so let's have a

look so just underneath our return

details still within the scope of the

class we say public and then override

after we press tab we can follow it by a

space and we can see the functions that

we can override so in this video we're

actually going to cover two string and

do equals get hash code will actually

serve as a default hash function if I

show you the the documentation it says

here a hash code is numeric value that

is used to insert and identify an object

in a hash based collection this is

normally use when you're doing hash

functions as it says here and for the

time being we're not actually going to

be using this right now so the two we

can do a two string and equals but as

you can see our two string is available

right now we'll cover equals as an

extension in a minute so let's double

click on our two string and we get this

little template placed in if you don't

want the template then it's just an

override if returns back a string since

it's converting to string it needs to be

this exact notation if you drop the T

then it's got nothing to override now

you go be a compile error because

there's nothing to override itself so

play two string in the capitals there's

no parameters passed in and then we're

going to be returning something so the

thing that we're going to be returning

is exactly the same as our return

details function we actually have two

options here we could say return and

then return details so what that will do

is it will go to this function it will

call this function grab that and

essentially place inside here and then

return it back to the console in the

ideal world we don't actually need this

return details function so we could

comment it out but I'm going to leave it

in just so the demonstration doesn't

break down here so we can take this and

place it straight inside here now we

have two functions that essentially do

the same thing but the advantage is this

function is something that needs to be

called explicitly do return details

whereas this function the two string

override actually just gets called

naturally without having to add any

extensions so if we run the code now

you'll see that now they all equal

exactly the same value we get three

sections that have this maybe we can

place back SLT instead just so we can

have them all in the same

line there we go so you can see all

three are exactly the same so what we

can do now is if we comment this option

and we comment out this function we

don't have to include two string if we

don't want to we can also comment this

one out and we can keep it just as

person so as we do when we declare the

integer we say integ equal 23 and then

we simply print out and this is exactly

the notation that we want it should

really be this simple there you go one

line creates the person and one line

with just a variable name goes inside

the brackets to print them out the same

thing here person person Edge and Edge

and let's run that code now and there

you go you get the person printed and

the edge printed exactly and

straightforward as you may think it

should be so now that we've done that

let's explore what the equals function

needs to be done let's make another

person we can say person test equals new

person and we can have hurry age

23 then we don't need to print them out

in this example we just need to

demonstrate this equals function so if

you remember with strings we can have a

string called abber for example and we

can say do equals straight after it we

can say if ABA is equal to hurry then we

can do something inside here what I'm

trying to demonstrate is once you've got

an object you can place do equals and

then you can compare it like that so you

can also do that without classes so we

can say person do equals and then equals

to test and in here we could just say

same let's try and make these as same as

possible and see what happens so let's

keep the name exactly the same just like

that and let's copy the 25 down just

like that so now these two are

instantiated exactly the same way let's

see what happens when we've run the

equals then we don't get anything

printed which means they're not the same

so because this doesn't automatically

tell us that these two are exactly the

same we can override that and provide

our own functionality just like we did

with the operate overload we override

equals we get passed in an object and we

need to check something inside it so

let's see what we can do inside here so

in order to check if something is equal

to another thing what can we do so we

have a name and age if this one is the

same as this and this is the same as

this then two people are exactly the

same so let's try that out and see what

happens so we can say name which is the

property inside the class that we're

currently inside

and then we can use equals because this

is just a string parameter and then we

can say that equals to

objectname but you can see we've got a

little problem here this object is very

generic it's just an object every class

that you create is derived by an object

what that means is every class or

integer or double at the end of the day

is also just known as an object through

inheritance which we'll discuss further

on this course but just know that

everything inside C is always an object

object somewhere down the line so what

that means is we have to convert it from

an object to our custom class which is

person in this case so we can use this

thing called casting so we can say

person person which is just to find a

new variable and we can make that

immediately equal to object as

person so what we've done here is we've

said our object which is this parameter

is currently an object right now we want

to cast it as a person which is kind of

like converting into a person and then

play placing the values inside here so

now if we get rid of this comment and

instead of using object we actually have

a new local variable called person so

then here we can say person. name there

we go now we have access to the person

property since we've converted this

object into a person and of course we

know that we have name and age

available so if the name is equal to the

personname and the age is equal to the

person.

AG then we must have a match and of

course want to keep using the properties

we're going to use a capital A and there

we go so we run the conversion on one

line and then we check if they're equal

to each other now in this specific case

you can actually pass anything inside

here so let's try it we can pass Five

inside here and as you can see there's

no compile error cuz like I said five is

just an integer which is an object at

the end of the day if we make it a

double that works as well there is

literally no compile errors and even if

you put M to make it into a decimal

again there's no compile errors because

they're all object at the end of the day

so let's pass test in there what you

will have to know is if you do

accidentally pass in a double for

example like this you're going to hit an

error here which will be a runtime error

it will try and convert it as soon as it

hits this line and obviously you can't

convert a double into our person so what

you could do just to wrap it around you

could say if the object is a person then

we can proceed with a conversion just

like this and then what you can do for

safety is just outside of this you can

actually just return back false just so

the user knows that this isn't equal to

each other so if the object is a person

then we convert it as a person is is

used for checking and as is used for

converting is this object a person and

if it is then we try and convert it and

then return back if they're equal to

each other and if we accidentally pass

something in that's not a person then we

just return back false so let's just

demonstrate this

first not the same so let's just save

five inside here it says not the same so

let's actually go into this place a

break point and let's run it

again hover over object then we get

five if we place this straight inside

the watch you can see object is person

is returning back false so it's skipping

this entire function and going into

return false and then it's returning

back false so we get not same let's stop

the program change this over to test and

rerun it using F5 and now we can see

object is person is is actually set to

true so now if you put the object inside

here you can see that generically it's

an object right here it says object so

what we can do now is we can place

person down here as well and you see

that person doesn't exist but if you

just give it a second and we change this

to just the

P there we go so obviously the person

doesn't exist cuz we're only up to this

line we press F10 and F10 again so now

it's created the variable and f101 so

skip over it and now you can see the

object has went from type object to type

string. override. person string override

is the name of our namespace and do

person with a capital P is the name of

our class now you can see that the

object and the values are exactly the

same 25 ab and 25 ABA as you can see

right here so now both of them are

exactly equal to each other so when we

check this name here is Aba name here is

ABBA age 25 and age is 25 so this must

return back true and we can check that

by highlighting everything dragging and

dropping it down here and we can see it

says true there so when it returns back

to our code it's going to go and print

their

same perfect there you go so that's it

for this video but let's just have a

recap before we wrap up so before this

video we'd always print the details out

like this person do return details

obviously we don't have that function

anymore so let's just bring it back

quickly there we go so we use return

details and this is just a bit long have

to do this every single time if if you

want to print the details of the test

object as well you have to do test Dot

and then return details again it'd be so

much easier if we could simply just use

it like this as you would do with a

normal variable like an integer double

string Etc and now it's made possible by

using our public override string two

string function it will contain exactly

the same contents as our previous

function except we won't have to go

through an additional function just to

print out the details we can override

the two string and then we can call it

straight in the console like this and

finally when you're doing equals inside

an object you can actually build in some

custom functionality we can convert the

person using object as person but first

before doing the conversion you want to

check if the object is indeed a person

type before doing the conversion this

will give you a runtime error on this

line so let me just demonstrate that

before we continue so if I comment out

this one and actually just change this

into

5D and then let's press into the chorde

right

here it's going to hit this line if I

press F10 then it's going to try and

convert it but you're going to get back

null and then if you run the code again

then you're going to exception thrown

here you're going to get a runtime

exception because it's a null reference

we're trying to run the equals function

on something that is null which is right

here null reference exception so you

shouldn't do this you should also make

sure that these are correct values

before doing it this is a form of error

checking if you don't do this then

you're going to have to wrap this inside

a TR catch and it will look something

like this and and the cord will be

considerably longer you can place these

two

lines inside here and then place your

cat inside here etc etc and you can

return false inside here but as you can

see the code is a bit more complicated

now and there's no reason for this extra

complication if you can prevent it with

an if statement so let's undo

that so what's best in this case is to

say if the object is of type person then

we can run the conversion if we run the

conversion and it's not of type person

then as you can see it's going to return

back null for the person and then when

you run this line it's actually going to

return you back a null reference

exception at this point but anyway the

whole point of this equals is to check

if two objects are going to be equal to

each other so we keep this back to test

because this is a custom classes you

can't just simply do person equals

equals test and assume that that will

just work these aren't buil-in

functionalities for custom classes we

covered operate overloading where you

can actually overload what you do with

the equal sign but we didn't cover the

do equals which is what we're doing

today in this video as well as the two

string this is a different kind of

overriding because in the other one when

we're doing operator overloading that's

specifically an operator that you're

just changing the parameters of whereas

this one is a strict override of a

function equals and the functions two

string this will make it easier to print

your custom classes out to the screen as

well as comparing them just like this

person. equals putting test inside the

bracket is a lot easier and quicker and

you can build in your own custom

functionality if you want only had the

age in there then you can compare the

age maybe you have a lot more properties

and you can always just chain them

inside a big if statement that's fine as

well but the point is you have full

control over how you compare your custom

classes maybe you had a list of names

inside a dictionary for example and you

wanted to add a new name or a new age or

a new user to this dictionary but first

before you add a new user to the

dictionary you want to check if the user

already exists so maybe you could have a

system where it uses the equals function

and it Loops through all of the

dictionary items and it checks if all

the values are not equal to this one if

you didn't build in this functionality

so you could do the equals function then

you won't be able to determine if this

one is equal to this one and now with

your equals function overrided you can

now have the functionality to do so

thank you for watching this C course I

hope you found it helpful in your

journey to becoming a proficient C

developer if you have any questions or

need further clarification on any topic

we have covered please don't hesitate to

leave a comment below and I will do my

best to assist you for those of you who

want to dive deeper in a cop consider

checking out my udemy course you'll find

more comprehensive lessons and Hands-On

exercises to enhance your skills

remember practice makes perfect keep

coding and exploring and I wish you all

the best on your programming Journey